├── AdalineClassifier_iris.ipynb
├── Adaline.ipynb
├── Adaline(hair,gender).ipynb
├── Adaline(height,weight).ipynb
└── Adaline(Boston).ipynb


/AdalineClassifier_iris.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "AdalineClassifier_iris.ipynb",
  7 |       "provenance": [],
  8 |       "collapsed_sections": []
  9 |     },
 10 |     "kernelspec": {
 11 |       "display_name": "Python 3 (ipykernel)",
 12 |       "language": "python",
 13 |       "name": "python3"
 14 |     },
 15 |     "language_info": {
 16 |       "codemirror_mode": {
 17 |         "name": "ipython",
 18 |         "version": 3
 19 |       },
 20 |       "file_extension": ".py",
 21 |       "mimetype": "text/x-python",
 22 |       "name": "python",
 23 |       "nbconvert_exporter": "python",
 24 |       "pygments_lexer": "ipython3",
 25 |       "version": "3.7.9"
 26 |     }
 27 |   },
 28 |   "cells": [
 29 |     {
 30 |       "cell_type": "code",
 31 |       "metadata": {
 32 |         "id": "Yv4vkuBkzl7Y"
 33 |       },
 34 |       "source": [
 35 |         "import numpy as np\n",
 36 |         "import matplotlib.pyplot as plt\n",
 37 |         "import pandas as pd\n",
 38 |         "from sklearn.model_selection import train_test_split\n",
 39 |         "from sklearn.datasets import load_iris"
 40 |       ],
 41 |       "execution_count": 11,
 42 |       "outputs": []
 43 |     },
 44 |     {
 45 |       "cell_type": "code",
 46 |       "metadata": {
 47 |         "id": "uYZD_VEp3M1o"
 48 |       },
 49 |       "source": [
 50 |         "iris=load_iris()\n",
 51 |         "x = iris.data[:, :4]\n",
 52 |         "y=iris.target\n",
 53 |         "Y=[]\n",
 54 |         "X=[]\n",
 55 |         "for i in range(len(y)):\n",
 56 |         "  if(y[i]==1 or y[i]==2):\n",
 57 |         "    Y.append(y[i])\n",
 58 |         "    X.append(x[i])\n",
 59 |         "\n",
 60 |         "X=np.array(X)\n",
 61 |         "Y_count=np.bincount(Y)\n",
 62 |         "Y=np.array(Y)\n",
 63 |         "#Y=Y.reshape(100,1)\n",
 64 |         "\n",
 65 |         "\n",
 66 |         "\n"
 67 |       ],
 68 |       "execution_count": 12,
 69 |       "outputs": []
 70 |     },
 71 |     {
 72 |       "cell_type": "code",
 73 |       "metadata": {
 74 |         "id": "emoDtnQ51Ds1"
 75 |       },
 76 |       "source": [
 77 |         "X_train,X_test,y_train,y_test=train_test_split(X,Y,test_size=0.2)\n"
 78 |       ],
 79 |       "execution_count": 13,
 80 |       "outputs": []
 81 |     },
 82 |     {
 83 |       "cell_type": "code",
 84 |       "metadata": {
 85 |         "id": "1tEkzd557c_i"
 86 |       },
 87 |       "source": [
 88 |         "class AdalineClassifier:\n",
 89 |         "  def __init__(self):\n",
 90 |         "    pass\n",
 91 |         "\n",
 92 |         "  def fit(self,X_train,Y_train):\n",
 93 |         "    #w=(x.T*x)^-1*x.T*y\n",
 94 |         "    self.w=np.matmul(np.linalg.inv(np.matmul(X_train.T,X_train)),np.matmul(X_train.T,Y_train))\n",
 95 |         "    #print(self.w)  \n",
 96 |         "\n",
 97 |         "  def predict(self,X_test):\n",
 98 |         "    y_pred=[]\n",
 99 |         "\n",
100 |         "    Y_pred=np.matmul(X_test,self.w)\n",
101 |         "    for i in range(len(Y_pred)):\n",
102 |         "      print(Y_pred[i])\n",
103 |         "      if(Y_pred[i] <= 1.5):\n",
104 |         "        y_pred.append(1)\n",
105 |         "      elif(Y_pred[i]>1.5):  \n",
106 |         "        y_pred.append(2)\n",
107 |         "    print(y_pred) \n",
108 |         "    return y_pred\n",
109 |         "      \n",
110 |         "    \n",
111 |         "\n",
112 |         "  def evaluate(self,y_pred,y_test):\n",
113 |         "    num_of_correct_pred=0\n",
114 |         "    #self.X_test=X_test\n",
115 |         "    #self.y_test=y_test\n",
116 |         "    y=[]\n",
117 |         "        \n",
118 |         "    for i in range(len(y_test)):\n",
119 |         "         if(y_test[i]==y_pred[i]):\n",
120 |         "            num_of_correct_pred +=1\n",
121 |         "     \n",
122 |         "     \n",
123 |         "    accuracy=(num_of_correct_pred/len(y_test))*100\n",
124 |         "    \n",
125 |         "        #print(num_of_correct_pred)\n",
126 |         "    return accuracy\n",
127 |         "      #y.append(self.predict(X_test[i]))   \n",
128 |         "      #print(y[i])\n",
129 |         "      \n",
130 |         "       \n",
131 |         "  "
132 |       ],
133 |       "execution_count": 14,
134 |       "outputs": []
135 |     },
136 |     {
137 |       "cell_type": "code",
138 |       "metadata": {
139 |         "id": "uzVU33d6_sJY"
140 |       },
141 |       "source": [
142 |         "\n"
143 |       ],
144 |       "execution_count": 14,
145 |       "outputs": []
146 |     },
147 |     {
148 |       "cell_type": "code",
149 |       "metadata": {
150 |         "colab": {
151 |           "base_uri": "https://localhost:8080/"
152 |         },
153 |         "id": "RSub0VjH_4PW",
154 |         "outputId": "75d889f2-112b-4b56-a136-1b4b34ecc6e1"
155 |       },
156 |       "source": [
157 |         "model=AdalineClassifier()\n",
158 |         "model.fit(X_train,y_train)\n",
159 |         "\n",
160 |         "y_pred=model.predict(X_test)\n",
161 |         "#print(len(y_pred))\n",
162 |         "accuracy=model.evaluate(y_pred,y_test)\n",
163 |         "print(\"Adaline Classifier accuracy =\",accuracy)\n"
164 |       ],
165 |       "execution_count": 15,
166 |       "outputs": [
167 |         {
168 |           "output_type": "stream",
169 |           "text": [
170 |             "2.4360170519287236\n",
171 |             "2.2595549013987215\n",
172 |             "1.6002233692340584\n",
173 |             "1.577177083230049\n",
174 |             "2.183782682554865\n",
175 |             "1.8165306856311778\n",
176 |             "1.5887120504611287\n",
177 |             "1.7590359057256748\n",
178 |             "1.714068583853558\n",
179 |             "0.8335866486499469\n",
180 |             "1.364895999641675\n",
181 |             "0.8905469382872588\n",
182 |             "2.0946322715023453\n",
183 |             "1.1713986433991488\n",
184 |             "2.2047348760788164\n",
185 |             "2.1611425467661243\n",
186 |             "0.9914775055918348\n",
187 |             "1.4691111764551643\n",
188 |             "2.18388169566814\n",
189 |             "2.1548817240511173\n",
190 |             "[2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 2, 2, 1, 1, 2, 2]\n",
191 |             "Adaline Classifier accuracy = 95.0\n"
192 |           ],
193 |           "name": "stdout"
194 |         }
195 |       ]
196 |     },
197 |     {
198 |       "cell_type": "code",
199 |       "metadata": {
200 |         "id": "2_JTzIdM1Ds7"
201 |       },
202 |       "source": [
203 |         "class Knearestneighbors:\n",
204 |         "  def __init__(self,k):\n",
205 |         "    self.k=k\n",
206 |         "\n",
207 |         "  def fit(self,X_train,y_train):\n",
208 |         "    self.X_train=X_train\n",
209 |         "    self.y_train=y_train\n",
210 |         "    self.number_of_classes=len(np.unique(y_train)) \n",
211 |         "\n",
212 |         "  def nearNeighbors(self,x_test):\n",
213 |         "    distance=np.sqrt(np.sum((x_test-self.X_train)**2,axis=1))\n",
214 |         "    near_neighbors=np.argsort(distance)[0:self.k]\n",
215 |         "    return near_neighbors  \n",
216 |         "\n",
217 |         "  def predict(self,x_test):\n",
218 |         "    near_neighbors=self.nearNeighbors(x_test)\n",
219 |         "    y_pred=np.argmax(np.bincount(self.y_train[near_neighbors]))\n",
220 |         "    return y_pred\n",
221 |         "\n",
222 |         "  def evaluate(self,X_test,y_test):\n",
223 |         "    num_of_correct_pred=0\n",
224 |         "    self.X_test=X_test\n",
225 |         "    self.y_test=y_test\n",
226 |         "\n",
227 |         "    y=[]\n",
228 |         "\n",
229 |         "    for i in range(len(X_test)):\n",
230 |         "      y.append(self.predict(X_test[i]))\n",
231 |         "\n",
232 |         "    for i in range(len(y)):\n",
233 |         "      if(y_test[i]==y[i]):\n",
234 |         "        num_of_correct_pred +=1\n",
235 |         "\n",
236 |         "\n",
237 |         "    accuracy=(num_of_correct_pred/len(y_test))*100\n",
238 |         "    return accuracy      \n",
239 |         "\n",
240 |         "\n",
241 |         "        "
242 |       ],
243 |       "execution_count": 16,
244 |       "outputs": []
245 |     },
246 |     {
247 |       "cell_type": "code",
248 |       "metadata": {
249 |         "id": "lqzWfKPf1Ds9",
250 |         "colab": {
251 |           "base_uri": "https://localhost:8080/"
252 |         },
253 |         "outputId": "dd992fcf-0fe4-41af-8ed8-f7af9b6f0078"
254 |       },
255 |       "source": [
256 |         "knn=Knearestneighbors(5)\n",
257 |         "knn.fit(X_train,y_train)\n",
258 |         "accuracy=knn.evaluate(X_test,y_test)\n",
259 |         "print(\"KNN accuracy :\",accuracy)"
260 |       ],
261 |       "execution_count": 17,
262 |       "outputs": [
263 |         {
264 |           "output_type": "stream",
265 |           "text": [
266 |             "KNN accuracy : 100.0\n"
267 |           ],
268 |           "name": "stdout"
269 |         }
270 |       ]
271 |     },
272 |     {
273 |       "cell_type": "code",
274 |       "metadata": {
275 |         "id": "CsTpLZQR1Ds_",
276 |         "colab": {
277 |           "base_uri": "https://localhost:8080/"
278 |         },
279 |         "outputId": "1fb8ea00-d4f3-41f6-cfbb-0bfdfaf32bfb"
280 |       },
281 |       "source": [
282 |         "#knn in scikitlean\n",
283 |         "import sklearn\n",
284 |         "from sklearn.neighbors import KNeighborsClassifier\n",
285 |         "\n",
286 |         "label=0\n",
287 |         "\n",
288 |         "KNN=KNeighborsClassifier(5)\n",
289 |         "KNN.fit(X,Y)\n",
290 |         "y=KNN.predict(X_test)\n",
291 |         "for i in range(len(y_pred)):\n",
292 |         "    if (y[i]==y_test[i]):\n",
293 |         "        label=label+1\n",
294 |         "        \n",
295 |         "accuracy=(label/len(y_test))*100\n",
296 |         "\n",
297 |         "print(\"The accuracy of sklearn :\",accuracy)\n"
298 |       ],
299 |       "execution_count": 18,
300 |       "outputs": [
301 |         {
302 |           "output_type": "stream",
303 |           "text": [
304 |             "The accuracy of sklearn : 95.0\n"
305 |           ],
306 |           "name": "stdout"
307 |         }
308 |       ]
309 |     },
310 |     {
311 |       "cell_type": "code",
312 |       "metadata": {
313 |         "id": "vqtYPH1cSnBe"
314 |       },
315 |       "source": [
316 |         ""
317 |       ],
318 |       "execution_count": 18,
319 |       "outputs": []
320 |     }
321 |   ]
322 | }


--------------------------------------------------------------------------------
/Adaline.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "Adaline.ipynb",
  7 |       "provenance": [],
  8 |       "collapsed_sections": []
  9 |     },
 10 |     "kernelspec": {
 11 |       "name": "python3",
 12 |       "display_name": "Python 3"
 13 |     },
 14 |     "language_info": {
 15 |       "name": "python"
 16 |     }
 17 |   },
 18 |   "cells": [
 19 |     {
 20 |       "cell_type": "code",
 21 |       "metadata": {
 22 |         "id": "JY8B0QVVjM5v"
 23 |       },
 24 |       "source": [
 25 |         "import numpy as np\n",
 26 |         "import matplotlib.pyplot as plt\n",
 27 |         "import pandas as pd\n",
 28 |         "from numpy.linalg import inv\n",
 29 |         "\n",
 30 |         "\n"
 31 |       ],
 32 |       "execution_count": 8,
 33 |       "outputs": []
 34 |     },
 35 |     {
 36 |       "cell_type": "code",
 37 |       "metadata": {
 38 |         "id": "s0rTGGaSj30u"
 39 |       },
 40 |       "source": [
 41 |         "data=pd.read_csv('regressionOutliers.csv')\n",
 42 |         "X_train=data['X']\n",
 43 |         "Y_train=data['Y']\n",
 44 |         "\n"
 45 |       ],
 46 |       "execution_count": 9,
 47 |       "outputs": []
 48 |     },
 49 |     {
 50 |       "cell_type": "code",
 51 |       "metadata": {
 52 |         "colab": {
 53 |           "base_uri": "https://localhost:8080/"
 54 |         },
 55 |         "id": "hNmxtXKskUzn",
 56 |         "outputId": "d360e6c4-0374-42f0-bd50-ba008a8d3718"
 57 |       },
 58 |       "source": [
 59 |         "X_train.head()"
 60 |       ],
 61 |       "execution_count": 10,
 62 |       "outputs": [
 63 |         {
 64 |           "output_type": "execute_result",
 65 |           "data": {
 66 |             "text/plain": [
 67 |               "0    0.655210\n",
 68 |               "1    0.752910\n",
 69 |               "2    0.810860\n",
 70 |               "3    0.048427\n",
 71 |               "4    0.414710\n",
 72 |               "Name: X, dtype: float64"
 73 |             ]
 74 |           },
 75 |           "metadata": {
 76 |             "tags": []
 77 |           },
 78 |           "execution_count": 10
 79 |         }
 80 |       ]
 81 |     },
 82 |     {
 83 |       "cell_type": "code",
 84 |       "metadata": {
 85 |         "colab": {
 86 |           "base_uri": "https://localhost:8080/"
 87 |         },
 88 |         "id": "52lSc_lhkXLA",
 89 |         "outputId": "23dc7f76-a953-4537-ad7a-a59189c18a85"
 90 |       },
 91 |       "source": [
 92 |         "Y_train.head()"
 93 |       ],
 94 |       "execution_count": 11,
 95 |       "outputs": [
 96 |         {
 97 |           "output_type": "execute_result",
 98 |           "data": {
 99 |             "text/plain": [
100 |               "0   -5.1815\n",
101 |               "1   -4.6796\n",
102 |               "2   -3.6935\n",
103 |               "3   -1.2416\n",
104 |               "4   -2.1358\n",
105 |               "Name: Y, dtype: float64"
106 |             ]
107 |           },
108 |           "metadata": {
109 |             "tags": []
110 |           },
111 |           "execution_count": 11
112 |         }
113 |       ]
114 |     },
115 |     {
116 |       "cell_type": "code",
117 |       "metadata": {
118 |         "id": "mBFVuI7ZkjBe"
119 |       },
120 |       "source": [
121 |         "X=np.array(X_train)\n",
122 |         "Y=np.array(Y_train)"
123 |       ],
124 |       "execution_count": 12,
125 |       "outputs": []
126 |     },
127 |     {
128 |       "cell_type": "code",
129 |       "metadata": {
130 |         "id": "YEAiYnhKpBJr"
131 |       },
132 |       "source": [
133 |         "X=X.reshape(400,1)\n",
134 |         "#X.shape\n",
135 |         "Y=Y.reshape(400,1)"
136 |       ],
137 |       "execution_count": 13,
138 |       "outputs": []
139 |     },
140 |     {
141 |       "cell_type": "code",
142 |       "metadata": {
143 |         "colab": {
144 |           "base_uri": "https://localhost:8080/"
145 |         },
146 |         "id": "9Cx0k3BkmSjM",
147 |         "outputId": "a6a43ca2-4524-41e8-dc2e-9f986fc6374f"
148 |       },
149 |       "source": [
150 |         "#m=((x.Tx)^-1)*x.Ty\n",
151 |         "#y=m*X\n",
152 |         "#m=Y/X\n",
153 |         "\n",
154 |         "m=np.matmul(inv(np.matmul(X.T,X)),np.matmul(X.T,Y))\n",
155 |         "m"
156 |       ],
157 |       "execution_count": 14,
158 |       "outputs": [
159 |         {
160 |           "output_type": "execute_result",
161 |           "data": {
162 |             "text/plain": [
163 |               "array([[-1.80480221]])"
164 |             ]
165 |           },
166 |           "metadata": {
167 |             "tags": []
168 |           },
169 |           "execution_count": 14
170 |         }
171 |       ]
172 |     },
173 |     {
174 |       "cell_type": "code",
175 |       "metadata": {
176 |         "colab": {
177 |           "base_uri": "https://localhost:8080/",
178 |           "height": 283
179 |         },
180 |         "id": "YAK-QeAlqHhz",
181 |         "outputId": "85bb5a1c-bbe0-496f-a1f0-9e10d5a241b0"
182 |       },
183 |       "source": [
184 |         "Y_pred=np.matmul(X,m)\n",
185 |         "plt.scatter(X,Y)\n",
186 |         "plt.plot(X,Y_pred,c='red',lw=2)"
187 |       ],
188 |       "execution_count": 15,
189 |       "outputs": [
190 |         {
191 |           "output_type": "execute_result",
192 |           "data": {
193 |             "text/plain": [
194 |               "[<matplotlib.lines.Line2D at 0x7f62a10427d0>]"
195 |             ]
196 |           },
197 |           "metadata": {
198 |             "tags": []
199 |           },
200 |           "execution_count": 15
201 |         },
202 |         {
203 |           "output_type": "display_data",
204 |           "data": {
205 |             "image/png": "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\n",
206 |             "text/plain": [
207 |               "<Figure size 432x288 with 1 Axes>"
208 |             ]
209 |           },
210 |           "metadata": {
211 |             "tags": [],
212 |             "needs_background": "light"
213 |           }
214 |         }
215 |       ]
216 |     }
217 |   ]
218 | }


--------------------------------------------------------------------------------
/Adaline(hair,gender).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "Adaline(hair,gender).ipynb",
  7 |       "provenance": [],
  8 |       "collapsed_sections": []
  9 |     },
 10 |     "kernelspec": {
 11 |       "name": "python3",
 12 |       "display_name": "Python 3"
 13 |     },
 14 |     "language_info": {
 15 |       "name": "python"
 16 |     }
 17 |   },
 18 |   "cells": [
 19 |     {
 20 |       "cell_type": "code",
 21 |       "metadata": {
 22 |         "id": "HZpHnG6nGfp4"
 23 |       },
 24 |       "source": [
 25 |         "import numpy as np\n",
 26 |         "import pandas as pd\n",
 27 |         "import matplotlib.pyplot as plt\n",
 28 |         "import random\n",
 29 |         "import scipy\n",
 30 |         "from scipy import stats"
 31 |       ],
 32 |       "execution_count": 93,
 33 |       "outputs": []
 34 |     },
 35 |     {
 36 |       "cell_type": "code",
 37 |       "metadata": {
 38 |         "colab": {
 39 |           "base_uri": "https://localhost:8080/",
 40 |           "height": 326
 41 |         },
 42 |         "id": "3yaiQD4-Ke_I",
 43 |         "outputId": "049fdde1-4c39-49e0-89ae-f83c561832b9"
 44 |       },
 45 |       "source": [
 46 |         "x_woman=[]\n",
 47 |         "x_man=[]\n",
 48 |         "N=50\n",
 49 |         "for i in range(N):\n",
 50 |         "  x_w=random.randint(20,50)\n",
 51 |         "  x_woman.append(x_w)\n",
 52 |         "  x_m=random.randint(5,15)\n",
 53 |         "  x_man.append(x_m)\n",
 54 |         "\n",
 55 |         "\n",
 56 |         "x_woman=np.array(x_woman)\n",
 57 |         "x_man=np.array(x_man)\n",
 58 |         "x_woman=x_woman.reshape(N,1)\n",
 59 |         "x_man=x_man.reshape(N,1)\n",
 60 |         "\n",
 61 |         "X=np.concatenate([x_woman,x_man])\n",
 62 |         "\n",
 63 |         "for i in range(N):\n",
 64 |         "  plt.scatter(x_woman[i],50)\n",
 65 |         "  plt.scatter(x_man[i],-50)\n",
 66 |         "\n",
 67 |         "for i in range(5):\n",
 68 |         "  m=random.randint(-2,2)*2\n",
 69 |         "  y=np.multiply(X,m)\n",
 70 |         "  plt.plot(X,y,c='red')\n",
 71 |         "plt.xlabel('Hair')\n",
 72 |         "plt.ylabel('Gender')\n",
 73 |         "plt.suptitle('Random slope')"
 74 |       ],
 75 |       "execution_count": 94,
 76 |       "outputs": [
 77 |         {
 78 |           "output_type": "execute_result",
 79 |           "data": {
 80 |             "text/plain": [
 81 |               "Text(0.5, 0.98, 'Random slope')"
 82 |             ]
 83 |           },
 84 |           "metadata": {
 85 |             "tags": []
 86 |           },
 87 |           "execution_count": 94
 88 |         },
 89 |         {
 90 |           "output_type": "display_data",
 91 |           "data": {
 92 |             "image/png": "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\n",
 93 |             "text/plain": [
 94 |               "<Figure size 432x288 with 1 Axes>"
 95 |             ]
 96 |           },
 97 |           "metadata": {
 98 |             "tags": [],
 99 |             "needs_background": "light"
100 |           }
101 |         }
102 |       ]
103 |     },
104 |     {
105 |       "cell_type": "code",
106 |       "metadata": {
107 |         "id": "7k-___usk-ws"
108 |       },
109 |       "source": [
110 |         "class AdalineRegressor:\n",
111 |         "  def __int__(self):\n",
112 |         "    pass\n",
113 |         "\n",
114 |         "#train\n",
115 |         "  def fit(self,X_train,Y_train):\n",
116 |         "    #w=(X.T*X)^-1 * X.T.Y\n",
117 |         "    self.w=np.matmul(np.linalg.inv(np.matmul(X_train.T,X_train)),np.matmul(X_train.T,Y_train))\n",
118 |         "\n",
119 |         "  def predict(self,X_test):\n",
120 |         "    Y_pred=np.matmul(self.w,X_test)  \n",
121 |         "    return Y_pred"
122 |       ],
123 |       "execution_count": 95,
124 |       "outputs": []
125 |     },
126 |     {
127 |       "cell_type": "code",
128 |       "metadata": {
129 |         "id": "1UxzlnleKdBo",
130 |         "colab": {
131 |           "base_uri": "https://localhost:8080/"
132 |         },
133 |         "outputId": "1aaa479c-eabf-4c83-91ce-1c8c38d14219"
134 |       },
135 |       "source": [
136 |         "model=AdalineRegressor()\n",
137 |         "model.fit(x_woman,x_man)\n",
138 |         "#w is a numpy array\n",
139 |         "print(\"Slope of Adaline\",model.w)\n"
140 |       ],
141 |       "execution_count": 96,
142 |       "outputs": [
143 |         {
144 |           "output_type": "stream",
145 |           "text": [
146 |             "Slope of Adaline [[0.25312043]]\n"
147 |           ],
148 |           "name": "stdout"
149 |         }
150 |       ]
151 |     },
152 |     {
153 |       "cell_type": "code",
154 |       "metadata": {
155 |         "id": "Vv0Uwp76tjYu"
156 |       },
157 |       "source": [
158 |         "Y_pred=np.matmul(X,model.w)"
159 |       ],
160 |       "execution_count": 97,
161 |       "outputs": []
162 |     },
163 |     {
164 |       "cell_type": "code",
165 |       "metadata": {
166 |         "colab": {
167 |           "base_uri": "https://localhost:8080/",
168 |           "height": 297
169 |         },
170 |         "id": "SL4A-tb6tpR0",
171 |         "outputId": "c6dc386e-bf24-41ae-a10a-0c6c510cf5fa"
172 |       },
173 |       "source": [
174 |         "#slope adaline\n",
175 |         "for i in range(N):\n",
176 |         "  plt.scatter(x_woman[i],50)\n",
177 |         "  plt.scatter(x_man[i],-50)\n",
178 |         "\n",
179 |         "plt.xlabel('Hair')\n",
180 |         "plt.ylabel('Gender')  \n",
181 |         "\n",
182 |         "plt.plot(X,Y_pred,c='red')"
183 |       ],
184 |       "execution_count": 98,
185 |       "outputs": [
186 |         {
187 |           "output_type": "execute_result",
188 |           "data": {
189 |             "text/plain": [
190 |               "[<matplotlib.lines.Line2D at 0x7efe45972dd0>]"
191 |             ]
192 |           },
193 |           "metadata": {
194 |             "tags": []
195 |           },
196 |           "execution_count": 98
197 |         },
198 |         {
199 |           "output_type": "display_data",
200 |           "data": {
201 |             "image/png": "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\n",
202 |             "text/plain": [
203 |               "<Figure size 432x288 with 1 Axes>"
204 |             ]
205 |           },
206 |           "metadata": {
207 |             "tags": [],
208 |             "needs_background": "light"
209 |           }
210 |         }
211 |       ]
212 |     },
213 |     {
214 |       "cell_type": "code",
215 |       "metadata": {
216 |         "colab": {
217 |           "base_uri": "https://localhost:8080/",
218 |           "height": 297
219 |         },
220 |         "id": "U6AlmC39t_5o",
221 |         "outputId": "d7594f45-8491-4f2c-d1c4-597b7486f0ab"
222 |       },
223 |       "source": [
224 |         "#slope lingress\n",
225 |         "for i in range(N):\n",
226 |         "  plt.scatter(x_woman[i],50)\n",
227 |         "  plt.scatter(x_man[i],-50)\n",
228 |         "slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(x_woman[:,0], x_man[:,0])\n",
229 |         "plt.plot(X, intercept + slope*X, 'g', lw=2)\n",
230 |         "plt.xlabel('Hair')\n",
231 |         "plt.ylabel('Gender')\n",
232 |         "print(\"Slope of lingress\",slope)"
233 |       ],
234 |       "execution_count": 99,
235 |       "outputs": [
236 |         {
237 |           "output_type": "stream",
238 |           "text": [
239 |             "Slope of lingress 0.06561491957018649\n"
240 |           ],
241 |           "name": "stdout"
242 |         },
243 |         {
244 |           "output_type": "display_data",
245 |           "data": {
246 |             "image/png": "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\n",
247 |             "text/plain": [
248 |               "<Figure size 432x288 with 1 Axes>"
249 |             ]
250 |           },
251 |           "metadata": {
252 |             "tags": [],
253 |             "needs_background": "light"
254 |           }
255 |         }
256 |       ]
257 |     }
258 |   ]
259 | }


--------------------------------------------------------------------------------
/Adaline(height,weight).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "Adaline(height,weight).ipynb",
  7 |       "provenance": []
  8 |     },
  9 |     "kernelspec": {
 10 |       "name": "python3",
 11 |       "display_name": "Python 3"
 12 |     },
 13 |     "language_info": {
 14 |       "name": "python"
 15 |     }
 16 |   },
 17 |   "cells": [
 18 |     {
 19 |       "cell_type": "code",
 20 |       "metadata": {
 21 |         "id": "SnEfkmUYEHvh"
 22 |       },
 23 |       "source": [
 24 |         "import random\n",
 25 |         "import numpy as np\n",
 26 |         "import pandas as pd\n",
 27 |         "import matplotlib.pyplot as plt\n",
 28 |         "from scipy import stats\n",
 29 |         "import scipy"
 30 |       ],
 31 |       "execution_count": 105,
 32 |       "outputs": []
 33 |     },
 34 |     {
 35 |       "cell_type": "code",
 36 |       "metadata": {
 37 |         "id": "WKSxaLo6Larf"
 38 |       },
 39 |       "source": [
 40 |         "X=[]\n",
 41 |         "Y=[]\n",
 42 |         "N=100\n",
 43 |         "\n",
 44 |         "for i in range(N):\n",
 45 |         "  x=random.randint(40,190)\n",
 46 |         "  X.append(x)\n",
 47 |         "\n",
 48 |         "  y=x+random.randint(-10,5)\n",
 49 |         "  Y.append(y)\n",
 50 |         "\n",
 51 |         "\n",
 52 |         "\n",
 53 |         "X=np.array(X)\n",
 54 |         "Y=np.array(Y)\n",
 55 |         "X=X.reshape(N,1)\n",
 56 |         "Y=Y.reshape(N,1)\n",
 57 |         "#print(X.shape)\n",
 58 |         "\n"
 59 |       ],
 60 |       "execution_count": 106,
 61 |       "outputs": []
 62 |     },
 63 |     {
 64 |       "cell_type": "code",
 65 |       "metadata": {
 66 |         "colab": {
 67 |           "base_uri": "https://localhost:8080/",
 68 |           "height": 308
 69 |         },
 70 |         "id": "krQ0Xuq6pHir",
 71 |         "outputId": "38d1518d-ca9c-4c03-c75e-01eeeaf7c87c"
 72 |       },
 73 |       "source": [
 74 |         "plt.scatter(X,Y)  \n",
 75 |         "plt.xlabel('Height')\n",
 76 |         "plt.ylabel('Weight')\n",
 77 |         "y=0\n",
 78 |         "m=0\n",
 79 |         "#random slope\n",
 80 |         "for i in range(5):\n",
 81 |         "  m=random.random()*1.5\n",
 82 |         "  y=np. multiply(X,m)\n",
 83 |         "  plt.plot(X,y,c='red')\n",
 84 |         "  plt.suptitle('Random slope')"
 85 |       ],
 86 |       "execution_count": 107,
 87 |       "outputs": [
 88 |         {
 89 |           "output_type": "display_data",
 90 |           "data": {
 91 |             "image/png": "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\n",
 92 |             "text/plain": [
 93 |               "<Figure size 432x288 with 1 Axes>"
 94 |             ]
 95 |           },
 96 |           "metadata": {
 97 |             "tags": [],
 98 |             "needs_background": "light"
 99 |           }
100 |         }
101 |       ]
102 |     },
103 |     {
104 |       "cell_type": "code",
105 |       "metadata": {
106 |         "id": "tREjdHBmpEGF"
107 |       },
108 |       "source": [
109 |         ""
110 |       ],
111 |       "execution_count": 107,
112 |       "outputs": []
113 |     },
114 |     {
115 |       "cell_type": "code",
116 |       "metadata": {
117 |         "id": "m-EfOfh8pDI9"
118 |       },
119 |       "source": [
120 |         ""
121 |       ],
122 |       "execution_count": 107,
123 |       "outputs": []
124 |     },
125 |     {
126 |       "cell_type": "code",
127 |       "metadata": {
128 |         "id": "LPc1aHqabvZ4"
129 |       },
130 |       "source": [
131 |         ""
132 |       ],
133 |       "execution_count": 107,
134 |       "outputs": []
135 |     },
136 |     {
137 |       "cell_type": "code",
138 |       "metadata": {
139 |         "id": "U-UcVeDjN3lO"
140 |       },
141 |       "source": [
142 |         "class AdalineRegressor:\n",
143 |         "  def __int__(self):\n",
144 |         "    pass\n",
145 |         "\n",
146 |         "#train\n",
147 |         "  def fit(self,X_train,Y_train):\n",
148 |         "    #w=(X.T*X)^-1 * X.T.Y\n",
149 |         "    self.w=np.matmul(np.linalg.inv(np.matmul(X_train.T,X_train)),np.matmul(X_train.T,Y_train))\n",
150 |         "\n",
151 |         "  def predict(self,X_test):\n",
152 |         "    Y_pred=np.matmul(self.w,X_test)  \n",
153 |         "    return Y_pred\n",
154 |         "\n",
155 |         "\n"
156 |       ],
157 |       "execution_count": 108,
158 |       "outputs": []
159 |     },
160 |     {
161 |       "cell_type": "code",
162 |       "metadata": {
163 |         "id": "VdN0VKrPmhNb"
164 |       },
165 |       "source": [
166 |         ""
167 |       ],
168 |       "execution_count": 108,
169 |       "outputs": []
170 |     },
171 |     {
172 |       "cell_type": "code",
173 |       "metadata": {
174 |         "colab": {
175 |           "base_uri": "https://localhost:8080/"
176 |         },
177 |         "id": "lSBNvs6pa032",
178 |         "outputId": "559962fb-52d2-498b-8498-9c780b6de3d9"
179 |       },
180 |       "source": [
181 |         "model=AdalineRegressor()\n",
182 |         "model.fit(X,Y)\n",
183 |         "#w is a numpy array\n",
184 |         "print(\"Slope of Adaline\",model.w)"
185 |       ],
186 |       "execution_count": 126,
187 |       "outputs": [
188 |         {
189 |           "output_type": "stream",
190 |           "text": [
191 |             "Slope of Adaline [[0.97844453]]\n"
192 |           ],
193 |           "name": "stdout"
194 |         }
195 |       ]
196 |     },
197 |     {
198 |       "cell_type": "code",
199 |       "metadata": {
200 |         "id": "0gyiY-BHcVH0"
201 |       },
202 |       "source": [
203 |         "Y_pred=np.matmul(X,model.w)"
204 |       ],
205 |       "execution_count": 110,
206 |       "outputs": []
207 |     },
208 |     {
209 |       "cell_type": "code",
210 |       "metadata": {
211 |         "colab": {
212 |           "base_uri": "https://localhost:8080/",
213 |           "height": 286
214 |         },
215 |         "id": "WrlQKu2aeiHN",
216 |         "outputId": "bd3585d6-d42b-4058-e745-4b2fb4000e07"
217 |       },
218 |       "source": [
219 |         "#slope adaline\n",
220 |         "plt.scatter(X,Y,c='blue')\n",
221 |         "plt.plot(X,Y_pred,c='red')\n"
222 |       ],
223 |       "execution_count": 124,
224 |       "outputs": [
225 |         {
226 |           "output_type": "execute_result",
227 |           "data": {
228 |             "text/plain": [
229 |               "[<matplotlib.lines.Line2D at 0x7f3ffdc61690>]"
230 |             ]
231 |           },
232 |           "metadata": {
233 |             "tags": []
234 |           },
235 |           "execution_count": 124
236 |         },
237 |         {
238 |           "output_type": "display_data",
239 |           "data": {
240 |             "image/png": "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\n",
241 |             "text/plain": [
242 |               "<Figure size 432x288 with 1 Axes>"
243 |             ]
244 |           },
245 |           "metadata": {
246 |             "tags": [],
247 |             "needs_background": "light"
248 |           }
249 |         }
250 |       ]
251 |     },
252 |     {
253 |       "cell_type": "code",
254 |       "metadata": {
255 |         "colab": {
256 |           "base_uri": "https://localhost:8080/",
257 |           "height": 286
258 |         },
259 |         "id": "fmZ1CTBG7JLs",
260 |         "outputId": "6295d753-ee9b-42d7-c3d8-ab0efceb7105"
261 |       },
262 |       "source": [
263 |         "#slope lingress\n",
264 |         "plt.scatter(X,Y,c='blue')\n",
265 |         "slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(X[:,0], Y[:,0])\n",
266 |         "plt.plot(X, intercept + slope*X, 'g', lw=2)\n",
267 |         "print(\"Slope of lingress\",slope)"
268 |       ],
269 |       "execution_count": 125,
270 |       "outputs": [
271 |         {
272 |           "output_type": "stream",
273 |           "text": [
274 |             "Slope of lingress 0.9936273316759551\n"
275 |           ],
276 |           "name": "stdout"
277 |         },
278 |         {
279 |           "output_type": "display_data",
280 |           "data": {
281 |             "image/png": "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\n",
282 |             "text/plain": [
283 |               "<Figure size 432x288 with 1 Axes>"
284 |             ]
285 |           },
286 |           "metadata": {
287 |             "tags": [],
288 |             "needs_background": "light"
289 |           }
290 |         }
291 |       ]
292 |     },
293 |     {
294 |       "cell_type": "code",
295 |       "metadata": {
296 |         "id": "rnVO3HElmimF"
297 |       },
298 |       "source": [
299 |         ""
300 |       ],
301 |       "execution_count": 111,
302 |       "outputs": []
303 |     },
304 |     {
305 |       "cell_type": "code",
306 |       "metadata": {
307 |         "id": "tyV2hQ4Kwqvo"
308 |       },
309 |       "source": [
310 |         ""
311 |       ],
312 |       "execution_count": 111,
313 |       "outputs": []
314 |     }
315 |   ]
316 | }


--------------------------------------------------------------------------------
/Adaline(Boston).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |   "nbformat": 4,
  3 |   "nbformat_minor": 0,
  4 |   "metadata": {
  5 |     "colab": {
  6 |       "name": "Adaline(Boston).ipynb",
  7 |       "provenance": [],
  8 |       "collapsed_sections": []
  9 |     },
 10 |     "kernelspec": {
 11 |       "display_name": "Python 3",
 12 |       "name": "python3"
 13 |     },
 14 |     "language_info": {
 15 |       "name": "python"
 16 |     }
 17 |   },
 18 |   "cells": [
 19 |     {
 20 |       "cell_type": "code",
 21 |       "metadata": {
 22 |         "id": "E2xGGh-0nf_4"
 23 |       },
 24 |       "source": [
 25 |         "from sklearn.datasets import load_boston\n",
 26 |         "import matplotlib.pyplot as plt\n",
 27 |         "import pandas as pd\n",
 28 |         "import numpy as np\n",
 29 |         "from sklearn.model_selection import train_test_split\n",
 30 |         "\n"
 31 |       ],
 32 |       "execution_count": 8,
 33 |       "outputs": []
 34 |     },
 35 |     {
 36 |       "cell_type": "code",
 37 |       "metadata": {
 38 |         "id": "MMns3e_nn3tf"
 39 |       },
 40 |       "source": [
 41 |         "#X, y = load_boston(return_X_y=True)\n",
 42 |         "boston_dataset=load_boston()\n",
 43 |         "#X=np.array(X)\n",
 44 |         "#y=np.array(y)\n",
 45 |         "boston = pd.DataFrame(boston_dataset.data, columns=boston_dataset.feature_names)\n",
 46 |         "boston.head(100)\n",
 47 |         "\n",
 48 |         "X=boston[['AGE','RM']]\n",
 49 |         "X=np.array(X)\n",
 50 |         "#print(X)\n",
 51 |         "\n",
 52 |         "Y=boston_dataset.target\n",
 53 |         "Y=np.array(Y)\n",
 54 |         "\n",
 55 |         "Y=Y.reshape(506,1)\n",
 56 |         "#print(Y.shape)"
 57 |       ],
 58 |       "execution_count": 9,
 59 |       "outputs": []
 60 |     },
 61 |     {
 62 |       "cell_type": "code",
 63 |       "metadata": {
 64 |         "id": "o3ehdF1I1Kcq"
 65 |       },
 66 |       "source": [
 67 |         "class AdalineRegressor:\n",
 68 |         "  def __init__(self):\n",
 69 |         "    pass\n",
 70 |         "\n",
 71 |         "  def fit(self,X_train,Y_train):\n",
 72 |         "    #w=(x.T*x)^-1*x.T*y\n",
 73 |         "    self.w=np.matmul(np.linalg.inv(np.matmul(X_train.T,X_train)),np.matmul(X_train.T,Y_train))\n",
 74 |         "    #print(self.w.shape)\n",
 75 |         "    print(self.w)\n",
 76 |         "\n",
 77 |         "  def predict(self,X_test):\n",
 78 |         "    Y_pred=np.matmul(X_test,self.w)  \n",
 79 |         "    return Y_pred\n",
 80 |         "\n",
 81 |         "  def evaluate(self,X_test,Y_test):\n",
 82 |         "    Y_pred=np.matmul(X_test,self.w)\n",
 83 |         "    subtract=np.abs(Y_test-Y_pred)\n",
 84 |         "    #return subtract\n",
 85 |         "\n",
 86 |         "    #MAE\n",
 87 |         "    MAE=np.mean(subtract)\n",
 88 |         "    #print(\"MAE =\",MAE)\n",
 89 |         "\n",
 90 |         "    #MSE\n",
 91 |         "    MSE=np.mean(np.square(subtract))\n",
 92 |         "    return MAE,MSE\n",
 93 |         "\n"
 94 |       ],
 95 |       "execution_count": 10,
 96 |       "outputs": []
 97 |     },
 98 |     {
 99 |       "cell_type": "code",
100 |       "metadata": {
101 |         "id": "xXwNlO136N42"
102 |       },
103 |       "source": [
104 |         "\n",
105 |         "X_train,X_test,y_train,y_test=train_test_split(X,Y,test_size=0.3,random_state=30)"
106 |       ],
107 |       "execution_count": 11,
108 |       "outputs": []
109 |     },
110 |     {
111 |       "cell_type": "code",
112 |       "metadata": {
113 |         "colab": {
114 |           "base_uri": "https://localhost:8080/"
115 |         },
116 |         "id": "YCRnxYPu2glm",
117 |         "outputId": "314f55ec-c0fd-41b6-d18f-94d3f0a2c118"
118 |       },
119 |       "source": [
120 |         "model=AdalineRegressor()\n",
121 |         "model.fit(X_train,y_train)\n",
122 |         "\n",
123 |         "y_pred=model.predict(X_test)\n",
124 |         "MAE,MSE=model.evaluate(X_test,y_test)\n",
125 |         "print(\"MAE =\",MAE)\n",
126 |         "print(\"MSE =\",MSE)\n",
127 |         "#print(y_pred)\n"
128 |       ],
129 |       "execution_count": 12,
130 |       "outputs": [
131 |         {
132 |           "output_type": "stream",
133 |           "text": [
134 |             "[[-0.11782797]\n",
135 |             " [ 4.92265742]]\n",
136 |             "MAE = 4.496512847727152\n",
137 |             "MSE = 43.36388887645207\n"
138 |           ],
139 |           "name": "stdout"
140 |         }
141 |       ]
142 |     },
143 |     {
144 |       "cell_type": "code",
145 |       "metadata": {
146 |         "colab": {
147 |           "base_uri": "https://localhost:8080/",
148 |           "height": 466
149 |         },
150 |         "id": "0b8dI529Du3f",
151 |         "outputId": "56ebe47e-4d5d-4631-d22a-5d73b4c89c1e"
152 |       },
153 |       "source": [
154 |         "\n",
155 |         "#plot 3d plane\n",
156 |         "fig = plt.figure(figsize=(8,8))\n",
157 |         "p = fig.add_subplot(111,projection='3d')\n",
158 |         "\n",
159 |         "x = np.arange(X_train[:,0].min(), X_train[:,0].max())\n",
160 |         "y = np.arange(X_train[:,1].min(), X_train[:,1].max())\n",
161 |         "\n",
162 |         "x, y = np.meshgrid(x, y)\n",
163 |         "\n",
164 |         "plane = x *model.w[0] + y *model. w[1]\n",
165 |         "\n",
166 |         "p.plot_surface(x, y, plane,alpha=0.5)\n",
167 |         "\n",
168 |         "p.scatter(X_train[:,0], X_train[:,1], y_train)\n",
169 |         "\n",
170 |         "p.set_xlabel('Age')\n",
171 |         "p.set_ylabel('Number of rooms')#RM\n",
172 |         "p.set_zlabel('Price')\n",
173 |         "p.view_init(-150,50)#angle of the plane\n",
174 |         "plt.show()\n",
175 |         "\n"
176 |       ],
177 |       "execution_count": 13,
178 |       "outputs": [
179 |         {
180 |           "output_type": "display_data",
181 |           "data": {
182 |             "image/png": "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\n",
183 |             "text/plain": [
184 |               "<Figure size 576x576 with 1 Axes>"
185 |             ]
186 |           },
187 |           "metadata": {
188 |             "tags": [],
189 |             "needs_background": "light"
190 |           }
191 |         }
192 |       ]
193 |     },
194 |     {
195 |       "cell_type": "code",
196 |       "metadata": {
197 |         "id": "LYLP4ZiZDFNE"
198 |       },
199 |       "source": [
200 |         ""
201 |       ],
202 |       "execution_count": 13,
203 |       "outputs": []
204 |     }
205 |   ]
206 | }


--------------------------------------------------------------------------------