model-evaluation2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## করণীয় ইভ্যালুয়েশন প্রসেস: ট্রেইন/টেস্ট ভাগ \n",
    "জুপিটার নোটবুকের লিংক https://github.com/raqueeb/ml-python/blob/master/model-evaluation2.ipynb\n",
    "\n",
    "ডাউনলোড করে নিন নিজের ব্যবহারের জন্য, ধারণার জন্য ধন্যবাদ কেভিন মার্কামকে। ডেটাস্কুল। "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"মডেল ইভাল্যুয়েশনের ধারণা\" চ্যাপ্টারের দ্বিতীয় প্রস্তাবনা দেখুন। \n",
    "\n",
    "১. পুরো ডেটাসেটকে ভাগ করে ফেলি দুভাগে। ক. ট্রেনিং সেট খ. টেস্ট সেট।\n",
    "\n",
    "২. মডেলকে ট্রেনিং করাবো \"ট্রেনিং সেট\" দিয়ে। \n",
    "\n",
    "৩. মডেলকে টেস্ট করবো \"টেস্ট সেট\" দিয়ে। সেটাই ইভ্যালুয়েট করবে কেমন করছে মডেলটা। \n",
    "\n",
    "৪. আমাদের সাইকিট-লার্নে এই কাজ করার জন্য train_test_split নামে একটা ফাংশন তৈরি করে দেয়া হয়েছে কাজের সুবিধার্থে। শুধুমাত্র কনভেনশনটা জানলেই চলবে। "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "আইরিস ডেটাসেট নিয়ে কাজ করার আগে একটা উদাহরণ দেখি। সাইকিট লার্ন ডকুমেন্টেশন থেকে নেয়া। আগে আপনাদেরকে দেখিয়ে নিয়ে আসি X এবং y এর ভেতরে কী আছে? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "# ভুলেও বোঝার দরকার নেই কিভাবে আমরা X, y জেনারেট করলাম \n",
    "X, y = np.arange(10).reshape((5, 2)), range(5)\n",
    "# আমাদের দেখতে হবে কি আছে X এর ভেতরে?\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# এখন দেখি কি আছে y এর ভেতর। \n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# এর মানে ০ থেকে ৫টা সংখ্যা, লিস্ট কমান্ড দিয়ে দেখি বরং \n",
    "list(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "এখন আসি কাজের কাজে। কষ্ট করে X, y ম্যানুয়ালি আলাদা না করে ডেকে নিয়ে আসি train_test_split ফাংশনকে। সাইকিট লার্নের model_selection মডিউল থেকে। আমি যদি আলাদা করে কিছু না বলি, তাহলে সে আমাদের এই ৫ লাইনের ডেটাকে ৭৫% ট্রেনিং আর ২৫% টেস্ট ডেটাসেটে ভাগ করবে।  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "একটু ভালো করে লক্ষ্য করলেই দেখবেন নিচের কমান্ডটা একটা সাইকিট লার্ন কনভেনশন। এই স্টাইলে ফলো করে সবাই। এটাই ব্যবহার করবো আমরা। শুরুতে কপি করে চালাবো এই কনভেনশন। train_test_split পুরো ডেটাকে ট্রেনিং আর টেস্ট সেটে ভাগ করার আগে দৈবচয়নের মাধ্যমে (random_state) শাফল করে নেয় কাজের সুবিধার্থে। মনে আছে শুরুতে টার্গেট ভেক্টর 0,0,0 এর পর 1,1,1 অথবা 2,2,2 হওয়ার কারণে শাফল জরুরি। তবে, random_state=? ভ্যালু হিসেবে যা ব্যবহার করবেন সেটাকে এক রাখতে হবে পুরো এক্সারসাইজে। মনে রাখুন X ভাগ হবে X_train, X_test দুভাগে। সেখানে y হবে y_train, y_test দুভাগে। "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "চলুন দেখি X_train, X_test, y_train এবং y_test মধ্যে কী আছে? খেয়াল করুন কিভাবে পুরো ডেটাসেট ভাগ হয়েছে?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [8, 9],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ৫টা রেকর্ডের মধ্যে ৩টা এসেছে এখানে \n",
    "X_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 2]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# টার্গেট ভেক্টর আসতে হবে ওই ৩টাই \n",
    "y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [6, 7]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [3, 4]]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_test_split(y, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "দেখেছেন তো কিভাবে পুরো ডেটাসেট ভাগ হয়ে গেছে? এখন আসি আইরিস ডেটাসেটে। শুরুতে আগের গল্প। পপুলেট করে নেই ফিচার আর টার্গেট রেসপন্স। "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ধাপ ১"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# শুরুতে লোড করে নেই আইরিস ডেটাসেট \n",
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "\n",
    "# ফিচার আর টার্গেট রেসপন্স চলে যাচ্ছে X এবং y\n",
    "X = iris.data\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4)\n",
      "(150,)\n"
     ]
    }
   ],
   "source": [
    "# train_test_split চালানোর আগে অ্যারেগুলোর সংখ্যা দেখে রাখি \n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ধাপ ২"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ইমপোর্ট করছি train_test_split ফাংশনকে \n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "এই জিনিস থেকে কী পাবো আমরা?\n",
    "\n",
    "১. আলাদা আলাদা ডেটা দিয়ে মডেলকে ট্রেইন এবং টেস্ট করানো যাবে।\n",
    "\n",
    "২. টেস্ট সেটের 'রেসপন্স ভ্যালু' আমরা যেহেতু জানি, সেজন্য সেটার পারফরম্যান্স জানা যাবে। \n",
    "\n",
    "৩. টেস্টিং অ্যাক্যুরেসি ভালো হবে যখন দুটো আলাদা আলাদা ডেটাসেট। মডেলটা 'জেনারেলাইজড' হলো নতুন আউট অফ স্যাম্পল ডেটা নিয়ে কাজ করার জন্য।\n",
    "\n",
    "৪. ডিফল্ট সেটিংস ধরে রেকর্ডকে ভাগ করে ৭৫% ডেটাকে ট্রেনিং আর ২৫% ডেটাকে টেস্ট ডেটাসেটে ভাগ হয়ে যাবে। ৭৫% হচ্ছে ১১২টা রেকর্ড। ২৫% হচ্ছে ৩৮টা রেকর্ড।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(112, 4)\n",
      "(38, 4)\n"
     ]
    }
   ],
   "source": [
    "# নতুন  X অবজেক্টগুলোর রেকর্ড সংখ্যা \n",
    "print(X_train.shape)\n",
    "print(X_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(112,)\n",
      "(38,)\n"
     ]
    }
   ],
   "source": [
    "# নতুন  y অবজেক্টগুলোর রেকর্ড সংখ্যা \n",
    "print(y_train.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ধরুন, আপনার বন্ধু নাছোড়বান্দা। সে ডিফল্ট সেটিংস নিয়ে সন্তুষ্ট নয়। তার কথা হচ্ছে ট্রেনিং আর টেস্ট সেট ভাগ করতে চায় ৬০-৪০% ভাগে। তার জন্য আপনাকে যোগ করতে হবে test_size=0.4 মানে ৪০%। "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "দেখে নেই নতুন ভাগ। "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60, 4)\n",
      "(60,)\n"
     ]
    }
   ],
   "source": [
    "# নতুন  X অবজেক্টগুলোর রেকর্ড সংখ্যা \n",
    "print(X_test.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ধাপ ৩"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=3, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# আগের মতো KNeighborsClassifier ইমপোর্ট করি \n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "# মডেলকে ইনস্ট্যানশিয়েট করলাম \n",
    "# যদি \"কে-নিয়ারেস্ট নেইবার্স\" ক্লাসিফায়ারের নেইবার ৩ হয়\n",
    "knn = KNeighborsClassifier(n_neighbors=3)\n",
    "# মডেলের মধ্যে সম্পৰ্ক তৈরি করি X_train এবং y_train দিয়ে\n",
    "knn.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ধাপ ৪"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.966666666667\n"
     ]
    }
   ],
   "source": [
    "# প্রেডিকশন করছি টেস্ট সেট ধরে \n",
    "y_pred = knn.predict(X_test)\n",
    "# প্রেডিক্টেড রেসপন্স ভ্যালুর (y_pred) সাথে তুলনা করছি \n",
    "# আসল রেসপন্স ভ্যালু (y_test)কে \n",
    "# আগের মতো ইমপোর্ট করলাম metricsকে \n",
    "from sklearn import metrics\n",
    "print(metrics.accuracy_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### যদি \"কে-নিয়ারেস্ট নেইবার্স\" ক্লাসিফায়ারের নেইবার ৫ হয়"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.966666666667\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=5)\n",
    "knn.fit(X_train, y_train)\n",
    "y_pred = knn.predict(X_test)\n",
    "print(metrics.accuracy_score(y_test, y_pred))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}