├── README.md ├── Neural_Network.py ├── Linear Regression.ipynb └── K-Nearest Neighboor.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # ML Algorithms From Scratch 2 | 3 | In this folder I carry out machine learning algorithms from first principles to improve my understanding. 4 | 5 | This will be an ongoing project and I am hoping to cover the following: 6 | 7 | - Linear Regression :heavy_check_mark: 8 | - Polynomial Regression 9 | - Logistic Regression :heavy_check_mark: 10 | - Support Vector Machines :heavy_check_mark: 11 | - K-Nearest Neighboor :heavy_check_mark: 12 | - Naive Bayes 13 | - K-Means 14 | - Neural Network :heavy_check_mark: 15 | -------------------------------------------------------------------------------- /Neural_Network.py: -------------------------------------------------------------------------------- 1 | 2 | # import packages 3 | import numpy as np 4 | 5 | print('This is a neural network from scratch using one hidden layer') 6 | 7 | 8 | # define the layer size for the network 9 | def layer_size(X, Y): 10 | 11 | input_size = X.shape[0] 12 | hidden_size = 3 13 | output_size = Y.shape[0] 14 | 15 | return input_size, hidden_size, output_size 16 | 17 | # initialise the weights and biases randomnly to enable symmetry breaking 18 | def initialise_parameters(input_size, hidden_size, output_size): 19 | 20 | W1 = np.random.randn(hidden_size, input_size) * 0.01 21 | W2 = np.random.randn(output_size, hidden_size) * 0.01 22 | b1 = np.zeros((hidden_size, 1)) 23 | b2 = np.zeros((output_size, 1)) 24 | 25 | # store in dict for access 26 | parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2} 27 | 28 | return parameters 29 | 30 | # sigmoid 31 | def sigmoid(z): 32 | return 1/(1+np.exp(-z)) 33 | 34 | # derivative 35 | def d_sigmoid(z): 36 | return z*(1-z) 37 | 38 | # forward prop 39 | def forward(X, parameters): 40 | 41 | # get parameters from dict 42 | W1 = parameters['W1'] 43 | W2 = parameters['W2'] 44 | b1 = parameters['b1'] 45 | b2 = parameters['b2'] 46 | 47 | # calculate the forward using the activation function 48 | Z1 = np.dot(W1,X) + b1 49 | A1 = np.tanh(Z1) 50 | Z2 = np.dot(W2,A1) + b2 51 | A2 = sigmoid(Z2) 52 | 53 | # store the values in a dict 54 | cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2} 55 | 56 | return A2, cache 57 | 58 | # cross entropy loss function 59 | def compute_cost(A2, Y): 60 | 61 | cost = (-1/Y.shape[1]) * np.sum(Y*np.log(A2) + (1-Y) * np.log(1-A2)) 62 | cost = float(np.squeeze(cost)) 63 | 64 | return cost 65 | 66 | # backprop 67 | def backprop(parameters, cache, X, Y): 68 | 69 | m = X.shape[1] 70 | 71 | # get parameters from dict in cache 72 | W1 = parameters['W1'] 73 | W2 = parameters['W2'] 74 | A1 = cache['A1'] 75 | A2 = cache['A2'] 76 | 77 | # compute gradients 78 | dZ2 = A2 - Y 79 | dW2 = (1/m) * np.dot(dZ2,A1.T) 80 | db2 = (1/m) * np.sum(dZ2, axis=1,keepdims=True) 81 | dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2)) 82 | dW1 = (1/m) * np.dot(dZ1,X.T) 83 | db1 = (1/m) * np.sum(dZ1, axis=1,keepdims=True) 84 | 85 | # store grads in dict 86 | grads = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2} 87 | 88 | return grads 89 | 90 | # update the parameters 91 | def update_params(parameters, grads, alpha = 1): 92 | 93 | # fetch grads, weights and biases from dicts 94 | W1 = parameters['W1'] 95 | b1 = parameters['b1'] 96 | W2 = parameters['W2'] 97 | b2 = parameters['b2'] 98 | dW1 = grads['dW1'] 99 | db1 = grads['db1'] 100 | dW2 = grads['dW2'] 101 | db2 = grads['db2'] 102 | 103 | # update them 104 | W1 -= alpha * dW1 105 | b1 -= alpha * db1 106 | W2 -= alpha * dW2 107 | b2 -= alpha * db2 108 | 109 | # store in dict 110 | parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2} 111 | 112 | return parameters 113 | 114 | # define the model 115 | def model(X, Y, hidden_size, epochs = 1000): 116 | 117 | # initiate layer size 118 | np.random.seed(3) 119 | input_size = layer_size(X, Y)[0] 120 | output_size = layer_size(X, Y)[2] 121 | 122 | # intialse the weights 123 | parameters = initialise_parameters(input_size, hidden_size, output_size) 124 | 125 | # train the model 126 | for i in range(0, epochs): 127 | 128 | A2, cache = forward(X, parameters) 129 | cost = compute_cost(A2, Y) 130 | grads = backprop(parameters, cache, X, Y) 131 | parameters = update_params(parameters, grads) 132 | 133 | # Print the cost every 1000 iterations 134 | print ("Cost after iteration %i: %f" %(i, cost)) 135 | 136 | return parameters 137 | 138 | 139 | # training data 140 | X = np.array([[0,0,1,1], 141 | [0,1,1,1], 142 | [1,0,1,1], 143 | [1,1,1,1]]) 144 | 145 | # expected output 146 | Y = np.array([[0],[1],[1],[1]]) 147 | 148 | 149 | # apply the model 150 | parameters = model(X, Y, hidden_size = 4, epochs = 1000) 151 | 152 | 153 | # predict the output 154 | def predict(parameters, X): 155 | 156 | A2, cache = forward(X, parameters) 157 | 158 | return np.round(A2,3) 159 | 160 | 161 | 162 | print('The output is:') 163 | print(predict(parameters,X)) 164 | print('The expected output:') 165 | print(Y) 166 | 167 | 168 | -------------------------------------------------------------------------------- /Linear Regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Linear Regression From First Principles" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## In this notebook we will derive the supervised learning algorith of linear regression from scratch using its mathematical principles" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 28, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "# import packages\n", 24 | "import numpy as np\n", 25 | "import matplotlib.pyplot as plt\n", 26 | "import pandas as pd" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "### Import and read the data" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 29, 39 | "metadata": { 40 | "scrolled": true 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "\n", 48 | "RangeIndex: 30 entries, 0 to 29\n", 49 | "Data columns (total 2 columns):\n", 50 | " # Column Non-Null Count Dtype \n", 51 | "--- ------ -------------- ----- \n", 52 | " 0 YearsExperience 30 non-null float64\n", 53 | " 1 Salary 30 non-null float64\n", 54 | "dtypes: float64(2)\n", 55 | "memory usage: 608.0 bytes\n" 56 | ] 57 | } 58 | ], 59 | "source": [ 60 | "# import the data\n", 61 | "data = pd.read_csv('Salary_Data.csv')\n", 62 | "data.info()" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "### Feature Engineering" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 30, 75 | "metadata": {}, 76 | "outputs": [], 77 | "source": [ 78 | "# set up the data\n", 79 | "X = data['YearsExperience'].values\n", 80 | "y = data['Salary'].values" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "Normalise the data using Z = (x - mu)/sigma to improve performance" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 32, 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [ 96 | "# normalise the data\n", 97 | "for i in range(len(X)):\n", 98 | " X[i] = (X[i] - np.mean(X)) / np.std(X)\n", 99 | " y[i] = (y[i] - np.mean(y)) / np.std(y)" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | " Prep the data for matrix multiplications " 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 34, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "# assign dummy features\n", 116 | "y = np.reshape(y, (30,1))\n", 117 | "X = np.reshape(X,newshape=(-1,1))\n", 118 | "X = np.hstack((np.ones((X.shape[0],1)), X))" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "### Modelling" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 35, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "def linreg(x, y, alpha, epochs):\n", 135 | " \n", 136 | " # intialise the theta values\n", 137 | " m = len(y)\n", 138 | " theta = np.zeros((X.shape[1],1))\n", 139 | " cost = []\n", 140 | " \n", 141 | " for i in range(epochs):\n", 142 | " \n", 143 | " # predicted output\n", 144 | " h = np.dot(x,theta)\n", 145 | " \n", 146 | " # cost function\n", 147 | " J = (1/(2*m)) * np.sum(np.square(h-y))\n", 148 | " \n", 149 | " # update the parameters\n", 150 | " d_theta = (1/m) * np.dot(x.T, h-y)\n", 151 | " theta = theta - alpha*d_theta\n", 152 | " \n", 153 | " cost.append(J)\n", 154 | " \n", 155 | " return theta, cost" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "Apply the model and plot the cost function " 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 36, 168 | "metadata": {}, 169 | "outputs": [], 170 | "source": [ 171 | "# set parameters for the iteration\n", 172 | "alpha = 0.1\n", 173 | "epochs = 21" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 37, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "# apply the model\n", 183 | "theta, cost = linreg(X, y, alpha, epochs)" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": {}, 189 | "source": [ 190 | "Plot the linear regression line " 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": 39, 196 | "metadata": {}, 197 | "outputs": [], 198 | "source": [ 199 | "# unpack the X values\n", 200 | "one, a = zip(*X)" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 40, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [ 209 | "# create the line, y = mx + c\n", 210 | "y_pred = a*theta[1] + theta[0]" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 43, 216 | "metadata": {}, 217 | "outputs": [ 218 | { 219 | "data": { 220 | "image/png": "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\n", 221 | "text/plain": [ 222 | "
" 223 | ] 224 | }, 225 | "metadata": { 226 | "needs_background": "light" 227 | }, 228 | "output_type": "display_data" 229 | } 230 | ], 231 | "source": [ 232 | "# plotting the regression line\n", 233 | "plt.scatter(a,y, label='Data Points')\n", 234 | "plt.plot(a,y_pred, color = 'r', label = 'Regression line')\n", 235 | "plt.xlabel('Years Experience (rescaled)', fontsize = 14)\n", 236 | "plt.ylabel('Salary (rescaled)', fontsize = 14)\n", 237 | "plt.xticks(size=14)\n", 238 | "plt.yticks(size=14)\n", 239 | "plt.legend()\n", 240 | "plt.show()" 241 | ] 242 | }, 243 | { 244 | "cell_type": "markdown", 245 | "metadata": {}, 246 | "source": [ 247 | " We can see that our line fits the data very well " 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "## Model from sklearn" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": 74, 260 | "metadata": {}, 261 | "outputs": [], 262 | "source": [ 263 | "# import packages\n", 264 | "from sklearn.model_selection import train_test_split\n", 265 | "from sklearn.linear_model import LinearRegression\n", 266 | "from sklearn import metrics" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": 70, 272 | "metadata": {}, 273 | "outputs": [ 274 | { 275 | "data": { 276 | "text/plain": [ 277 | "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)" 278 | ] 279 | }, 280 | "execution_count": 70, 281 | "metadata": {}, 282 | "output_type": "execute_result" 283 | } 284 | ], 285 | "source": [ 286 | "# set up the data again\n", 287 | "X = data[['YearsExperience']].values\n", 288 | "y = data['Salary'].values\n", 289 | "\n", 290 | "# split into test train \n", 291 | "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.5, random_state = 7)\n", 292 | "\n", 293 | "# train the model\n", 294 | "model = LinearRegression() \n", 295 | "model.fit(x_train, y_train)" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": 71, 301 | "metadata": {}, 302 | "outputs": [ 303 | { 304 | "name": "stdout", 305 | "output_type": "stream", 306 | "text": [ 307 | "Intercept: 0.155417965345038\n", 308 | "Coefficient: [1.0057085]\n" 309 | ] 310 | } 311 | ], 312 | "source": [ 313 | "# Print out the line values y = mx + c\n", 314 | "print(\"Intercept: \", model.intercept_)\n", 315 | "print(\"Coefficient: \", model.coef_)" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 72, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [ 324 | "# use the test data to predict values to test the model\n", 325 | "pred = model.predict(x_test)" 326 | ] 327 | }, 328 | { 329 | "cell_type": "code", 330 | "execution_count": 73, 331 | "metadata": {}, 332 | "outputs": [ 333 | { 334 | "data": { 335 | "image/png": "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\n", 336 | "text/plain": [ 337 | "
" 338 | ] 339 | }, 340 | "metadata": { 341 | "needs_background": "light" 342 | }, 343 | "output_type": "display_data" 344 | } 345 | ], 346 | "source": [ 347 | "# plotting the regression line\n", 348 | "plt.scatter(x_test,y_test, label='Data Points')\n", 349 | "plt.plot(x_test, pred, 'Red', label = 'Linear Regression Line')\n", 350 | "plt.xlabel('Years Experience (rescaled)', fontsize = 14)\n", 351 | "plt.ylabel('Salary (rescaled)', fontsize = 14)\n", 352 | "plt.xticks(size=14)\n", 353 | "plt.yticks(size=14)\n", 354 | "plt.legend()\n", 355 | "plt.show()" 356 | ] 357 | } 358 | ], 359 | "metadata": { 360 | "kernelspec": { 361 | "display_name": "Python 3 (ipykernel)", 362 | "language": "python", 363 | "name": "python3" 364 | }, 365 | "language_info": { 366 | "codemirror_mode": { 367 | "name": "ipython", 368 | "version": 3 369 | }, 370 | "file_extension": ".py", 371 | "mimetype": "text/x-python", 372 | "name": "python", 373 | "nbconvert_exporter": "python", 374 | "pygments_lexer": "ipython3", 375 | "version": "3.9.7" 376 | } 377 | }, 378 | "nbformat": 4, 379 | "nbformat_minor": 4 380 | } 381 | -------------------------------------------------------------------------------- /K-Nearest Neighboor.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# KNN from scratch" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## In this code I implement the KNN algorithm from scratch using the OOP paradigm " 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 40, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "# import packages\n", 24 | "import numpy as np\n", 25 | "import matplotlib.pyplot as plt\n", 26 | "from collections import Counter\n", 27 | "from sklearn.model_selection import train_test_split\n", 28 | "from sklearn import datasets" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "## Model Class" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 90, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "# distance between two-dimensional vectors\n", 45 | "def distance(x1, x2):\n", 46 | " return np.sqrt(np.sum((x1 - x2) ** 2))\n", 47 | "\n", 48 | "# build the KNN class\n", 49 | "class model:\n", 50 | " \n", 51 | " # compare to k neareast points\n", 52 | " def __init__(self, k):\n", 53 | " self.k = k\n", 54 | "\n", 55 | " # assign training data \n", 56 | " def fit(self, X, y):\n", 57 | " self.X_train = X\n", 58 | " self.y_train = y\n", 59 | "\n", 60 | " # array of predicted value for each data points \n", 61 | " def predict(self, X):\n", 62 | " preds = [self.predict_class(x) for x in X]\n", 63 | " return np.array(preds)\n", 64 | "\n", 65 | " def predict_class(self, x):\n", 66 | " \n", 67 | " # distances between x and all data points in the training set\n", 68 | " distances = [distance(x, x_train) for x_train in self.X_train]\n", 69 | " \n", 70 | " # Sort by distance and return indices of the first k neighbors with shortest distance \n", 71 | " k_idx_val = np.argsort(distances)[:self.k]\n", 72 | " \n", 73 | " # get the labels of the k nearest neighbor training samples using the index values\n", 74 | " labels = [self.y_train[i] for i in k_idx_val]\n", 75 | " \n", 76 | " # get the mode using the counter function\n", 77 | " mode = Counter(labels).most_common(1)\n", 78 | " \n", 79 | " # return the first mode if the are more than one\n", 80 | " return mode[0][0]\n", 81 | " " 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "## Testing the model on a dataset " 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 91, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "data": { 98 | "image/png": "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\n", 99 | "text/plain": [ 100 | "
" 101 | ] 102 | }, 103 | "metadata": { 104 | "needs_background": "light" 105 | }, 106 | "output_type": "display_data" 107 | } 108 | ], 109 | "source": [ 110 | "# import the data\n", 111 | "data = datasets.load_breast_cancer()\n", 112 | "\n", 113 | "# assign and separate to train and test\n", 114 | "X, y = data.data, data.target\n", 115 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2)\n", 116 | "\n", 117 | "# plot the first two features for visualisation\n", 118 | "plt.figure()\n", 119 | "plt.scatter(X_train[:,0], X_train[:,1], c=y_train)\n", 120 | "plt.xlabel('radius')\n", 121 | "plt.ylabel('texture')\n", 122 | "plt.show()" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 92, 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "name": "stdout", 132 | "output_type": "stream", 133 | "text": [ 134 | "Accuracy of model: 91.22807017543859 %\n" 135 | ] 136 | } 137 | ], 138 | "source": [ 139 | "# function for the accuracy of the model\n", 140 | "def accuracy(y_true, preds):\n", 141 | " accuracy = (y_true == preds).mean()\n", 142 | " return accuracy\n", 143 | "\n", 144 | "# apply the model to the data and evaluate the accuracy\n", 145 | "knn = model(k=5)\n", 146 | "knn.fit(X_train, y_train)\n", 147 | "predictions = knn.predict(X_test)\n", 148 | "print(\"Accuracy of model:\", accuracy(y_test, predictions)*100,'%')" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "## Very good accuracy! " 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 93, 161 | "metadata": {}, 162 | "outputs": [ 163 | { 164 | "data": { 165 | "image/png": "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\n", 166 | "text/plain": [ 167 | "
" 168 | ] 169 | }, 170 | "metadata": { 171 | "needs_background": "light" 172 | }, 173 | "output_type": "display_data" 174 | } 175 | ], 176 | "source": [ 177 | "# plot the predictions\n", 178 | "plt.figure()\n", 179 | "plt.scatter(X_test[:,0],X_test[:,1],c=predictions)\n", 180 | "plt.xlabel('radius')\n", 181 | "plt.ylabel('texture')\n", 182 | "plt.show()" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "## The data points look to be in a reasonable location compared to the the training examples above." 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [] 198 | } 199 | ], 200 | "metadata": { 201 | "kernelspec": { 202 | "display_name": "Python 3", 203 | "language": "python", 204 | "name": "python3" 205 | }, 206 | "language_info": { 207 | "codemirror_mode": { 208 | "name": "ipython", 209 | "version": 3 210 | }, 211 | "file_extension": ".py", 212 | "mimetype": "text/x-python", 213 | "name": "python", 214 | "nbconvert_exporter": "python", 215 | "pygments_lexer": "ipython3", 216 | "version": "3.7.6" 217 | } 218 | }, 219 | "nbformat": 4, 220 | "nbformat_minor": 4 221 | } 222 | --------------------------------------------------------------------------------