hw4_98722098.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nUXoMKBNL2BB"
   },
   "source": [
    "\n",
    "<h3 align=\"center\">به نام خدا </h3>\n",
    "<h2 align=\"center\">تمرین سری چهارم </h2>\n",
    "\n",
    "\n",
    "<p align=\"right\">در این تمرین می خواهیم با کمک دانسته های خود از توزیع نرمال یک متغیره یک دسته بند طراحی کنیم</p>\n",
    "\n",
    "<p align=\"right\">برای پیاده سازی مدل ها از کتابخانه  استفاده کنید scikitlearn</p>\n",
    "\n",
    "<p align=\"right\">https://scikit-learn.org/stable/</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UzYY1KuUPu2Z"
   },
   "source": [
    "# خواندن داده ها"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0v0tV8s9P4xZ"
   },
   "source": [
    "<p align=\"right\">ابتدا داده ها را از کتابخانه می خوانیم و سپس داده ها را به دو دسته ی آموزش و آزمایش تقسیم بندی می کنیم</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "3wyhQpoQQgQ0",
    "outputId": "8f4cdba2-a3f2-4f35-cada-696f1d225c17"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "our dataset has 4 features. for more information about data surf the web\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "iris = datasets.load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "# store the feature matrix (X) and response vector (y) \n",
    "X = iris.data\n",
    "y = iris.target\n",
    "print(\"our dataset has \" + str(X.shape[1]) + \" features. for more information about data surf the web\")\n",
    "# splitting X and y into training and testing sets\n",
    "#you can change the test size, fit model with more or less data and see results\n",
    "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=1) \n",
    "\n",
    "import numpy as np\n",
    "from math import pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.1, 3.5, 1.4, 0.2])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Fq4rKK30R9fz"
   },
   "source": [
    "### q1) print the number of train and test data and number of classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RQy7kw4pSR8l"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of train data is : 90\n",
      "the number of test data is 60: \n",
      "there is 3 different classes in the dataset\n"
     ]
    }
   ],
   "source": [
    "print(\"the number of train data is : {}\".format(len(X_train)) )\n",
    "print(\"the number of test data is {}: \".format(len(X_test)) )\n",
    "print(\"there is {} different classes in the dataset\".format(len(set(y))) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GDB-hbPVSpHt"
   },
   "source": [
    "# آموزش یک مدل با فرض گوسی بودن توزیع داد ها"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Nqd2cq44Tksm"
   },
   "source": [
    "<p align=\"right\">فرض کنید می دانیم که داده های ما از یک توزیع گوسی پیروی می کنند و همچنین ویژگی ها از هم مستقل هستند لطفا با کمک فرض های مساله و بدون کمک از مدل های آماده یک مدل برای دسته بندی کلاس ها آموزش دهید . دقت کنید که نباید از کدهای آماده استفاده کنید و فقط مجاز هستید برای فرمول های پایه مثل میانگین یا واریانس از توابع آماده استفاده نمایید</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_c0 = np.array([ X_train[i] for i in range( len(y_train) ) if y_train[i] == 0 ])\n",
    "x_c1 = np.array([ X_train[i] for i in range( len(y_train) ) if y_train[i] == 1 ])\n",
    "x_c2 = np.array([ X_train[i] for i in range( len(y_train) ) if y_train[i] == 2 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate mean and variance.\n",
    "def get_mean_var(df):\n",
    "    features_count = df.shape[1]\n",
    "    mean , var = np.zeros(features_count) , np.zeros(features_count)\n",
    "    for i in range(features_count):\n",
    "        mean[i] = df.transpose()[i].mean()\n",
    "        var[i]  = df.transpose()[i].var()\n",
    "    return mean, var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_c0, var_c0 = get_mean_var(x_c0)\n",
    "mean_c1, var_c1 = get_mean_var(x_c1)\n",
    "mean_c2, var_c2 = get_mean_var(x_c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate P(Ci)\n",
    "p_c0 = len(x_c0) / len(y_train)\n",
    "p_c1 = len(x_c1) / len(y_train)\n",
    "p_c2 = len(x_c2) / len(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_p(X,mean,var):\n",
    "    return (-np.log(np.sqrt(var))-((X-mean)**2)/(2*var))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = np.zeros((4,len(X_test)))\n",
    "\n",
    "for i in range(len(X_test)):\n",
    "    temp_0 =  calc_p( X_test[i,0], mean_c0[0], var_c0[0] ) \\\n",
    "            + calc_p( X_test[i,1], mean_c0[1], var_c0[1] ) \\\n",
    "            + calc_p( X_test[i,2], mean_c0[2], var_c0[2] ) \\\n",
    "            + calc_p( X_test[i,3], mean_c0[3], var_c0[3] )\n",
    "    \n",
    "    G_0 = -.5*np.log(2*pi) + temp_0 + np.log(p_c0)\n",
    "\n",
    "    temp_1 =  calc_p( X_test[i,0], mean_c1[0], var_c1[0] ) \\\n",
    "            + calc_p( X_test[i,1], mean_c1[1], var_c1[1] ) \\\n",
    "            + calc_p( X_test[i,2], mean_c1[2], var_c1[2] ) \\\n",
    "            + calc_p( X_test[i,3], mean_c1[3], var_c1[3] )\n",
    "        \n",
    "    G_1 = -.5*np.log(2*pi) + temp_1 + np.log(p_c1)\n",
    "\n",
    "    temp_2 =  calc_p( X_test[i,0], mean_c2[0], var_c2[0] ) \\\n",
    "            + calc_p( X_test[i,1], mean_c2[1], var_c2[1] ) \\\n",
    "            + calc_p( X_test[i,2], mean_c2[2], var_c2[2] ) \\\n",
    "            + calc_p( X_test[i,3], mean_c2[3], var_c2[3] )\n",
    "    \n",
    "    G_2 = -.5*np.log(2*pi) + temp_2 + np.log(p_c2)\n",
    "    \n",
    "    g_0 = np.exp(G_0)\n",
    "    g_1 = np.exp(G_1)\n",
    "    g_2 = np.exp(G_2)\n",
    "    \n",
    "    p[0][i] = g_0/(g_1+g_0+g_2)\n",
    "    p[1][i] = g_1/(g_1+g_0+g_2)\n",
    "    p[2][i] = g_2/(g_1+g_0+g_2)\n",
    "    \n",
    "    p[3][i] = np.argmax([p[0][i], p[1][i], p[2][i]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wkv9HCmSWAk0"
   },
   "source": [
    "<p align=\"right\">اکنون با کمک داده های آزمایشی دقت مدل خود را بسنجید</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy = 0.95\n"
     ]
    }
   ],
   "source": [
    "y_pred_GNB = np.array(1 *(p[3]==y_test))\n",
    "print('Accuracy =',(np.count_nonzero(y_pred_GNB)/len(y_pred_GNB)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9V49EZ73XsvG"
   },
   "source": [
    "# آموزش مدل بدون دانستن توزیع داده ها"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uni-0aA_X1ac"
   },
   "source": [
    "<p align=\"right\">داده ها را با کمک دسته بند اس وی ام و همچنین یک شبکه عصبی ساده دسته بندی کنید و دقت را با بخش قبل مقایسه نمایید</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VftAlrbXZ-Nn"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 98.33%\n"
     ]
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "from sklearn import metrics\n",
    "\n",
    "#train svm model\n",
    "#write yor code here :\n",
    "\n",
    "clf = svm.SVC(kernel='linear')\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "print(\"Accuracy: {}%\".format( round( metrics.accuracy_score(y_test, y_pred) * 100 , 2 ) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RYJlUDsGaGQT"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 100.0%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "#use two hidden layers \n",
    "#train multi layer perceptron\n",
    "#write yor code here :\n",
    "\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "mlp = MLPClassifier(hidden_layer_sizes=(20,20), max_iter=5000)\n",
    "mlp.fit(X_train,y_train)\n",
    "y_pred = mlp.predict(X_test)\n",
    "\n",
    "print(\"Accuracy: {}%\".format( round( metrics.accuracy_score(y_test, y_pred) * 100 , 2 ) ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J_bh4KyklqFA"
   },
   "source": [
    "\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yYGlkDuckgmz"
   },
   "source": [
    "# خواندن داده های جدید"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "d626_2ecknMc"
   },
   "outputs": [],
   "source": [
    "wine = datasets.load_wine()\n",
    "# store the feature matrix (X) and response vector (y) \n",
    "X = wine.data \n",
    "y = wine.target \n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E3ihimJ_lBJq"
   },
   "source": [
    "# آموزش یک مدل با فرض گوسی بودن توزیع داد ها"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EIbuPy6GlKyw"
   },
   "source": [
    "<p align=\"right\">فرض کنید می دانیم که داده های ما از یک توزیع گوسی پیروی می کنند با کمک کتابخانه های آماده یک مدل برای دسته بندی کلاس ها آموزش دهید می  توانید برای این قسمت از کتابخانه های آماده نیز استفاده کنید و نیازی به پیاده سازی نیست</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2i8GbQt9lPJO"
   },
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "# training the model on training set \n",
    "\n",
    "# write your code here :\n",
    "\n",
    "clf = GaussianNB()\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9ugDovFDljq2"
   },
   "source": [
    "<p align=\"right\">اکنون با کمک داده های آزمایشی دقت مدل خود را بسنجید</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dnkJltLll0qD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 98.61%\n"
     ]
    }
   ],
   "source": [
    "#write your code here :\n",
    "print(\"Accuracy: {}%\".format( round( metrics.accuracy_score(y_test, y_pred) * 100 , 2 ) ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "24nscd6El30c"
   },
   "source": [
    "# آموزش مدل بدون دانستن توزیع داده ها"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jXoB6ppJl7Vl"
   },
   "source": [
    "<p align=\"right\">داده ها را با کمک دسته بند اس وی ام و همچنین یک شبکه عصبی ساده دسته بندی کنید و دقت را با بخش قبل مقایسه نمایید</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9cw27u1bmBWE"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 95.83%\n"
     ]
    }
   ],
   "source": [
    "#train svm model\n",
    "\n",
    "#write yor code here :\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import metrics\n",
    "\n",
    "clf = SVC(kernel='linear')\n",
    "clf.fit(X_train, y_train)\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "print(\"Accuracy: {}%\".format( round( metrics.accuracy_score(y_test, y_pred) * 100 , 2 ) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tqS7kFEqmEMG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 97.22%\n"
     ]
    }
   ],
   "source": [
    "#train multi layer perceptron\n",
    "\n",
    "#write yor code here\n",
    "\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "mlp = MLPClassifier(hidden_layer_sizes=(20,20), max_iter=5000)\n",
    "mlp.fit(X_train,y_train)\n",
    "y_pred = mlp.predict(X_test)\n",
    "\n",
    "print(\"Accuracy: {}%\".format( round( metrics.accuracy_score(y_test, y_pred) * 100 , 2 ) ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Xw54ZdjmlsjN"
   },
   "source": [
    "\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X_qYfi-kgFbN"
   },
   "source": [
    "#بخش امتیازی"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NQ97VUicmoir"
   },
   "source": [
    "<p align=\"right\">آیا راهی وجود دارد که قبل از انتخاب بک دسته بند بتوان توزیع یک داده را حدس زد و دسته بندی را بر اساس این بینش از داده ها انجام داد؟</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2Oi6thGwnNiC"
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### توضیحات این بخش در فایل گزارش تمرین آورده شده است."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimator(a,b,degree,offset = 0) :\n",
    "    c = np.zeros([degree,degree])\n",
    "    for i in range(degree):\n",
    "        for j in range(degree):\n",
    "            g = i + j\n",
    "            c[i][j] = sum([(i-offset)**g for i in a])\n",
    "    c2 = np.linalg.inv(c)\n",
    "    d = np.zeros(degree)\n",
    "    for i in range(degree) :\n",
    "        d[i] = sum( [ b[j] * (a[j]-offset) ** i for j in range(len(a)) ] )\n",
    "    return c,d, np.matmul(c2,d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = [ 1394, 1395, 1396,1397, 1398 ]\n",
    "Y = [12 ,19 ,29, 37 ,45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,y,w = estimator(X,Y,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : \n",
      " [[5.00000000e+00 6.98000000e+03 9.74409000e+06]\n",
      " [6.98000000e+03 9.74409000e+06 1.36027776e+10]\n",
      " [9.74409000e+06 1.36027776e+10 1.89895359e+13]]\n",
      "y : \n",
      " [1.42000000e+02 1.98316000e+05 2.76966684e+08]\n",
      "w : \n",
      " [-1.16969531e+04  8.39851379e+00  5.21540642e-07]\n"
     ]
    }
   ],
   "source": [
    "print(\"A : \\n\",A)\n",
    "print(\"y : \\n\",y)\n",
    "print(\"w : \\n\",w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimation for 1399 : 53.59\n"
     ]
    }
   ],
   "source": [
    "p1 = np.polyval(np.flip(w, 0), 1399)\n",
    "print(\"Estimation for 1399 : {}\".format(round(p1,2)))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "hw4-project",
   "provenance": [],
   "toc_visible": true
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}