diff --git a/convolutional_neural_network.ipynb b/convolutional_neural_network.ipynb new file mode 100644 index 0000000000..37a5826638 --- /dev/null +++ b/convolutional_neural_network.ipynb @@ -0,0 +1,481 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "convolutional_neural_network.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true, + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3DR-eO17geWu", + "colab_type": "text" + }, + "source": [ + "# Convolutional Neural Network" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EMefrVPCg-60", + "colab_type": "text" + }, + "source": [ + "### Importing the libraries" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "sCV30xyVhFbE", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "outputId": "29f8d2bf-147e-4735-d0f1-ff9c8918b600" + }, + "source": [ + "import tensorflow as tf\n", + "from keras.preprocessing.image import ImageDataGenerator" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FIleuCAjoFD8", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "outputId": "2447f005-8785-4fc8-8529-4ea1a12b1737" + }, + "source": [ + "tf.__version__" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic": { + "type": "string" + }, + "text/plain": [ + "'2.2.0'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 2 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oxQxCBWyoGPE", + "colab_type": "text" + }, + "source": [ + "## Part 1 - Data Preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HHxc7_vOo0Ro", + "colab_type": "text" + }, + "source": [ + "Preprocessing the training set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "X-lMGlH9o3RO", + "colab_type": "code", + "colab": {} + }, + "source": [ + "train_datagen = ImageDataGenerator(\n", + " rescale=1./255,\n", + " shear_range=0.2,\n", + " zoom_range=0.2,\n", + " horizontal_flip=True)\n", + "train_generator = train_datagen.flow_from_directory(\n", + " 'dataset/training_set',\n", + " target_size=(150, 150),\n", + " batch_size=32,\n", + " class_mode='binary')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MvE-heJNo3GG", + "colab_type": "text" + }, + "source": [ + "### Preprocessing the Training set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0koUcJMJpEBD", + "colab_type": "code", + "colab": {} + }, + "source": [ + "train_datagen = ImageDataGenerator(rescale = 1./255,\n", + " shear_range = 0.2,\n", + " zoom_range = 0.2,\n", + " horizontal_flip = True)\n", + "training_set = train_datagen.flow_from_directory('dataset/training_set',\n", + " target_size = (64, 64),\n", + " batch_size = 32,\n", + " class_mode = 'binary')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mrCMmGw9pHys", + "colab_type": "text" + }, + "source": [ + "### Preprocessing the Test set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SH4WzfOhpKc3", + "colab_type": "code", + "colab": {} + }, + "source": [ + "test_datagen = ImageDataGenerator(rescale = 1./255)\n", + "test_set = test_datagen.flow_from_directory('dataset/test_set',\n", + " target_size = (64, 64),\n", + " batch_size = 32,\n", + " class_mode = 'binary')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "af8O4l90gk7B", + "colab_type": "text" + }, + "source": [ + "## Part 2 - Building the CNN" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ces1gXY2lmoX", + "colab_type": "text" + }, + "source": [ + "### Initialising the CNN" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SAUt4UMPlhLS", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn = tf.keras.models.Sequential()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "u5YJj_XMl5LF", + "colab_type": "text" + }, + "source": [ + "### Step 1 - Convolution" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XPzPrMckl-hV", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.add(tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu', input_shape=[64, 64, 3]))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tf87FpvxmNOJ", + "colab_type": "text" + }, + "source": [ + "### Step 2 - Pooling" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ncpqPl69mOac", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xaTOgD8rm4mU", + "colab_type": "text" + }, + "source": [ + "### Adding a second convolutional layer" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "i_-FZjn_m8gk", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.add(tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu'))\n", + "cnn.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tmiEuvTunKfk", + "colab_type": "text" + }, + "source": [ + "### Step 3 - Flattening" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6AZeOGCvnNZn", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.add(tf.keras.layers.Flatten())" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dAoSECOm203v", + "colab_type": "text" + }, + "source": [ + "### Step 4 - Full Connection" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8GtmUlLd26Nq", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.add(tf.keras.layers.Dense(units=128, activation='relu'))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yTldFvbX28Na", + "colab_type": "text" + }, + "source": [ + "### Step 5 - Output Layer" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1p_Zj1Mc3Ko_", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.add(tf.keras.layers.Dense(units=1, activation='sigmoid'))" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "D6XkI90snSDl", + "colab_type": "text" + }, + "source": [ + "## Part 3 - Training the CNN" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vfrFQACEnc6i", + "colab_type": "text" + }, + "source": [ + "### Compiling the CNN" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "NALksrNQpUlJ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ehS-v3MIpX2h", + "colab_type": "text" + }, + "source": [ + "### Training the CNN on the Training set and evaluating it on the Test set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XUj1W4PJptta", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cnn.fit(x = training_set, validation_data = test_set, epochs = 25)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "U3PZasO0006Z", + "colab_type": "text" + }, + "source": [ + "## Part 4 - Making a single prediction" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gsSiWEJY1BPB", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import numpy as np\n", + "from keras.preprocessing import image\n", + "test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', target_size = (64, 64))\n", + "test_image = image.img_to_array(test_image)\n", + "test_image = np.expand_dims(test_image, axis = 0)\n", + "result = cnn.predict(test_image)\n", + "training_set.class_indices\n", + "if result[0][0] == 1:\n", + " prediction = 'dog'\n", + "else:\n", + " prediction = 'cat'" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ED9KB3I54c1i", + "colab_type": "code", + "colab": {} + }, + "source": [ + "print(prediction)" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/principal_component_analysis.ipynb b/principal_component_analysis.ipynb new file mode 100644 index 0000000000..4469cb4169 --- /dev/null +++ b/principal_component_analysis.ipynb @@ -0,0 +1,416 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy of principal_component_analysis.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true, + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VQ3syspj_rKn", + "colab_type": "text" + }, + "source": [ + "# Principal Component Analysis (PCA)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xJGl9TcT_skx", + "colab_type": "text" + }, + "source": [ + "## Importing the libraries" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "BNEgrGwd_29D", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Hyp1gza1_6qX", + "colab_type": "text" + }, + "source": [ + "## Importing the dataset" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lPLTDBVI__ZQ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "dataset = pd.read_csv('/Wine.csv')\n", + "X = dataset.iloc[:, :-1].values\n", + "y = dataset.iloc[:, -1].values" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1wrHODfJAEiI", + "colab_type": "text" + }, + "source": [ + "## Feature Scaling" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "W-UCD7ezAJG2", + "colab_type": "code", + "colab": {} + }, + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "sc = StandardScaler()\n", + "X = sc.fit_transform(X)" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3bUhSHktAcOe", + "colab_type": "text" + }, + "source": [ + "## Splitting the dataset into the Training set and Test set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "L7hGLt1qAced", + "colab_type": "code", + "colab": {} + }, + "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.2, random_state = 0)" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S3i3lRiwASAX", + "colab_type": "text" + }, + "source": [ + "## Applying PCA" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "TAi_sSw9AVzI", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "outputId": "c64dd5ee-c9e4-4fd7-e3f9-a0ad79cc0492" + }, + "source": [ + "from sklearn.decomposition import PCA\n", + "pca = PCA(n_components = 2)\n", + "X_train = pca.fit_transform(X_train)\n", + "X_test = pca.transform(X_test)\n", + "explained_variance = pca.explained_variance_ratio_\n", + "print(explained_variance)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[0.65629405 0.34370595]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UBx16JVLAuel", + "colab_type": "text" + }, + "source": [ + "## Training the Logistic Regression model on the Training set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XDQahsqTAy44", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104 + }, + "outputId": "9a024c6f-39ae-4223-8fa4-7ec3a063c839" + }, + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "classifier = LogisticRegression(random_state = 0)\n", + "classifier.fit(X_train, y_train)" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", + " intercept_scaling=1, l1_ratio=None, max_iter=100,\n", + " multi_class='auto', n_jobs=None, penalty='l2',\n", + " random_state=0, solver='lbfgs', tol=0.0001, verbose=0,\n", + " warm_start=False)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "37ouVXGHBGAg", + "colab_type": "text" + }, + "source": [ + "## Predicting the Test set results" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8uUGyVCTBMHz", + "colab_type": "code", + "colab": {} + }, + "source": [ + "y_pred = classifier.predict(X_test)" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MTck416XBPnD", + "colab_type": "text" + }, + "source": [ + "## Making the Confusion Matrix" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "2LO7H5LsBS1b", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 69 + }, + "outputId": "0107545f-b1b7-4180-eac9-519526610467" + }, + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "print(cm)" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[[14 0 0]\n", + " [ 1 15 0]\n", + " [ 0 0 6]]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h6pZMBrUBXwb", + "colab_type": "text" + }, + "source": [ + "## Visualising the Training set results" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FK_LpLOeBdQ4", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 367 + }, + "outputId": "617ba1ab-cb82-4593-f185-e9ebccb904d3" + }, + "source": [ + "from matplotlib.colors import ListedColormap\n", + "X_set, y_set = X_train, y_train\n", + "X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n", + " np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\n", + "plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n", + " alpha = 0.75, cmap = ListedColormap(('red', 'green', 'blue')))\n", + "plt.xlim(X1.min(), X1.max())\n", + "plt.ylim(X2.min(), X2.max())\n", + "for i, j in enumerate(np.unique(y_set)):\n", + " plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n", + " c = ListedColormap(('red', 'green', 'blue'))(i), label = j)\n", + "plt.title('Logistic Regression (Training set)')\n", + "plt.xlabel('PC1')\n", + "plt.ylabel('PC2')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEWCAYAAABv+EDhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5wcZZ3v8c9vZuIESUgwhEm4RBwhOXjFNSJgJHFxWS8EdVEPiqzoslk9x4OCHlyI+tI9m3V33WN0b4cTcUWFs+jiFRd3RWUQ1qACRlkMCTpAhIQJt0ACyZCZ+Z0/qjrp6VR1V3VXd1V3fd+vFy+S6u7qpztdz+95fs+lzN0REZHy6cu7ACIikg8FABGRklIAEBEpKQUAEZGSUgAQESkpBQARkZJSAJADmNllZvbRJl63yMx2mVl/O8pVVGb2XTN7Z5vO/ftm9s02nPdOM1uR9XPzYmY/NbPn512ObmNaB9DdzOxe4Hx3/363vreZnQd8HtgNTAH3AKvd/TutlrHbmdmtwPuArcCvqh46GHgKqFzAr3X3mzpcvFyY2RXA/e7+kapjbwX+q7uflVvBupB6AFIU6919FjAX+EfgajObm/WbdFPvxMxeBsxx91vcfYu7z6r8Fz7lxVXHbqp63UA+Jc7Vt4FXmdmCvAvSTRQAepSZDZrZZ8xsa/jfZ8xssOrxi81sW/jY+WbmZnZs+NgVZvbn4Z8PM7PvmNkOM3vUzG4ysz4z+zKwCLg2TPtcbGbHhOcZCF/7LDP7QvgejyVJZbj7FPBlghbucVWf5W/MbIuZjYUpqoNSfJb/Y2bXmdmTBJXEEWb2NTN7yMzuMbMLqs51opndamZPhO/16fD4TDO70sweCb+Ln5nZUPjYiJmdH/65z8w+Ymb3mdl2M/uSmc0JH6t8P+8MP8vDZra6ztfxWuDGBP/W55nZf5jZWjN7BPi4mT3XzH4YlvdhM7uqOqCa2b1m9urwzx83s6+GZd0ZpnyWNvnc3zGzn4eP/YuZfaXyW4oo97FmdqOZPR6W8StVj/0XM7s+/M1tClv4mNkq4Bzg4vB3dy2Au+8BbgN+v9H3JfspAPSu1cBJwAnAi4ETgY8AmNlrgIuAVwPHAivqnOeDwP3AfGAIuBRwdz8X2AKsDFugfx3x2i8DzwSeDxwOrG1UaAta6O8C9gL3hYf/ElgcfpZjgSOBj6X4LG8H1gCzgR8D1wK/CM9zGvABM6tUHJ8FPuvuhwDPBb4aHn8nMAc4GpgHvIcgZVXrvPC/VwHDwCzg72ueswxYEr73x8zs+Jiv44XAppjHar0cGCX4N1oDGPBJ4Ajg+LDcH6/z+jOBqwl6YN+OKHPD55rZM4BvAFcAzwL+GXhTnfP8L+B7wKHAUcDfhec5GLge+H8Ev5uzgX80s+e5+zrgKuCvw9/dyqrzbST4rUtCCgC96xzgz9x9u7s/BHwCODd87K3AF9z9Tnd/ivoVw15gIfBsd9/r7jd5goEjM1tI0IJ9j7s/Fr62Xmv2JDPbAewB/gZ4h7tvNzMDVgEXuvuj7r4T+AuCSiHpZ/mWu/9H2Lt4ITDf3f/M3Z9291Hgc1Xn2wsca2aHufsud7+l6vg84Fh3n3T329z9iYj3Ogf4tLuPuvsu4BLgbJuelvmEu+92918QBKK4SmsusLPOd1Ztq7v/nbtPhOf+tbtf7+7j4b//p4HldV5/s7tf5+6TBIG7XkUa99yTgAHgb8N/768DP61znr3As4Ej3H2Pu98cHj8DuNfdvxB+np8DXwPe0uA72EnwnUlCCgC96wj2t6AJ/3xE1WO/rXqs+s+1PgX8GviemY2a2Z8mfP+jgUfd/bGEz7/F3ecStAa/DbwyPD6foBdxW5h62QH8W3gckn2W6mPPBo6onCs836UELWeAPyLobdwVpnnOCI9/Gfh3grGJrWb212Y2I+K9or73garzAzxY9eenCHoJUR4j6LUkMe1zm9mQmV1tZg+Y2RPAlcBhdV5fW6aZFj+WEPfcI4AHahoI9X5bFxP0VH4appLeHR5/NvDymn+jc4BG+f3ZwI4Gz5EqCgC9ayvBhVSxKDwGsI2gy11xdNxJ3H2nu3/Q3YcJuv4XmdlplYfrvP9vgWdZyoHcsNX8XuBcM3sJ8DBBquX57j43/G9O1UBoks9SWyHdU3Wuue4+291fF77/3e7+NoLUw18B15jZwWGL9hPu/jzgFIJW6h9GvFfU9z4BjKX5HkK/JAhGSdT+W/xFeOyFYTrrHQSVbTttA44Me20V9X5bD7r7H7v7EcCfEKR5jiX4N7qx5t9olru/t/LSmFMeT9CjkoQUAHrDjHCQsvLfAEH+9SNmNt/MDiPImV8ZPv+rwLvM7HgzeyYQO+ffzM4IB+sMeByYJJiqCUGlNhz1OnffBnyX4KI+1MxmmNmpST6Muz8KXA58LEzbfA5Ya2aHh2U6sipnn/izhH4K7DSzD5vZQWbWb2YvsGDGDWb2DjObH75vpTU5ZWavMrMXhmMUTxCkL6Yizv/PwIVm9hwzm0VQEX/F3SeSfPYa11E/bVPPbGAX8LiZHQn8zybPk8Z6gt/H+8xswMzeQDD2FMnM3mJmleD9GEHFPgV8B1hsZueGv5sZZvayqrGSA353ZjYTeCnB2IEkpADQG64jaCVX/vs48OfArQStyDuA28NjuPt3gb8FbiBI71Ty3OMR5z4O+D5BZbIe+Ed3vyF87JMEQWaHmX0o4rXnElSUdwHbgQ+k+EyfAV5nZi8CPlwpZ5jO+D7BIGraz0KYtz6DYED5HoIexuUEA7wArwHuNLNdBAPCZ7v7boL0wzUElf9Ggtk5X454i38Kj/8oPP8e4H+k+NzVZb2doAJ/eRMv/wTwOwRB+1+BrzdThjTc/WngDwjSaDsIeh3fIebfAngZ8JPwu/428P5w7GQncDrBuMxWgpTTXwGVWWyfB54X/u4qM8tWAiPuvhVJTAvBhLBl9Z/AYJMt1cLopc8CYGanA//N3d+Yd1maYWY/AS5z9y904H3+yN3/s53v02sUAErKzN5E0HN4JvBFYKqLK5me+SzdzsyWE0xdfZhg4PYyYDhMCUrBKAVUXn9CkJb5DUHe9r31n15ovfRZut0SgoHYHQRrSN6syr+41AMQESkp9QBEREqqqzaNmjF7hs88bGbexRAR6Sq77t31sLvPrz3eVQFg5mEzWfrxpY2fKCIi+4ycN3Jf1HGlgERESkoBQESkpBQARERKqqvGAERE8jCrfxZnLzqbhQctpK+g7eYppti2extXb7maXZO7Er1GAUBEpIGzF53NC456AYOzB5m+2WlxuDvzds7jbM7m8nsuT/SaYoYyEZECWXjQwkJX/gBmxuDsQRYetDDxaxQAREQa6KOv0JV/hZmlSlEpAIiIlJQCgIhIl7j0gks55fhTWPnKlZmcTwFARKRLvOnsN/G5qz+X2fkUAEREMjb7mmsZfsnvsvjw4xl+ye8y+5prMznvy055GXMOndP4iQlpGqiISIZmX3MtCy76KH279wAw4/6tLLgouFX1zjdnk7rJinoAIiIZmr9m7b7Kv6Jv9x7mr1mbU4ni5R4AzKzfzH5uZt/JuywiIq0aeCD6Bmhxx/OUewAA3g9szLsQIiJZmDgyeiFW3PE85RoAzOwo4PVAsnXLIiIF99DqC5k6aPqNq6YOmslDqy9s+dwXrbqIt732bdzz63tY/qLlXHPlNS2dL+9B4M8AFwOzcy6HiEgmKgO989esZeCBbUwcuZCHVl+YyQDwp9d9uuVzVMstAJjZGcB2d7/NzFbUed4qYBXA4LzBDpVORKR5O9+8snAzfqLk2QN4BXCmmb0OmAkcYmZXuvs7qp/k7uuAdQCznzPbO19Mkc4Y2zXG6GOjjE+OM9g/yPChwwzNGsq7WNLDchsDcPdL3P0odz8GOBv4YW3lL1IWY7vG2PTIJsYnxwEYnxxn0yObGNs1lnPJpJcVYRaQSOmNPjbKlE9NOzblU4w+NppTiaQM8h4EBsDdR4CRnIshkptKyz/pcZEsqAcgUgCD/dETHOKOi2RBAUCkAIYPHabPpl+OfdbH8KHDOZVIimbbA9v4wzf+Ia9/xes5Y9kZfOn/fqnlcxYiBSRSdpXZPpoFJHH6+/v58Cc+zPNf/Hx27drFWaedxSkrTuHYJcc2fU4FAJGCGJo1pAq/R1y7+VrWrl/Ltl3bWDhrIReefCErF7e2LuDwBYdz+ILDAZg1axbPXfxcxraNKQCIiBTFtZuv5aM3fJQ9E8GOoFt3beWjNwTbQbcaBCru33I/G+/YyItf+uKWzqMxABGRDK1dv3Zf5V+xZ2IPa9dnsx30k7ue5IJ3XcAlf34Js2bPaulcCgAiIhnatit62+e442ns3buXC951ASvfvJLTzzi95fMpAIiIZGjhrOhtn+OOJ+XufOQDH+G5i5/Lu977rpbOVaEAICKSoQtPvpCZA9O3g545MJMLT25tO+jbf3I73/rqt7jl5lt444o38sYVb+TG629s6ZwaBBYRyVBloDfrWUAvPeml3PXQXVkUcR8FABGRjK1cvDKzGT/tpBSQiEhJqQcgPUf76oskowAgPaWyr35la+XKvvqAgoBIDaWApKdoX32R5BQApKdoX32R5JQCkp4y2D8YWdlrX33pduN7xnnHme/g6aefZnJiktNXns4FH76gpXMqAEhPGT50eNoYAGhffekNzxh8Bld8/QoOnnUwe/fu5ZwzzuHU007lhKUnNH1OBQDpKe3aV18ziySNa6+Zzdo189n2wAALj5zgwtUPsfLNO1s6p5lx8KyDAZjYO8HE3gnMrKVzKgBIz8l6X33NLJI0rr1mNh+9aAF7dgdDrFvvn8FHL1oA0HIQmJyc5KzTzmLLPVt4+x+9XdtBi7SbZhZJGmvXzN9X+Vfs2d3H2jXzWz53f38/3xz5JiO/HOGXt/+SzRs3t3Q+BQCRBjSzSNLY9kB0YiXueDMOmXMIL1/2cm764U0tnUcpICmV6lz+QN8A7s6kT9bN62tmkaSx8MgJtt4/I/J4Kx59+FEGZgxwyJxD2LN7Dz8e+THnX3B+S+dUD0BKo5LLr1TmE1MTTPoksD+vP7Zr7IDXDR86TJ9Nv1Q0s0jiXLj6IWYeND1lOPOgKS5c/VBL531o7CHe+cZ3cubyM3nL6W/hlBWn8KrTX9XSOdUDkNKIyuVXq+T1a3sB7ZpZJL2pMtCb9SygJc9fwjdu+EYWRdxHAUBKI0nOPu45Wc8skt628s07W67wO0EBQHpO3Jz9uFx+NeX1pUw0BiA9pTbPX53bj8rlV1NeX+JMMYW7512MhtydKeLTnLXUA5CeUm/O/slHnwzA3Y/ezcTUgTMyuuECb0Qrlttj2+5tzNs5j8HZgy2vvm0Xd2d85zjbdm9L/BoFAOkpjebsD80aYvSxUSaICAB4pit8O10Za8Vy+1y95WrO5mwWHrSQvoImTqaYYtvubVy95erEr1EAkJ6SZM5+vXGAuJlAabWrMq4XVOr1fhQAWrNrcheX33N53sXIXDFDmUiTkszZbzTQm8UK33ZsH1FvfKPy9yhasSxxFACkpwzNGmLJvCX7KvnB/kGWzFsyrQXcaDAYiFwQlkY7KuNGQSUusGlmk8RRCkh6TqM5+5XHNj68MfY5zaRNqtMzcVqpjBsFFd0LQdJSD0BKaWjWEP3WH/t42pZ6bXomSiuVcaMeyci9I4w+NsqCgxfU7f2IVFMPQErLzCBm5mfalnqjbSZanQWUZOxgfHKcB598UJW+JKYAIKUVtRagol5LPWomTr2W/4pjVjR8faMKO2mPRLN+JA2lgKS04lr5A30DsRVo3EycuHRS7Xs0msmTtqxRNOtHksqtB2BmRwNfAoYIOuLr3P2zeZVHyqG69d1v/RiGV+WB+qyP4551XOzr42biDPQN0EdfwwHYZufqzztoHlt3bU30GTXrR5LKMwU0AXzQ3W83s9nAbWZ2vbv/Ku4Fu+5d3LnSSVvkuVVB7eKsyr0Aqi04eEHd8sS1riemJjj+sOMbfrZmp4c+svuRuo9XpBlo1rYRklsAcPdtwLbwzzvNbCNwJBAbAABG3v09AOwZT7L8sje1u5iSoby3Kmg0UAuwdddW5syc01R5kmwZ3ezdxRpNLU1bief9byHFUIhBYDM7BngJ8JOIx1YBqwAGBxdx8snBrdZGfnTwvmAwcMwtLPvYxzpUWmlWq1sVtNpiTZobb+cgarNz9esFjsomd2lo2wiBAgwCm9ks4GvAB9z9idrH3X2duy9196UzZszfd3zFqTNYceoM5h4yg4l7T2Lk3d/bFxCkmFpZHdvs4Gm1pLnxZhZyJT13kpXKUbK+LaW2jRDIuQdgZjMIKv+r3P3rzZzjhBMAgl7Bhg1MCwIr/un01gspqaW9IUuSyjOLFmtU6ztKvfJksdq2mbuLZX1bSt3oXiDfWUAGfB7Y6O6fzuKc1cFg5Ed7lSLKQb3cciuVZxYt1tpKNE698uR5f+Asb0upbSME8u0BvAI4F7jDzDaExy519+uyOPmKU2fs+/PIj07S4HGHJLkhSzOVZ1Yt1upKdGzX2LSbw/RbP4vnLW5Ynl64P7BudC+Q7yygm4GO3FpnejDYP3g89y8O54QFJ3SiCKWR5IYszVQy7Wix9kJF3oqyf34pyCygTqoEg5tvhh2XbmekclzjBU2pzfcP9A1EbrHQam5ZLVaR7JUuAFQsWwZR4wVKESUXle8HIlfXxrXU00ztVItVJFulDQDV4lJEGjyuL25hVZ/1MdA30LBS12IkkXwpANSIGzxWMDhQXL5/0id55dGvbPh6LUbqHdpWojspANRRPV5QWWwGGi+oSDMzJ80WylqMFK+IFa16ct1LASCBuPECKHcwSDozJ66CaNeAca8qakWrnlz3UgBIaXqKqNyLzZLOzImrIAyjzxpvoVxWta39iamJujeFb7Vn0GzvQj25gvv5htiHFABa0AvjBa2mFJLMzKk3VpBkC+UyipthFaXSE2ilZ9BK70LbShTITTfD5PRtzm+4sj92wZUCQEYqwWDDBtjRJeMFnUgp1NusbbB/sOundrYrJ59k6+pqraZgWknjaFuJnIzcGHn4hm/OqeyLE1gGjIxEPlcBIGNx+xFB8YJBJ3K39W5m3i0VRFwl384AmjR9UrvmIs05qj9XknLEfQ9apNchERX+DfcuP/B5KTY3UABoo6KPF3Qid1vvXN1QQdSr5NsZQOPSKgN9A/Rb/7Rxgag7m1XOEaf2c9UrR9Tza4Ndt/fkCiUijQMxlX2LFAA6pIjjBZ3I3eaZH84iPVOvkm9nAI1Lqxz3rOOmfYaRe0fqniNOkhRTdRpHM33a5Ocb4PHHDzh8QBqnTRQAchAXDDqdIupE7jZuD/5Jn2Rs11jbKo+s0jP1Kvl2BrekaZW4MvRbf1P3Nq4+b/X7aaZPRtqQxmmFAkDOKsHgxh9NdHy8oBO528q5Nj+yeVqqYmJqoq1z2LNqsdar5NsdQJOkVeLKsHje4rqvS3uLSc30SSmuZX9lf2VhUSEoABTE8lP3/1N0cnO6TuRuh2YNMfrYKJM1ec12phCyarHWq+SLMPjZbBnSBi/N9KkjLmcflcYpTt0PKAAUUi9uTtfpFEKWN5CB+Ao2TQBt15TRTtxisgjBrjAKlsZphQJAwRVlvKBVnU4hZNlizaKXVMRtHNJ+rtLN9IlJ40B7ZuTkQQGgi+Q5XtCqTqcQitZi1SyaLhDVsi9Yzj5rCgBdKG68AIobDPKokIvUYu2mWTRF3HE0c0nTOL1b9wMKAF0vbrFZEe93nLZC7qWKKK9ZNGm/wyKmqlpSgjROKxQAekgv3e+41yqiPGbRNPMddn2qKmYztF5O47RCAaAH9cL9C7q+IqqRRQosbWs+yXd42o/HOP9roxz+yDjb5w2y8H3jRG0dWcRUVexmaLUte9X9sRQAelx1iqibBo/bmTPPK7XUyphEM635Rt/haT8e40NXbGLm08E5FzwyztFPwG/nHPia3Bd8Ja3sJRUFgBKJGzwuYiBoV868W1NLzfSIGn2H539tdF/lX/HJ78Mfnwm797cbOr/gS2mcjlEAKKnq+xcUsVfQrpx5t6aWmukRNfoOD3/kwNeecwc4cP5bBzvTQ1IaJ1cKACU2Nga7dwNTMxgchPHxycIEg3ZNG+2m6ZjVmukRNfoOt88bZEFEEHj11uj9gFoWtz+O0ji5UQAomLExGB2F8XEYHIThYRhqQ+NrbAw2bYKpsHE4Pg59ff0sWdLP0ND08YJ270cUpx3z+Lt1U7Nme0T1vsPLzxqeNgYA8PSAMXPPBD84b4Tt8wa5/KxhfnBKE/8GsWkcVfZFogBQIFGV8qYgPZ15EBgd3f8+FVNTwfGhodrxgoMLPV6QRrduataOHlGlYq/MAnpi1gDP3D3B3CeDinvBI+N86IpN054bKc2tCaVQzD36dnJFNHv2Ul+69Na8i9E269cHlX6twUE4OeMeecwtQgFYsSL6+IYNsOOJvfv+XsTFZkn00gKzLP3zB9dHpoQenDfI2/53+APs4N2qJDs2MnKbuy+tPa4eQIFEVf71jrciyPlHH49Tfb/jIi02S1uhF2mLiCKJGhTed7yqla/KvncoABRIM5Vys4aHp6ebAPr6guNJFGWxWbdO6yyckRvZfjAsePLAh/oGB7nh3jYMCkvuFAAKpNVKOY3KmEIWA8557kfUrdM6cxeRt1+w6PgDf4AQ/EDWr2/fjATJTcMAYGaHAPPd/Tc1x1/k7r9sW8lKKMtKOen7ZX3uTu9H1K3TOjsmzd2qKr+Fyg+wWjMzEjo1pU2aVjcAmNlbgc8A281sBnCeu/8sfPgK4HfaW7zyaUelnIfqFFE7F5t167TOtoibZx9V2cd1zCo/wKgZCdXTxBrp5JQ2aVqjHsClwEvdfZuZnQh82cwucfdvELlllBTR2OFXMTq8mvHBLQyOL2J4dA1D28/p2PtXDx5nPV7QrdM6M9HOWxO2OiOh0TxjKYRGAaDf3bcBuPtPzexVwHfM7GiCFeOl02292rHDr2LTklVM9T8FwPjM+9i0ZBVAR4NARdx4QbP3Oy7anb/aIq5l3879cVqdkdDJKW3StLrrAMzsx8C51fl/M5sNfBNY5u4d7WfnvQ6gtlcLwSDtkiXFDQLrTzqG8Zn3HXB8cM+zOfmWeztfoAgbNsCOHRNAPwCD88YYPutyhk75Qb4Fy0OanH09rbZUWv2xd3JRizTU7DqA91KT6nH3nWb2GuCtLRcqOM9nCa78y939L1s9Zzt1Y692fHBLquN5WLgQnnhiYH+6+JEFbFy3mo3r/pQVV/xevoVrt3akcbLIv7c6I6GTU9qkaY0CwJMEcwN+XXP8ROCWVt7YzPqBfwB+D7gf+JmZfdvdf9XKedupCL3atA27wfFF0T2A8UVtLGU6UYE1aHf0t5wiKoxOpnGyaqm0MiMhTQDptrxqD2kUAD4DXBJx/InwsZUtvPeJwK/dfRTAzK4G3gAUNgB0cqFWlLiG3eOPwyOPRF8/w6Nrpo0BAPRNPpPh0TWdKXQC8QHU9o0ZjPzopO4KBlEt+6jKvh0p/CK0VCBZANFsoVw1CgBD7n5H7UF3v8PMjmnxvY8Eflv19/uBl9c+ycxWAasABgfzbbXm3auNa9ht3br/77XXT2Wgt3oW0LwbrmR0wzI2FqTBlSSwTh88Pqmji80aiqrso3L2ndoMrZmWSl6t8G7Mq/aQRgFgbp3HDsqyIHHcfR2wDoJB4E68Z5xOL9SqlbQBV3v9DG0/Z18giGpwbdwImzfD4sXTP0un6oS0gbXTi832iUnjQETePs+YlPYLzbEVftXicVafBlvmwKLHYc0PgpvSaLZQZzQKALea2R+7++eqD5rZ+cBtLb73A8DRVX8/KjxWaJ1aqDU2BnffDRMTwd/7+2FgYP/fG4m7fqLz7cHEk+prvpN1QrOBtXqx2c03k/39C7r11oRpv9CcWuH/7djNXLYcPJxmct9cWBUmlc/ZXMKFfDloFAA+AHzDzM5hf4W/FHgG0OoV9jPgODN7DkHFfzbw9hbP2RPGxuCuu6B6hm7EzMC64nr79RpW1dd8p+uEVgPr9M3pDk4/XlCEWxNm2eVK84UmHTPIsHxXHT7GZUdu3Vf5Vzz1DFh9GpwzodlCnVA3ALj7GHBKuADsBeHhf3X3H7b6xu4+YWbvA/6dYBroP7n7na2etxeMjk6v/OP098Ps2bBjx4GPzZsX/Zq49HBF5bGijCM2I268YOCYW1i28szkaZxOaqXL1WrFnGTMIOMu4erh0QMq/4otc5o7p6TXaC+gmcB7gGOBO4DPu3vCJERj7n4dcF1W5+sVSSvZycnoyh+CWUFRotLD1SrXfN4znrJSPV4wce9J8PjjxUzjNNvlyqJiTjJm0Ez56gSmLYPxP/JF4132I+tijVJAXwT2AjcBrwWOJ0gLSRs1aqUnUdnBt/baq1yrmzcfmFaqvubznvGUtWXLYORHVX/JS1yl2GyXK4tcXZIxg7TlaxCYFo0Pct/MA19rDmtGu/RH1oUaBYDnufsLAczs88BP218kGR4+cAygGdXpnNpGYdS5FyyomjmU84yndlhx6gxGvjgOy3O6e1m9SrHZLldWubpGYwZpy9cgMK0ZHWbVkk081b//OebwngeO4JztXfwj6zKNAsC+G8CGOfs2F6e4OjlNunLe6llArWo0wAsHpo16ZWvqwqhXKTbb5epUri5t+RoEpkolv3p4lC2D4ywaH2TN6HC2lb9WGDfUKAC82MyeCP9swEHh3w1wdz+kraUriDymSddWvtW/5XrqpY96YYC3q9X74pvtcnUqV5e2fAkC0znbh9rX2tcK40QazQLq71RBiqwIixWrA0KjjRrjNmKsvLZXBnibtmFDup01s9Loi2+my9XJXF2a8uU9iFSEi7YL6J7ACRStxdzomh8eDlb3Rmkl29Azdu3K533b9cUXMVeX9yBS0S7aglIASKCILeZ61/zQUHwAaCXb0Cts8imcHAaCy/bF5xmYinjRFpACQAJJGm5FG29qR7ahF6xYPoORG/c2fmK75PHFR+0rUrvxU9RrivSDTqv03dxkFAASaNRwqzfeVO917aTfv31av0UAAA3SSURBVADx+4pUuohx+/N3+wBq2XpbTVIASKhewy1uvGnz5uC6y+M60u9fgPr7isQNiLayKrlIP7iydnNTUADIQNy4UtQGbp2ciKDffx0331y87SDaIcnGT60eHxs7cGl5N/YaSkgBIANpt27QRARJrdnWdb0fZ9yAaJoB1Kg5yRVZtHaK1qvoMX15F6AXDA8H+fVqfX3B/v1RNBEhZxbMBOoalUq2dm+PsbHGrx0ehrgV/HEDQnE/6Kjnxy0rr2iltdPK55ZE1APIQFy+HTQQW0QrTs15JlBarSxqitpXpNEsoDQDSEmWptdTr4Wf5nOrp9AUBYCMNBokLvLvMmqbiaKWtZRaXdTU7ArjVlNMjVo7jabPpblRTbfPWsqJAkCbFX0gNi6Fq2uoQIq8qCnuBhMDA3DccfV/PI2mz8Wp/dza9qFpGgMouXop3Mo11LNuvjnvEiSTJiffaUNDwSZU1XcSOv74YIZVo8q33vS5uB9l1OfWtg9NUw+gDWrTkfPmBVstFzEN1Oga6eVrKLctIdIq8qKOVnLvzdz5qLLjYZLzFKGHVHAKABmLSkdu3br/8VZSK+0Y52p0DfbqNZT7lhBpFTGX2GruPW65el9f9I0wBgejz6tl701TCihjjWbFQXOplXbNiIvKLlToGpK66uXeG6m0ZqpfPzgYtPCPOy5dyisqDRXVU5ADqAeQsaQ92rQ933aNc9VmFyqKlGWQgmo29x53Q4vaH1ya7m4Re0hdQAEgY0nTmmlTK+0c5yr1tZPXzWF6QbO59yStmVL/KDtHKaCM1UupVDSTWqm3al8kF3E/9snJ+Nzk2Fi2rZmxseAWeCMjwf+1SjgV9QAyFjVhI4tZQEUb5+qFhZcD/TOwx7d3x0ygIqr8g9duBDcxET0YXNmaOk7a1owWgLVMAaAN2tF7LdJMwF657pYtg5Eb8y5FF6qN/lF7DUUNUN19d/wCr+rWTNLWhRaAtUwBoIvU3hh+dDS4r0eng4GuuxKLiv5xah+LmtpZUZm1k6Z10cogdBFaUgWgMYAulPcmiVp4WWJJ5jlXpEnpJNkALun5671vJQ1VffHcdVdpxw4UALpQK9Ovs9BzA9IbNuRdgu6RNMpHDVD190c/t/p4mtZFM1tkRKWh3IPjJaQUUBeqd410ondbtAHpVmkgOIW4qZ/9/cEGcPV+eIsX778Xce3xyg+33vvWSnKz7trH4tJQ9dJTPUwBoAvFXYMDA50ZnC3SgHSrum5LiLzFRf969xeoSHPjjGqNVgGnvbG97KMAkKFOjS3FXYPVN6CvaNfgrNbplFSr0T/qh7N+fXzl3+yFFJcnjROXnupxCgAZ6eTUyLhrMKp3XSmLSGpxLZpG0T9tS6jeD/Tkk5sre9of/eLFzb1Pl1MAyEinp0ZGXYO1+/lUdO3gbCdpS4jpmm3RNPO6dmznXO+cw8O9kb/MgAJARoowNbLXBmclR822aJp5XTt+uPXOqfzlPgoAGWn3PSmS9Kp7aXC20zQTqEazLZpmXteOH269Aef163WBhBQAMtLO1ndUr3rjRnj88QNTl2rcpKeZQBGabdE0+7p27Z9SuxdRL+xhkiEFgIy0s/Udt/hy61aYM6e0v11pp7Qtmuouaq2o12V531TtHdS0XAKAmX0KWAk8DfwGeJe778ijLFlqV+u7Xu+5xL9daac0LZqoG7xURL0uy/umdmLvoB6WVw/geuASd58ws78CLgE+nFNZCq/eTWZK/NuVdkvaoonrog4ORk/jTHPf1Ebvn6ZVr5vHHyCXvYDc/XvuXll7fQtwVB7l6LRm711RbxyhxL/dzNmN38u7CN0pbesky/umtnvvoB5XhDGAdwNfiXvQzFYBqwAGBxd1qkyZa2X8aWgoGPCt7iVXjI8HwaRe71z3+21MA8EtSNuyzvK+qWneW9PkDtC2AGBm3wcWRDy02t2/FT5nNTABXBV3HndfB6wDmD17aczdJIqv1fGnxYuDAd+ocba4YBKXmq3MIsrjXgLSg9IOGEc9v1bSlnna99Y0uWnaFgDc/dX1Hjez84AzgNPc424T1DuyyOFXfruVaczVooJJklSrZsJJy9K2rLO8b6pa9S3JaxbQa4CLgeXu/lQeZei0LMefkgaTpMGl5DPhJAtpW9ZZtsTVqm9aXjeE+XtgNnC9mW0ws8tyKkfHZDn+lPSGLGmCi2YTiZRPXrOAjnX3o939hPC/9+RRjk4aGgpue1qplAcH998GNa2kwSTqeXE0mwjMTDOBpFSKMAuoNLLqqSZNe9Y+L07JZ8Lts/zUAc0ESkM3V+96CgBdKmkwqTwnzUJNkYa0r05PUAAogbvvTrdQsxlqDJaM9tVprAsuCgWAHjc2Fn+/66wGftUYLCHtTVJfl1wUec0Ckg4ZHY1/LKuB33qNwW6kgeAEkk5FK6suuSgUALpco/2F6jXIshr47aXG4IrlM/IuQnfQvjr1dclFoRRQTrJIDybpZcYtQOvvz64nqk0WS0grcOvrkotCASAHWaUHk4zDxW2VUnsnsVboXsQlpRW48brkolAAyEFWEyiS9DI70VBTY1CkRpdcFAoAOcgqPZi0l9mJhpoagyI1uuCi0CBwDrKaQKFxuPbRTCApAwWAHGRVcWe5v5Dsp5lAUhZKAeUgy/RgF/QyRaSgFAByoopbRPKmACAiAl2xd0/WNAYgEkMDwSVSWZxTmVZXWZxTu7S+xygAiETQQHDJdMnePVlTABAR6ZK9e7KmACAiUtLdTRUARERKuqpSs4BERLpk756sKQCIxLFgJpAvPz3vkkgnlHBxjlJAIjFWnKqZQNLbFABEREpKAUBEpKQUAERESkoBQKSBvvVfz7sIIm2hACBSx4rlM/CnZ+VdDJG2UAAQESkprQOQQijhTrwiuVMAkNxVduKtbMZY2YkXFARE2kkpIMldSXfiFcmdAoDkrht24tVMIOlFCgCSu6LvxKubw0ivUgCQ3HXDTryaCiq9SIPAkruS7sQrkjsFACmEEu7EK5I7pYBEEpox+rG8iyCSqVwDgJl90MzczA7LsxwijcydM4PJsRPyLoZIpnILAGZ2NHA6sCWvMoikoYFg6TV59gDWAhcDnmMZRBI5QY1/6UG5BAAzewPwgLv/IsFzV5nZrWZ26969D3WgdCIi5dC2WUBm9n1gQcRDq4FLCdI/Dbn7OmAdwOzZS9VbEBHJSNsCgLu/Ouq4mb0QeA7wCzMDOAq43cxOdPcH21UekSz0rf86Uyf/Qd7FEMlEx9cBuPsdwOGVv5vZvcBSd3+402URSWPunBnseFwDwdI7tA5AJCENBEuvyX0lsLsfk3cZRETKSD0AEZGSUgAQSUlbQkivUAAQSWHuHN0bQHqHAoBIShO/XZZ3EUQyoQAgkoJmAkkvUQAQESkpBQARkZJSABBpgmYCSS8w9+7ZX83MHgLu6/DbHgZomwp9DxX6HgL6HgLd8j08293n1x7sqgCQBzO71d2X5l2OvOl7COh7COh7CHT796AUkIhISSkAiIiUlAJAY+vyLkBB6HsI6HsI6HsIdPX3oDEAEZGSUg9ARKSkFABEREpKASAFM/ugmbmZHZZ3WfJgZp8ys7vM7Jdm9g0zm5t3mTrFzF5jZpvM7Ndm9qd5lycPZna0md1gZr8yszvN7P15lylPZtZvZj83s+/kXZZmKQAkZGZHA6cDW/IuS46uB17g7i8CNgOX5FyejjCzfuAfgNcCzwPeZmbPy7dUuZgAPujuzwNOAv57Sb+HivcDG/MuRCsUAJJbC1wMlHbU3N2/5+4T4V9vAY7KszwddCLwa3cfdfengauBN+Rcpo5z923ufnv4550Eld+R+ZYqH2Z2FPB64PK8y9IKBYAEzOwNwAPu/ou8y1Ig7wa+m3chOuRI4LdVf7+fklZ8FWZ2DPAS4Cf5liQ3nyFoEE7lXZBW5H5T+KIws+8DCyIeWg1cSpD+6Xn1vgd3/1b4nNUE6YCrOlk2KQYzmwV8DfiAuz+Rd3k6zczOALa7+21mtiLv8rRCASDk7q+OOm5mLwSeA/zCzCBIe9xuZie6+4MdLGJHxH0PFWZ2HnAGcJqXZxHJA8DRVX8/KjxWOmY2g6Dyv8rdv553eXLyCuBMM3sdMBM4xMyudPd35Fyu1LQQLCUzuxdY6u7dsANgpszsNcCngeXu/lDe5ekUMxsgGPQ+jaDi/xnwdne/M9eCdZgFLaAvAo+6+wfyLk8RhD2AD7n7GXmXpRkaA5A0/h6YDVxvZhvM7LK8C9QJ4cD3+4B/Jxj4/GrZKv/QK4Bzgd8N//03hK1g6VLqAYiIlJR6ACIiJaUAICJSUgoAIiIlpQAgIlJSCgAiIiWlACCSgJlNhtMe/9PM/sXMnhkeX2BmV5vZb8zsNjO7zswWh4/9m5nt6ObdIqW3KQCIJLPb3U9w9xcATwPvCRdGfQMYcffnuvtLCXZIHQpf8ymCefMihaQAIJLeTcCxwKuAve6+b0Gcu//C3W8K//wDYGc+RRRpTAFAJIVwW4jXAncALwBuy7dEIs1TABBJ5iAz2wDcSnBToM/nXB6Rlmk3UJFkdrv7CdUHzOxO4M05lUekZeoBiDTvh8Cgma2qHDCzF5nZK3Msk0hiCgAiTQrvh/Am4NXhNNA7gU8CDwKY2U3AvwCnmdn9Zvb7+ZVW5EDaDVREpKTUAxARKSkFABGRklIAEBEpKQUAEZGSUgAQESkpBQARkZJSABARKan/D+NfXtXm6G+YAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Dbzx_KqBguX", + "colab_type": "text" + }, + "source": [ + "## Visualising the Test set results" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "kk07XbUHBl0W", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 367 + }, + "outputId": "6697e6fb-051a-4842-f9b9-76e596da78e7" + }, + "source": [ + "from matplotlib.colors import ListedColormap\n", + "X_set, y_set = X_test, y_test\n", + "X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n", + " np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\n", + "plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n", + " alpha = 0.75, cmap = ListedColormap(('red', 'green', 'blue')))\n", + "plt.xlim(X1.min(), X1.max())\n", + "plt.ylim(X2.min(), X2.max())\n", + "for i, j in enumerate(np.unique(y_set)):\n", + " plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n", + " c = ListedColormap(('red', 'green', 'blue'))(i), label = j)\n", + "plt.title('Logistic Regression (Test set)')\n", + "plt.xlabel('PC1')\n", + "plt.ylabel('PC2')\n", + "plt.legend()\n", + "plt.show()" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "text": [ + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file