├── .gitignore ├── Anomalies ├── .gitignore ├── Anomalies_CNN2D.ipynb ├── Credit_Card_Fraud.ipynb └── Credit_Card_Fraud_TF1.ipynb ├── Clustering ├── Iris K-means.ipynb └── images │ └── iris_versicolor.png ├── LICENSE ├── MNIST ├── .gitignore ├── MNIST_CNN_Training.ipynb ├── MNIST_CNN_Training_TF1.ipynb ├── MNIST_Prediction.ipynb ├── MNIST_Training.ipynb ├── Training_Size.ipynb ├── model.json ├── model_cnn.json ├── weights.h5 └── weights_cnn.h5 ├── Math ├── Mandelbrot_PyTorch.ipynb └── Signals.ipynb ├── Notebooks ├── .gitignore ├── Great Pyramid.ipynb ├── Jupyter Notebook.ipynb ├── Keras.ipynb ├── Keras_TF1.ipynb ├── Matplotlib.ipynb ├── NumPy.ipynb ├── Pandas.ipynb ├── PyTorch.ipynb ├── Python_Quick_Start.ipynb └── data │ ├── Khufu.png │ └── imports-85.data ├── README.md ├── Recommendations ├── Item_Similarity.ipynb ├── Movie_Recommendations.ipynb └── Movie_Recommendations_TF1.ipynb ├── Regression ├── Battery_Capacity.ipynb ├── DeepHousingModel.ipynb ├── HousingPrices.ipynb ├── Iris_Classification.ipynb ├── LinearRegression.ipynb ├── LogisticRegression.ipynb ├── data │ └── kc_house_data.csv └── images │ ├── iris_versicolor.png │ └── perceptron75.png ├── Sequence ├── Airline_Passengers.ipynb ├── LSTM.ipynb ├── Time_Series.ipynb └── data │ └── airline-passengers.csv ├── Text ├── .gitignore ├── Alphabet.ipynb ├── Email_Spam_Classifier.ipynb ├── Embeddings.ipynb ├── GloVe_Sentiment.ipynb ├── Sentiment.ipynb └── Sentiment_BERT.ipynb └── images ├── practical_example_icon.png └── practical_intro_icon.png /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Byte-compiled / optimized / DLL files 3 | __pycache__/ 4 | *.py[cod] 5 | *$py.class 6 | 7 | # Jupyter Notebook 8 | .ipynb_checkpoints 9 | -------------------------------------------------------------------------------- /Anomalies/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Byte-compiled / optimized / DLL files 3 | __pycache__/ 4 | *.py[cod] 5 | *$py.class 6 | 7 | # Jupyter Notebook 8 | .ipynb_checkpoints 9 | 10 | # data is quite large, so don't commit 11 | data 12 | data.zip 13 | 14 | # Don't commit models 15 | *.h5 16 | 17 | logs 18 | -------------------------------------------------------------------------------- /Clustering/images/iris_versicolor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/Clustering/images/iris_versicolor.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Madhu Siddalingaiah 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /MNIST/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Byte-compiled / optimized / DLL files 3 | __pycache__/ 4 | *.py[cod] 5 | *$py.class 6 | 7 | # Jupyter Notebook 8 | .ipynb_checkpoints 9 | -------------------------------------------------------------------------------- /MNIST/MNIST_Prediction.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "Using TensorFlow backend.\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "import keras\n", 18 | "from keras.datasets import mnist\n", 19 | "from keras.models import model_from_json\n", 20 | "from keras.layers import Dense, Dropout, Flatten\n", 21 | "from keras.optimizers import Adam\n", 22 | "from matplotlib import pyplot as plt\n", 23 | "import numpy as np\n", 24 | "import random" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "### Restore Trained Model" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 2, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "name": "stdout", 41 | "output_type": "stream", 42 | "text": [ 43 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", 44 | "Instructions for updating:\n", 45 | "Colocations handled automatically by placer.\n", 46 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", 47 | "Instructions for updating:\n", 48 | "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "with open('model.json', 'r') as json_file:\n", 54 | " loaded_model_json = json_file.read()\n", 55 | "model = model_from_json(loaded_model_json)\n", 56 | "model.load_weights(\"weights.h5\")" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "### Load data\n", 64 | "\n", 65 | "Keras has a builting function for loading MNIST data while splitting it into train and test sets. x_train and x_test are arrays if train and test input images respectively. Images are represented as a 28 x 28 matrix of pixel values. y_train and y_test are train and test labels respectively." 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 3, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", 75 | "\n", 76 | "# Save original test images for display later\n", 77 | "orig_test = x_test\n", 78 | "\n", 79 | "x_train, x_test = x_train / 255.0, x_test / 255.0" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "### Make Predictions\n", 87 | "\n", 88 | "Use the trained model to make predictions on data that it was not trained on.\n", 89 | "Notice that prediction takes much less time compared with training.\n", 90 | "\n", 91 | "Keras can make predictions for a set of test data, rather than just one sample. In this case, the model is used to make predictions for all of the test data in one statement. Keras/Tensorflow will parallelize this operation as much as possible when using a GPU.\n", 92 | "\n", 93 | "The predicted output is a one-hot vector. argmax() is used to translate the output vector to a scalar value by choosing the index of the vector with the highest value." 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 4, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "predictions = model.predict(x_test)\n", 103 | "most_likely = predictions.argmax(1)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "The following snippet chooses a random test image, prints the model predicted value, expected value (label), and the original image." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 8, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "image/png": "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\n", 121 | "text/plain": [ 122 | "
" 123 | ] 124 | }, 125 | "metadata": { 126 | "needs_background": "light" 127 | }, 128 | "output_type": "display_data" 129 | } 130 | ], 131 | "source": [ 132 | "index = random.randrange(10000)\n", 133 | "plt.title('Prediction: %d, label: %d' % (most_likely[index], y_test[index]))\n", 134 | "plt.imshow(orig_test[index], cmap='gray')\n", 135 | "plt.show()" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "### Error Analysis\n", 143 | "\n", 144 | "The next snippet looks for model predictions that specifically do not match the expected value. In some cases, even humans might disagree on what this image is." 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 12, 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "image/png": "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\n", 155 | "text/plain": [ 156 | "
" 157 | ] 158 | }, 159 | "metadata": { 160 | "needs_background": "light" 161 | }, 162 | "output_type": "display_data" 163 | }, 164 | { 165 | "data": { 166 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAFe9JREFUeJzt3XuUXWd53/HvDxkF8AUTNLSgiyVA0AiHYjMIWlqHBpMlQyqT1EmkLi5OwKKriEvITaQsh7gNJJSEtCtKg7gklGALYS5RiIggBdJwrQQ2YElREMJYgwwebHMJBIzg6R9ni3UYjzR7pJkz9uvvZ61ZOnvvd/bzbI30O3vec/Y+qSokSW2510I3IEmae4a7JDXIcJekBhnuktQgw12SGmS4S1KDDHfdLSRZmaSSnNEtvyfJs09hPyuS/GOSRXPf5alJcnmSDy10H2qL4a45k+TGJP/UheeXk/xpkrPmo1ZVXVJVb+rZ08VD33dTVZ1VVd+bj76kuwrDXXPt31fVWcCFwOOAl00dkAH/7UnzyP9gmhdV9UXgPcD5AEk+mOR3knwY+Bbw0CT3T/KGJDcn+WKS/3Z8uiTJoiSvTvKVJIeBpw3vv9vfc4eWr0hyIMk3kuxPcmGSNwMrgL/sfpv49Wmmdx6SZGeS25IcSnLF0D5fnmRHkv/d7XdfkvHpjjfJnyR59ZR1f5HkJd3jLUk+N9Tfz5xgPz/U3wmO9Ze6Y709ye4k53Xrk+Q1SW5J8rUkn05y/ow/LDXJcNe8SLIceCpw3dDqZwKbgLOBLwBvAo4BDwcuAH4KOB5iVwA/3a0fBy47Sa2fA14OPAs4B1gP3FpVzwRuovttoqpeNc23XwNMAA/parwiyZOHtq8HtgPnAjuBPzpBG1cDv5AkXU8P6I5ne7f9c8C/Be4P/Dbw50kefKJjOsmxPh34TeBngTHg77pjoKt3EfCIrt9fAG6dbQ21wXDXXHtXkq8CHwL+FnjF0LY/q6p9VXUM+FHgEuDFVfXNqroFeA2woRv788AfVtWRqroNeOVJaj4XeFVV7amBQ1X1hZka7Z6A/g3wG1X17aq6Hng9gyeh4z5UVbu6Ofo3A//yBLv7O6AYBDgMnig+WlVHAarqbVV1tKq+X1VvBT4LrJ2px2k8D3hlVR3o/h5fATymO3v/LoMnzn8BpBtz8ynUUAMMd821p1fVuVV1XlX956r6p6FtR4YenwfcG7g5yVe7J4TXAg/qtj9kyviThfVyBmfGs/UQ4Laq+saUOkuHlr809PhbwH2Gp0yOq8Ed+LYDG7tV/xF4y/HtSZ6V5PqhYz0fWHIKPZ8H/I+h/dwGBFhaVe9n8JvFVuDLSbYlOecUaqgBhrtGafgWpEeA7wBLuieDc6vqnKp6VLf9ZgahfdyKk+z3CPCwHjWnOgr8aJKzp9T54km+52SuAS7rzqIfD7wdoFt+HbAZeGBVnQvcwCCUp/pm9+f9htb986HHR4DnDf2dnVtV962qjwBU1f+sqscCj2IwPfNrp3gsupsz3LUguumC9wK/n+ScJPdK8rAkP9EN2QG8MMmybv56y0l293rgV5M8tntR8eHHX2QEvgw89AQ9HAE+ArwyyX2SPBp4DkNn3LM8puuAya6f3VX11W7TmQyeZCYBkvwi3QvN0+xjksGTyzO6F5V/iR9+4voT4KVJHtXt6/7daw4keVySxye5N4MniW8DvuXzHspw10J6FrAY2A/cDlwLHH+R8XXAbuBTwCeBd5xoJ1X1NuB3GLyo+Q3gXQzm9GEwV/+ybhrjV6f59o3ASgZn8e8Efquq3ncax3QNcHHXy/H+9gO/D3yUwZPNjwMfPsk+rmBwxn0rgzPwjwzt653A7wHbk3ydwW8Al3Sbz2Hw93Y7g+mlW4EfegeP7jnih3VIUns8c5ekBhnuktQgw12SGmS4S1KD7nQxxqgsWbKkVq5cuVDlJelu6ROf+MRXqmpspnELFu4rV65k7969C1Veku6Wksx4aw1wWkaSmmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhq0YFeoSrprW7nlr+a9xo2/+7R5r3FP5Zm7JDXIcJekBhnuktQgw12SGmS4S1KDeoV7knVJDiY5lGTLNNtXJPlAkuuSfDrJU+e+VUlSXzOGe5JFwFbgEmANsDHJminDXgbsqKoLgA3AH891o5Kk/vqcua8FDlXV4aq6A9gOXDplTAHndI/vDxyduxYlSbPV5yKmpcCRoeUJ4PFTxrwceG+SFwBnAhfPSXeSpFPS58w906yrKcsbgT+rqmXAU4E3J7nTvpNsSrI3yd7JycnZdytJ6qVPuE8Ay4eWl3HnaZfnADsAquqjwH2AJVN3VFXbqmq8qsbHxmb88G5J0inqE+57gNVJViVZzOAF051TxtwEPBkgyY8xCHdPzSVpgcwY7lV1DNgM7AYOMHhXzL4kVyVZ3w37FeCKJJ8CrgEur6qpUzeSpBHpdVfIqtoF7Jqy7sqhx/uBJ85ta5KkU+UVqpLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBvUK9yTrkhxMcijJlmm2vybJ9d3XPyT56ty3Kknqa8ZPYkqyCNgKPIXBh2XvSbKz+/QlAKrql4fGvwC4YB56lST11OfMfS1wqKoOV9UdwHbg0pOM38jgc1QlSQukT7gvBY4MLU906+4kyXnAKuD9J9i+KcneJHsnJydn26skqac+4Z5p1tUJxm4Arq2q7023saq2VdV4VY2PjY317VGSNEt9wn0CWD60vAw4eoKxG3BKRpIWXJ9w3wOsTrIqyWIGAb5z6qAkjwQeAHx0bluUJM3WjOFeVceAzcBu4ACwo6r2JbkqyfqhoRuB7VV1oikbSdKIzPhWSICq2gXsmrLuyinLL5+7tiRJp8MrVCWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDeoV7knWJTmY5FCSLScY8/NJ9ifZl+TquW1TkjQbM34SU5JFwFbgKQw+LHtPkp1VtX9ozGrgpcATq+r2JA+ar4YlSTPrc+a+FjhUVYer6g5gO3DplDFXAFur6naAqrplbtuUJM1Gn3BfChwZWp7o1g17BPCIJB9O8rEk66bbUZJNSfYm2Ts5OXlqHUuSZtQn3DPNupqyfAawGngSsBF4fZJz7/RNVduqaryqxsfGxmbbqySppz7hPgEsH1peBhydZsxfVNV3q+rzwEEGYS9JWgB9wn0PsDrJqiSLgQ3Azilj3gX8O4AkSxhM0xyey0YlSf3NGO5VdQzYDOwGDgA7qmpfkquSrO+G7QZuTbIf+ADwa1V163w1LUk6uRnfCglQVbuAXVPWXTn0uICXdF+SpAXmFaqS1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1qFe4J1mX5GCSQ0m2TLP98iSTSa7vvp47961Kkvqa8cM6kiwCtgJPYfBZqXuS7Kyq/VOGvrWqNs9Dj5KkWepz5r4WOFRVh6vqDmA7cOn8tiVJOh19wn0pcGRoeaJbN9V/SPLpJNcmWT4n3UmSTkmfcM8062rK8l8CK6vq0cDfAG+adkfJpiR7k+ydnJycXaeSpN76hPsEMHwmvgw4Ojygqm6tqu90i68DHjvdjqpqW1WNV9X42NjYqfQrSeqhT7jvAVYnWZVkMbAB2Dk8IMmDhxbXAwfmrkVJ0mzN+G6ZqjqWZDOwG1gEvLGq9iW5CthbVTuBFyZZDxwDbgMun8eeJUkzmDHcAapqF7Bryrorhx6/FHjp3LYmSTpVXqEqSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWpQr3BPsi7JwSSHkmw5ybjLklSS8blrUZI0WzOGe5JFwFbgEmANsDHJmmnGnQ28EPj4XDcpSZqdPmfua4FDVXW4qu4AtgOXTjPuvwKvAr49h/1Jkk5Bn3BfChwZWp7o1v1AkguA5VX17pPtKMmmJHuT7J2cnJx1s5KkfvqEe6ZZVz/YmNwLeA3wKzPtqKq2VdV4VY2PjY3171KSNCt9wn0CWD60vAw4OrR8NnA+8MEkNwJPAHb6oqokLZw+4b4HWJ1kVZLFwAZg5/GNVfW1qlpSVSuraiXwMWB9Ve2dl44lSTOaMdyr6hiwGdgNHAB2VNW+JFclWT/fDUqSZu+MPoOqahewa8q6K08w9kmn35Yk6XR4haokNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUG9wj3JuiQHkxxKsmWa7f8pyWeSXJ/kQ0nWzH2rkqS+Zgz3JIuArcAlwBpg4zThfXVV/XhVPQZ4FfAHc96pJKm3Pmfua4FDVXW4qu4AtgOXDg+oqq8PLZ4J1Ny1KEmarT6foboUODK0PAE8fuqgJM8HXgIsBn5yuh0l2QRsAlixYsVse5Uk9dTnzD3TrLvTmXlVba2qhwG/Abxsuh1V1baqGq+q8bGxsdl1KknqrU+4TwDLh5aXAUdPMn478PTTaUqSdHr6hPseYHWSVUkWAxuAncMDkqweWnwa8Nm5a1GSNFszzrlX1bEkm4HdwCLgjVW1L8lVwN6q2glsTnIx8F3gduDZ89m0JOnk+rygSlXtAnZNWXfl0OMXzXFfkqTT4BWqktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNahXuCdZl+RgkkNJtkyz/SVJ9if5dJL/k+S8uW9VktTXjOGeZBGwFbgEWANsTLJmyrDrgPGqejRwLfCquW5UktRfnzP3tcChqjpcVXcw+ADsS4cHVNUHqupb3eLHGHyItiRpgfQJ96XAkaHliW7diTwHeM/pNCVJOj19PkM106yraQcmzwDGgZ84wfZNwCaAFStW9GxRkjRbfc7cJ4DlQ8vLgKNTByW5GPgvwPqq+s50O6qqbVU1XlXjY2Njp9KvJKmHPuG+B1idZFWSxcAGYOfwgCQXAK9lEOy3zH2bkqTZmDHcq+oYsBnYDRwAdlTVviRXJVnfDfvvwFnA25Jcn2TnCXYnSRqBPnPuVNUuYNeUdVcOPb54jvuSJJ0Gr1CVpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDWoV7gnWZfkYJJDSbZMs/2iJJ9McizJZXPfpiRpNmYM9ySLgK3AJcAaYGOSNVOG3QRcDlw91w1Kkmavz8fsrQUOVdVhgCTbgUuB/ccHVNWN3bbvz0OPkjQyK7f81bzXuPF3nzbvNfpMyywFjgwtT3TrZi3JpiR7k+ydnJw8lV1IknroE+6ZZl2dSrGq2lZV41U1PjY2diq7kCT10CfcJ4DlQ8vLgKPz044kaS70Cfc9wOokq5IsBjYAO+e3LUnS6Zgx3KvqGLAZ2A0cAHZU1b4kVyVZD5DkcUkmgJ8DXptk33w2LUk6uT7vlqGqdgG7pqy7cujxHgbTNZKkuwCvUJWkBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1qNdFTFIrt0GV7ik8c5ekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUG9wj3JuiQHkxxKsmWa7T+S5K3d9o8nWTnXjUqS+psx3JMsArYClwBrgI1J1kwZ9hzg9qp6OPAa4PfmulFJUn99rlBdCxyqqsMASbYDlwL7h8ZcCry8e3wt8EdJUlU1h73eJSzklZr35KtE5/vYT3bcC1lbOlWZKX+TXAasq6rndsvPBB5fVZuHxtzQjZnolj/XjfnKlH1tAjZ1i48EDs7VgfSwBPjKjKOsbW1rW/uuXfu8qhqbaVCfM/dMs27qM0KfMVTVNmBbj5pzLsneqhq3trWtbe1Wap9MnxdUJ4DlQ8vLgKMnGpPkDOD+wG1z0aAkafb6hPseYHWSVUkWAxuAnVPG7ASe3T2+DHh/i/PtknR3MeO0TFUdS7IZ2A0sAt5YVfuSXAXsraqdwBuANyc5xOCMfcN8Nn2KFmQ6yNrWtra1F8KML6hKku5+vEJVkhpkuEtSg5oP95lunTDPtd+Y5JbuOoBR1l2e5ANJDiTZl+RFI6x9nyT/L8mnutq/ParaQz0sSnJdkncvQO0bk3wmyfVJ9o649rlJrk3y993P/l+NqO4ju+M9/vX1JC8eRe2u/i93/9ZuSHJNkvuMsPaLurr7RnnMvVRVs18MXgD+HPBQYDHwKWDNCOtfBFwI3DDi434wcGH3+GzgH0Z13AyueTire3xv4OPAE0Z8/C8BrgbePcq6Xe0bgSWjrtvVfhPw3O7xYuDcBehhEfAlBhfajKLeUuDzwH275R3A5SOqfT5wA3A/Bm9O+Rtg9UL87Kf7av3M/Qe3TqiqO4Djt04Yiar6vyzA+/2r6uaq+mT3+BvAAQb/CUZRu6rqH7vFe3dfI3vVPsky4GnA60dV864gyTkMTibeAFBVd1TVVxeglScDn6uqL4yw5hnAfbtrbO7Hna/DmS8/Bnysqr5VVceAvwV+ZkS1Z9R6uC8FjgwtTzCikLur6O7QeQGDM+hR1VyU5HrgFuB9VTWy2sAfAr8OfH+ENYcV8N4kn+hutzEqDwUmgT/tpqRen+TMEdY/bgNwzaiKVdUXgVcDNwE3A1+rqveOqPwNwEVJHpjkfsBT+eELPhdU6+He67YIrUpyFvB24MVV9fVR1a2q71XVYxhczbw2yfmjqJvkp4FbquoTo6h3Ak+sqgsZ3EX1+UkuGlHdMxhMAf6vqroA+CYw6teYFgPrgbeNsOYDGPw2vgp4CHBmkmeMonZVHWBwB9z3AX/NYNr32Chq99F6uPe5dUKTktybQbC/paresRA9dNMCHwTWjajkE4H1SW5kMAX3k0n+fES1Aaiqo92ftwDvZDA1OAoTwMTQb0nXMgj7UboE+GRVfXmENS8GPl9Vk1X1XeAdwL8eVfGqekNVXVhVFzGYgv3sqGrPpPVw73PrhOYkCYO51wNV9Qcjrj2W5Nzu8X0Z/Of7+1HUrqqXVtWyqlrJ4Gf9/qoayVkcQJIzk5x9/DHwUwx+dZ93VfUl4EiSR3arnswP35Z7FDYywimZzk3AE5Lcr/t3/2QGrzGNRJIHdX+uAH6W0R//CfW5K+TdVp3g1gmjqp/kGuBJwJIkE8BvVdUbRlD6icAzgc90c98Av1lVu0ZQ+8HAm7oPebkXsKOqRv6WxAXyz4B3DjKGM4Crq+qvR1j/BcBbuhOZw8AvjqpwN+f8FOB5o6oJUFUfT3It8EkGUyLXMdrbAbw9yQOB7wLPr6rbR1j7pLz9gCQ1qPVpGUm6RzLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoP+P+ZvNsSM9EypAAAAAElFTkSuQmCC\n", 167 | "text/plain": [ 168 | "
" 169 | ] 170 | }, 171 | "metadata": { 172 | "needs_background": "light" 173 | }, 174 | "output_type": "display_data" 175 | } 176 | ], 177 | "source": [ 178 | "\n", 179 | "for i in range(10000):\n", 180 | " index = random.randrange(10000)\n", 181 | " if most_likely[index] != y_test[index]:\n", 182 | " break\n", 183 | "\n", 184 | "plt.imshow(orig_test[index], cmap='gray')\n", 185 | "plt.title('Prediction: %d, label: %d' % (most_likely[index], y_test[index]))\n", 186 | "plt.show()\n", 187 | "\n", 188 | "plt.bar(range(10), predictions[index], tick_label=range(10))\n", 189 | "plt.title('Prediction values')\n", 190 | "plt.show()" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": {}, 196 | "source": [ 197 | "The following cell calculates the error rate by comparing predicted values with expected values. This is similar to what Keras does when evaluating a model." 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 13, 203 | "metadata": {}, 204 | "outputs": [ 205 | { 206 | "name": "stdout", 207 | "output_type": "stream", 208 | "text": [ 209 | "Error rate: 2.19 %\n" 210 | ] 211 | } 212 | ], 213 | "source": [ 214 | "total = 0.0\n", 215 | "misclassified = 0.0\n", 216 | "for i in range(10000):\n", 217 | " total += 1\n", 218 | " if most_likely[i] != y_test[i]:\n", 219 | " misclassified += 1\n", 220 | "print('Error rate: %.2f %%' % (100.0*misclassified/total))" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [] 229 | } 230 | ], 231 | "metadata": { 232 | "anaconda-cloud": {}, 233 | "kernelspec": { 234 | "display_name": "Python 3", 235 | "language": "python", 236 | "name": "python3" 237 | }, 238 | "language_info": { 239 | "codemirror_mode": { 240 | "name": "ipython", 241 | "version": 3 242 | }, 243 | "file_extension": ".py", 244 | "mimetype": "text/x-python", 245 | "name": "python", 246 | "nbconvert_exporter": "python", 247 | "pygments_lexer": "ipython3", 248 | "version": "3.6.8" 249 | } 250 | }, 251 | "nbformat": 4, 252 | "nbformat_minor": 1 253 | } 254 | -------------------------------------------------------------------------------- /MNIST/MNIST_Training.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## MNIST Handwritten Digit Recognition\n", 8 | "\n", 9 | "[MNIST](http://yann.lecun.com/exdb/mnist) is often considered the [hello world](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program) of machine learning. It contains 70,000 images of handwritten digits suitable for image classification. Typically, 60,000 of these images are used for training and 10,000 are set aside for testing. Each digit is a black and white 28 x 28 pixel image along with a label, so the full dataset can be used for supervised training as well as testing unsupervised algorithms.\n", 10 | "\n", 11 | "Over the years, MNIST has been used to measure the accuracy of a number of different algorithms. In this example, we will train a standard three layer neural network. Even this simple model can achieve 98% accuracy, rivaling human performance.\n", 12 | "\n", 13 | "This example requires Python 3, Keras, Tensorflow, matplotlib, and numpy. You can use either Tensorflow-CPU or Tensorflow-GPU, of course Tensorflow-GPU will train significantly faster." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 1, 19 | "metadata": {}, 20 | "outputs": [ 21 | { 22 | "name": "stderr", 23 | "output_type": "stream", 24 | "text": [ 25 | "Using TensorFlow backend.\n" 26 | ] 27 | } 28 | ], 29 | "source": [ 30 | "import keras\n", 31 | "from keras.datasets import mnist\n", 32 | "from keras.models import Sequential\n", 33 | "from keras.layers import Dense, Dropout, Flatten\n", 34 | "from keras.optimizers import Adam\n", 35 | "from matplotlib import pyplot as plt\n", 36 | "import numpy as np\n", 37 | "import random" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "These are some configuration parameters and hyperparameters." 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 2, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "# Input image dimensions\n", 54 | "img_rows, img_cols = 28, 28\n", 55 | "\n", 56 | "# The number of training samples per batch. 128 is a reasonable number.\n", 57 | "batch_size = 128\n", 58 | "\n", 59 | "# Our data set contains 10 digits, so the number of classes is 10\n", 60 | "num_classes = 10\n", 61 | "\n", 62 | "# epochs is the number of times the model is trained with the data set, more can be better, up to a point\n", 63 | "epochs = 20\n", 64 | "\n", 65 | "# dropout is a common regularization hyperperameter. It helps to avoid overfitting or memorizing the input.\n", 66 | "dropout = 0.5" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "### Load data\n", 74 | "\n", 75 | "Keras has a builting function for loading MNIST data and splitting it into train and test sets. x_train and x_test are arrays of train and test input images respectively. Images are represented as a 28 x 28 matrix of pixel values. y_train and y_test are train and test labels respectively.\n", 76 | "\n", 77 | "Pixel values are normalized into values ranging from 0.0 - 1.0." 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 3, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "name": "stdout", 87 | "output_type": "stream", 88 | "text": [ 89 | "60000 train samples\n", 90 | "10000 test samples\n" 91 | ] 92 | } 93 | ], 94 | "source": [ 95 | "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", 96 | "\n", 97 | "# Save original test images for display purposes\n", 98 | "orig_test = x_test\n", 99 | "\n", 100 | "x_train, x_test = x_train / 255.0, x_test / 255.0\n", 101 | "\n", 102 | "print(x_train.shape[0], 'train samples')\n", 103 | "print(x_test.shape[0], 'test samples')" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "The following cell display random test images to get an idea of what they look like." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 6, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "image/png": "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\n", 121 | "text/plain": [ 122 | "
" 123 | ] 124 | }, 125 | "metadata": { 126 | "needs_background": "light" 127 | }, 128 | "output_type": "display_data" 129 | } 130 | ], 131 | "source": [ 132 | "index = random.randrange(1000)\n", 133 | "plt.imshow(orig_test[index], cmap='gray')\n", 134 | "plt.title('Label: %d' % y_test[index])\n", 135 | "plt.show()" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "### Define Model\n", 143 | "\n", 144 | "This is the neural network model itself built using predefined Keras classes. This is a simple three layer model using dense, fully connected layers. Still, it achieves very good accuracy which demonstrates the predictive power of properly trained neural networks. The initial layer flattens the input matrix into a 784 element vector.\n", 145 | "\n", 146 | "The following two layers use a REctified Linear Unit activation function, which does not suffer from the \"vanishing gradient\" problem that plagued traditional sigmoid activation functions in the past. The output layer has 10 neurons corresponding to one of 10 possible digit classes. The neuron with the largest output is the most likely digit. This is known as one-hot encoding, a concept borrowed from digital logic.\n", 147 | "\n", 148 | "The best image recognition models use Convolutional Neural Networks (CNNs), which are like two dimensional FIR filters. The inpiration for CNNs comes from the visual cortex of animal brains. Models with over 100 CNN, pooling, padding, and other layers have been successfully trained to recognize complex objects as well as multiple objects in the one image." 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 7, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "name": "stdout", 158 | "output_type": "stream", 159 | "text": [ 160 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", 161 | "Instructions for updating:\n", 162 | "Colocations handled automatically by placer.\n", 163 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n", 164 | "Instructions for updating:\n", 165 | "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n", 166 | "_________________________________________________________________\n", 167 | "Layer (type) Output Shape Param # \n", 168 | "=================================================================\n", 169 | "flatten_1 (Flatten) (None, 784) 0 \n", 170 | "_________________________________________________________________\n", 171 | "dense_1 (Dense) (None, 512) 401920 \n", 172 | "_________________________________________________________________\n", 173 | "dropout_1 (Dropout) (None, 512) 0 \n", 174 | "_________________________________________________________________\n", 175 | "dense_2 (Dense) (None, 512) 262656 \n", 176 | "_________________________________________________________________\n", 177 | "dropout_2 (Dropout) (None, 512) 0 \n", 178 | "_________________________________________________________________\n", 179 | "dense_3 (Dense) (None, 10) 5130 \n", 180 | "=================================================================\n", 181 | "Total params: 669,706\n", 182 | "Trainable params: 669,706\n", 183 | "Non-trainable params: 0\n", 184 | "_________________________________________________________________\n" 185 | ] 186 | } 187 | ], 188 | "source": [ 189 | "# Create three layer model, two hidden layers, one output layer\n", 190 | "model = Sequential()\n", 191 | "model.add(Flatten(input_shape=(img_rows, img_cols)))\n", 192 | "model.add(Dense(512, activation='relu'))\n", 193 | "model.add(Dropout(dropout))\n", 194 | "model.add(Dense(512, activation='relu'))\n", 195 | "model.add(Dropout(dropout))\n", 196 | "# 10 output units, one for each digit (one hot encoding)\n", 197 | "model.add(Dense(num_classes, activation='softmax'))\n", 198 | "\n", 199 | "model.summary()" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "### Train Model\n", 207 | "\n", 208 | "This is more or less boilerplate Keras code to train the model given the training data set. Keras can also evaluate the trained model given the test data set. Matplotlib is used to plot train and test accuracy as a function of the epoch number.\n", 209 | "\n", 210 | "Ideally, the accuracy with test and train data should be about the same. Low training accuracy means the model exhibits high bias. High bias could be caused by a weak model, not enough training examples, or too few training epochs. High train accuracy and low test accuracy is a case of high variance. This means the model is more or less \"memorizing\" the expected output and not generalizing well. High variance can be reduced through *regularization*." 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 8, 216 | "metadata": {}, 217 | "outputs": [ 218 | { 219 | "name": "stdout", 220 | "output_type": "stream", 221 | "text": [ 222 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", 223 | "Instructions for updating:\n", 224 | "Use tf.cast instead.\n", 225 | "Train on 60000 samples, validate on 10000 samples\n", 226 | "Epoch 1/20\n", 227 | "60000/60000 [==============================] - 13s 225us/step - loss: 0.3484 - acc: 0.8924 - val_loss: 0.1248 - val_acc: 0.9614\n", 228 | "Epoch 2/20\n", 229 | "60000/60000 [==============================] - 13s 210us/step - loss: 0.1617 - acc: 0.9509 - val_loss: 0.0953 - val_acc: 0.9705\n", 230 | "Epoch 3/20\n", 231 | "60000/60000 [==============================] - 12s 200us/step - loss: 0.1292 - acc: 0.9608 - val_loss: 0.0818 - val_acc: 0.9740\n", 232 | "Epoch 4/20\n", 233 | "60000/60000 [==============================] - 9s 153us/step - loss: 0.1112 - acc: 0.9658 - val_loss: 0.0802 - val_acc: 0.9755\n", 234 | "Epoch 5/20\n", 235 | "60000/60000 [==============================] - 11s 186us/step - loss: 0.0958 - acc: 0.9696 - val_loss: 0.0710 - val_acc: 0.9802\n", 236 | "Epoch 6/20\n", 237 | "60000/60000 [==============================] - 11s 190us/step - loss: 0.0859 - acc: 0.9731 - val_loss: 0.0642 - val_acc: 0.9801\n", 238 | "Epoch 7/20\n", 239 | "60000/60000 [==============================] - 11s 184us/step - loss: 0.0790 - acc: 0.9747 - val_loss: 0.0619 - val_acc: 0.9820\n", 240 | "Epoch 8/20\n", 241 | "60000/60000 [==============================] - 11s 184us/step - loss: 0.0737 - acc: 0.9765 - val_loss: 0.0659 - val_acc: 0.9819\n", 242 | "Epoch 9/20\n", 243 | "60000/60000 [==============================] - 11s 183us/step - loss: 0.0692 - acc: 0.9787 - val_loss: 0.0663 - val_acc: 0.9811\n", 244 | "Epoch 10/20\n", 245 | "60000/60000 [==============================] - 11s 180us/step - loss: 0.0672 - acc: 0.9790 - val_loss: 0.0629 - val_acc: 0.9829\n", 246 | "Epoch 11/20\n", 247 | "60000/60000 [==============================] - 11s 179us/step - loss: 0.0610 - acc: 0.9809 - val_loss: 0.0607 - val_acc: 0.9825\n", 248 | "Epoch 12/20\n", 249 | "60000/60000 [==============================] - 11s 178us/step - loss: 0.0569 - acc: 0.9818 - val_loss: 0.0629 - val_acc: 0.9826\n", 250 | "Epoch 13/20\n", 251 | "60000/60000 [==============================] - 10s 170us/step - loss: 0.0567 - acc: 0.9826 - val_loss: 0.0646 - val_acc: 0.9805\n", 252 | "Epoch 14/20\n", 253 | "60000/60000 [==============================] - 9s 151us/step - loss: 0.0559 - acc: 0.9823 - val_loss: 0.0620 - val_acc: 0.9820\n", 254 | "Epoch 15/20\n", 255 | "60000/60000 [==============================] - 10s 175us/step - loss: 0.0547 - acc: 0.9824 - val_loss: 0.0605 - val_acc: 0.9818\n", 256 | "Epoch 16/20\n", 257 | "60000/60000 [==============================] - 11s 180us/step - loss: 0.0510 - acc: 0.9840 - val_loss: 0.0681 - val_acc: 0.9808\n", 258 | "Epoch 17/20\n", 259 | "60000/60000 [==============================] - 11s 176us/step - loss: 0.0509 - acc: 0.9840 - val_loss: 0.0612 - val_acc: 0.9828\n", 260 | "Epoch 18/20\n", 261 | "60000/60000 [==============================] - 11s 176us/step - loss: 0.0466 - acc: 0.9854 - val_loss: 0.0637 - val_acc: 0.9839\n", 262 | "Epoch 19/20\n", 263 | "60000/60000 [==============================] - 11s 175us/step - loss: 0.0449 - acc: 0.9856 - val_loss: 0.0646 - val_acc: 0.9821\n", 264 | "Epoch 20/20\n", 265 | "60000/60000 [==============================] - 11s 176us/step - loss: 0.0446 - acc: 0.9861 - val_loss: 0.0651 - val_acc: 0.9835\n", 266 | "Test loss: 0.06511768952859093\n", 267 | "Test accuracy: 0.9835\n" 268 | ] 269 | }, 270 | { 271 | "data": { 272 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XmYXGWZ9/Hv3Xsn6S3d2Ts7YQkQQghB1iAgQkCRRVkGRUSRGVHUQQdfHVQcR3AbUXhHUaIgjigoig6IGEHgZUuAJASSkAWS6qRDOr0m6bW67vePczqpNL1U0l1dla7f57rqqrM8p+qu6q6661nOc8zdERER6UtWqgMQEZH0p2QhIiL9UrIQEZF+KVmIiEi/lCxERKRfShYiItIvJQvJeGY2zczczHISKPtRM3tmKOISSSdKFnJQMbO3zKzdzCq6bV8efuFPS01kIsObkoUcjN4ELu9aMbOjgcLUhZMeEqkZiRwoJQs5GP0S+Ejc+lXAvfEFzKzEzO41sxoz22RmXzGzrHBftpl918x2mNlG4Lwejr3bzKrNbIuZ/YeZZScSmJk9YGbbzKzRzJ4ysyPj9hWa2ffCeBrN7BkzKwz3nWJmz5pZg5lFzOyj4fYnzezjcY+xTzNYWJv6lJmtA9aF224PH6PJzF4ys1Pjymeb2f8xsw1mtjPcP9nM7jSz73V7LX8ys88m8rpl+FOykIPR80CxmR0RfolfCtzXrcyPgBJgBrCQILlcHe77BHA+cCwwH7ik27H3AFHgkLDM2cDHScyjwCxgLPAy8Ku4fd8FjgNOAkYDXwRiZjYlPO5HwBhgLrA8wecD+ABwAjA7XF8aPsZo4H+AB8ysINz3eYJa2SKgGPgY0By+5svjEmoFcCbw6/2IQ4Yzd9dNt4PmBrwFnAV8BfgWcA7wOJADODANyAbagNlxx30SeDJc/jtwXdy+s8Njc4Bx4bGFcfsvB54Ilz8KPJNgrKXh45YQ/DBrAY7podyXgId6eYwngY/Hre/z/OHjn9FPHPVdzwusBS7opdxq4D3h8vXAI6n+e+uWPje1ccrB6pfAU8B0ujVBARVAHrApbtsmYFK4PBGIdNvXZSqQC1SbWde2rG7lexTWcr4JfJCghhCLiycfKAA29HDo5F62J2qf2MzsXwlqQhMJkklxGEN/z3UPcCVB8r0SuH0AMckwo2YoOSi5+yaCju5FwO+77d4BdBB88XeZAmwJl6sJvjTj93WJENQsKty9NLwVu/uR9O8K4AKCmk8JQS0HwMKYWoGZPRwX6WU7wG5gRNz6+B7K7Jk6Ouyf+DfgQ0CZu5cCjWEM/T3XfcAFZnYMcATwh17KSQZSspCD2TUETTC74ze6eyfwW+CbZlZkZlMJ2uq7+jV+C3zGzCrNrAy4Ke7YauCvwPfMrNjMssxsppktTCCeIoJEU0vwBf+fcY8bAxYD3zeziWFH84lmlk/Qr3GWmX3IzHLMrNzM5oaHLgcuMrMRZnZI+Jr7iyEK1AA5ZnYzQc2iy8+Ab5jZLAvMMbPyMMYqgv6OXwK/c/eWBF6zZAglCzloufsGd1/Wy+5PE/wq3wg8Q9DRuzjc91PgMWAFQSd095rJRwiasV4naO9/EJiQQEj3EjRpbQmPfb7b/huBVwm+kOuA24Asd99MUEP613D7cuCY8Jj/AtqBtwmaiX5F3x4j6Cx/I4yllX2bqb5PkCz/CjQBd7PvsON7gKMJEobIHuauix+JSMDMTiOogU0La0MigGoWIhIys1zgBuBnShTSnZKFiGBmRwANBM1tP0hxOJKG1AwlIiL9Us1CRET6NWxOyquoqPBp06alOgwRkYPKSy+9tMPdx/RXbtgki2nTprFsWW+jKEVEpCdmtqn/UmqGEhGRBChZiIhIv5QsRESkX8Omz6InHR0dVFVV0dramupQhkxBQQGVlZXk5uamOhQRGUaGdbKoqqqiqKiIadOmETfd9LDl7tTW1lJVVcX06dNTHY6IDCPDuhmqtbWV8vLyjEgUAGZGeXl5RtWkRGRoDOtkAWRMouiSaa9XRIbGsG6GEhEZDlo7Omlq7aCpJUpTaweNLR00tXTQ1BqlqaWDshF5XHHClP4faACULJKotraWM888E4Bt27aRnZ3NmDHBiZIvvvgieXl5/T7G1VdfzU033cRhhx2W1FhF5MB0dMZoaumgvTNGezRGR2eMtmjXstMejdHe2Rneh+thuWBbjOb2KE0t0SAJtAaJoDEuGbRF+54E+NgppUoWB7Py8nKWL18OwNe+9jVGjRrFjTfeuE+ZrouhZ2X13CL485//POlxikhiana2sbq6iTXbmlhTvZPV23ayfvtOOjoHNiFrTpZRXJhLcUEOJYW5FBfmMqGkkOLCnHB77jv2FxfkUlKYS1FBDgW52YP0CvuIMenPIO+wfv16PvCBD3DKKafwwgsv8Oc//5mvf/3rvPzyy7S0tHDppZdy8803A3DKKadwxx13cNRRR1FRUcF1113Ho48+yogRI/jjH//I2LFjU/xqRIaf1o5O1m/fxZptO1lT3RTcb2tix672PWXGFedz+PhiTju0goklheTlZJGXnUVueJ+fk0VeTha52Vl79u1zv2e/kZedlfb9jRmTLL7+p9d4fWvToD7m7InFfPV9Rx7Qsa+//jo///nP+fGPfwzArbfeyujRo4lGo7z73e/mkksuYfbs2fsc09jYyMKFC7n11lv5/Oc/z+LFi7npppt6eniRjNEejbGztQMHYu64g3uw3OM6QY0+Frd9W2Mrq8PawpptTWyo2U1nLKgt5Odkcdj4Is44fCyHjy/m8AlFHD6+mNEj+29GHk4yJlmkm5kzZ3L88cfvWf/1r3/N3XffTTQaZevWrbz++uvvSBaFhYWce+65ABx33HE8/fTTQxqzSKpFO2Os276LV6saWVHVwMqqRtZsaxpwM1CXyrJCDh9fzHuPHL8nMUwrH0l2lkG0HRo2Qe0yWLkBajdA3Qao3Qi5hTDlXTD1pOC+dCoMVU0h2gbNtVA8MalPkzHJ4kBrAMkycuTIPcvr1q3j9ttv58UXX6S0tJQrr7yyx3Ml4jvEs7OziUajQxKrSCq4O2/VNrOyqoEVkUZWVjXw2tYmWjo6ASjKz+HoyhKuOWUGE0oKyMoyDMgyI8uC72qzuG1ZYBhmwfqee6CiKJ/DxhdRnGvQuDlIAHUbYGlXQlgPDRHwzr0BFpTA6Jkw5QRobYTX/gAv3xPsK5oIU0+EKeFt7GzopV9yv+zaDttehbdXwbZVwX3NWqg8Hq55bOCP34eMSRbprKmpiaKiIoqLi6muruaxxx7jnHPOSXVY0peWeoi8CJueDe6jLZA3CvKLIX8U5BeF60V7b72t540KvkjcIRaFWGfwpdS1vGc93OadEIvFLXdC6RQoLN3vl9EejbF9ZyvRTqcgN5v8nCzyc7MoyMkmK2vo2tDdnerG1iAxVAWJ4dWqRppagx9EBblZHDmxhMsWTGZOZQlzKkuZXj5yYDF2tELVi7DxH/DqqiAh1G+CWMfeMnmjYPQMmHgsHP3BIDmUzwzuR4zet/YQi8H212Hzc8Ft03Ow6nfBvvySIKl0JY9J8yAnv/fYOqNQuy5MCK8G99tehd3b95YpngTjjoLDzoVJxx34+5AgJYs0MG/ePGbPns1RRx3FjBkzOPnkk1MdknTXuCX8AngWNj8ffCngkJUDE+bCiApo3xU0U7Tt3HuL/+LpkwWPd6AsCybNh0POhJlnwqR57O5wtjW1sq0xvIXL1Y2tvN0U3O/Y1dbrQ+ZmGwU52eTnZpEf3u9dz9qTXApys8kyC/sEIBbzPf0D+67v7TeIxfYud8aczXUte2LJyTIOG1/EeXMmckyYGA4dN4qc7AH+Mo91QvUKePMfsPHJ4O8YbQXLhjGHB7/+j3jfvglh1NjEm5OysmD8UcFtwSeC5N+wed//m3V/Dcpm5wdf8F1NV7mFcYnhVdi+BjrDv01WLow9HA45K3jscUfB+KODZDWEhs01uOfPn+/dL360evVqjjjiiBRFlDpp/7rdof4teOuZ4Lb5WWjfHXxos7KDL2DLilsO77Oy4paz9y1fWAbFE4Lqf/EEKIq75exnR6R7ULWP/4XYuDnYlzcKJi+I+4V4HOSN6P2xom3QtgvamoJk0raz53XvjHut2XGvL6fbejZu2TRHob6lk4bWGHXNUfJqVjGx9lkqW9aQhdPESJ7uPJKnYsfwVOccqikHoHRELuOLCxhfUrDPfV5OFm3RGG0dnbRGY7R1xGiNdvZ4n9tWz8SWN5jatpZpHeuZEd3ASG+hw3KIkkuH5dBBLh2WRzTcFrVcOiyXTguWu26dlks0KxdGlFM8YRYTph3G9ENmUzBq/2tJPf4dazfAxieCBPHm09DaEOwbOxumL4QZpwdf1gXFA3++ROzeESSNrv+t6hVBDbHLiIp9E8L4o6HiUMhO3sSgZvaSu8/vr5xqFpJ83ZPDW89AU1Wwb0QFTDsZRo6Ja2aJ9dAc063ZpatctDVYrtsAq6v3/hqLN6KiWyLpdj9qPNS/uffX3+bnoKUuOHbkmCApnPgvwa/AcUdD9n58bHLyg9vI8gTfKqdudzvVYW2guqmV6rqWPTWCbU2tVDe20Nqx70laZuMYW7SIWaPbOS33deZ3vMLCXS9yXvuLkAvtZYeQdciZ5Bz6Hpg6v+8EF29XTfCFVv1KcP/2ir2JE4KO3AkLgvepsy3oBO5sg86OIFF2tge3aBt07g7vO8KybXv37eyEt4Hl4eOOqICyaVA2NbyfFjxX2bSg+aW3v8HObUGzUlftoWlLsL1kMhxxPkw/HaafBkXjEnv9g21kRRDHEecH6+27oWpZ8J6MPwpGjRu6jvH9lNRkYWbnALcD2cDP3P3WbvunAouBMUAdcKW7V4X7vg2cRzB/1ePADT5cqkHDXb/J4RSY9lmYdiqMOWzwPhzuQV9C01bYWd3z/ZZlwciR3pRND9qAu2oO5TOT9uF9u6mV5zbU8vzGWjbu2L2nqai929m6OVnGuLAWMHtiMWcePpbxJQVMKCkM7wsYW5Qf10yzaO/7UbMG1i8hb8Pf4ZV7YOlPgiaQqScGzVUzz4BxRwavcee2ICFsXR4miOV7v2whaJapnA8LPg4TjgluhWUDfyO6/m71b+17a9gEW14KOo7jO5azcoIv/65EUjo1iP3NfwSvF4K4pp8GM24MahCjZ6Tnl3DeSJixMNVRJCRpzVBmlg28AbwHqAKWApe7++txZR4A/uzu95jZGcDV7v5hMzsJ+A5wWlj0GeBL7v5kb8+nZqi99vt1tzQEzSJ9NgN1LffwgXMPPtjxyaExEuwbUR4mh1OD+zGHp/5DG20Lk0c17NwafNEUTwySQ9H4pD1tzc42nt9Yy3Mba3l+Q5AgAEoKczlsfBETSoKEMKG4gPElhUwIE0H5qPxg6OZAdbQEtacNf4f1S6BmdbB9VPiad20LCxpUzAoTwtzwfk4w+icVOqPBj436Tfsmkq7l5lrIKQyak2YsDJLD+DmDM/ooA6RDM9QCYL27bwwDuh+4AHg9rsxs4HPh8hPAH8JlBwqAPIKev1yCSqoMpmgbPPMDePp7PTff9MjemUQgSDawNzmcfEP6JIfucvL3Nm0kUf3udl54s5bnNgQJ4o23dwEwKj+HE6aP5ooTpvCuGeUcMaF4cJJBf3ILgw7wQ86E934zqGlt+HvQXGPZMHFukBzGHxWM0koX2Tlxf68efoW37QxqS/vbNyX7JZnJYhIQiVuvAk7oVmYFcDFBU9WFQJGZlbv7c2b2BFBNkCzucPfV3Z/AzK4FrgWYMiW5k2gNOxv/Af/7+WC44FEXB80R+wzRjB+mGfYZ7DOcM65vwWNBJ1y6Joch0tjSwYtv1u1JDmu2NeEOhbnZHD99NBceW8mJM8s5amLxwEf2DIbiiXDslcHtYJZOiW0YS2ay6Okbo3ub143AHWb2UeApYAsQNbNDgCOAyrDc42Z2mrs/tc+Dud8F3AVBM9Qgxj587aqBv34ZVv4maJ+/8vfBL00Bgg7mtmiM5vZOdrdFg/v2KC3d1pvbOmlu76S5PcrOtiirtjSyaksjMQ+mhzhuahmfP+tQTpxZzpzKUvJy0iA5iAxAMpNFFTA5br0S2BpfwN23AhcBmNko4GJ3bwxrDM+7+65w36PAuwgSykFjMKYoB1i8eDGLFi1i/PgBtKfHYsHZpX/7KrQ3w2lfhFM/HzRNZKDOmLM80sCTa7fz1Bs1bGtqpbktSASx/fjZkZ+TxYi8bGaNLeL6M2Zx4oxyjp1SOiSzgIoMpWQmi6XALDObTlBjuAy4Ir6AmVUAde4eA75EMDIKYDPwCTP7FkENZSHwgyTGmhSJTFGeiMWLFzNv3rwDTxbbVsGfPxecrTrtVDjv+zDm0AN7rINY/e52nlpXw9/XbOcfb9TQ0NxBlsG8KWWcfuhYRuRnMzIvh8K8bEbmZTMiP4eReTmMyM9mRG42I/NzGJG3974wNzs9mpNEhkDSkoW7R83seuAxgqGzi939NTO7BVjm7g8DpwPfMjMnqDV8Kjz8QeAM4FWCpqu/uPufkhVrKtxzzz3ceeedtLe3c9JJJ3HHHXcQi8W4+uqrWb58Oe7Otddey7hx41i+fDmXXnophYWF+1UjoW0X/ONWeO7/BkMJL/wJzLk0Y/oU3J3XtjbxxJrtPLF2O8sjDcQcRo/M44zDxnL64WM5bVYFpSPUMSrSn6SeZ+HujwCPdNt2c9zygwSJoftxncAnBzWYR28KTqMfTOOPhnNv7b9cN6tWreKhhx7i2WefJScnh2uvvZb777+fmTNnsmPHDl59NYizoaGB0tJSfvSjH3HHHXcwd+7cxJ9kzf/CI18MhhzOuwrO+tqQTw+QCk2tHfy/dTt4Yu12nlxbw/adwSivOZUlfPqMWbz78LEcPalkaEYfiQwjOoM7Bf72t7+xdOlS5s8Phja3tLQwefJk3vve97J27VpuuOEGFi1axNlnn73/Dx5tD6YU+PMVwZQGlzwWnHk8TMVizhvbd/LUG0Hz0rK36onGnKKCHE47dAzvPmwsCw8dw5iiPiZtE5F+ZU6yOIAaQLK4Ox/72Mf4xje+8Y59K1eu5NFHH+WHP/whv/vd77jrrrsSfNAY7K4JTjCLtsBZX4cTP5XUOWVSoaW9k+WRBl7aVMeyTfW8vKl+z8ykh48v4hOnzeDdh41l3pRS9SeIDKLMSRZp5KyzzuKSSy7hhhtuoKKigtraWnbv3k1hYSEFBQV88IMfZPr06Vx33XUAFBUVsXPnzp4fzGPB/DKNW4IkkV8MRVlw5AHUStLQ9qZWlm2qZ9lb9by0qY7XtjYRDYcrzRo7ivPmTOC4qaM5aWY5E0szc2SXyFBQskiBo48+mq9+9aucddZZxGIxcnNz+fGPf0x2djbXXHMN7o6ZcdtttwFw9dVX8/GPfzzo4H7mCfKsEzqag+kbOloIpsrODc6bKCgJpjc+CHU1KQWJoZ5lm+qI1LUAwRDVYyaXcu1pM5g/rYx5U8rUMS0yhDRFebqKxYKaQldSaG8OZljtOq/RsoNzJHJHBPcFJXum3jhYXndjSwcrqxpYvrkhaFLaXM/OsEmpYlQ+86eWMX9aGcdNLePIiSU6sU0kCdJhbihJVKwzSATtzXuTQ7Rl737LDpLCqLF7E0R23kE1BLajM8babTt5JRIkh+WRejbU7N6z/9Bxozh/zsQ9CWLK6BHYQfT6RIY7JYtUirYFl0lsrgv6HiCYoC+3EArG7a01HGSJwd3Z0tDC8j2JoYFVWxv3XIOhfGQecyeXcuGxk5g7uYw5k0soLhheHfEiw82wTxZd7f9ppb05uPB6az1gwQlzBaVhYsgdUGJIRbPirrYoKyMNQa0h0sArmxv2XCIzLyeLoyYWc8WCqcydUsqxk0upLCtMv7+JiPRpWCeLgoICamtrKS8vT/2Xk3swlfKu7dC+M7hexMixMGpMUHMYlKdwamtrKSgoGJTH68+m2t387Ok3eeClyJ5aw4yKkZw2q4K5U0qZO7mUw8cXq69BZBgY1smisrKSqqoqampqUheEe9AH0dYUXEIyKxvyiiB/FDQ0AU2D+nQFBQVUVlb2X3AAlkcauOupDfxl1TZysrL4wLETOW/ORI6pLNEIJZFhalgni9zcXKZPn56aJ2/fDa/8Cp77ETRsDq73cNJnYM6HgovvHGRiMefva7Zz19MbefHNOooKcvjkwplcfdI0xhYPTU1GRFJnWCeLlNi9A168C178KbTUweQT4Jzb4NBzDsrLPLZFO/nDK1v46dNvsn77LiaWFPCV847gsgVTGJWvfx+RTKFP+2CpexOeuwNeuS8YBnvYouDSogfpvEyNzR3c98ImfvHsW9TsbGP2hGJuv2wui46eQK6m0RDJOEoWA9XRCn+6AV79bXA+xDGXBs1NYw5LdWQHpKq+mbufeZPfLI3Q3N7JqbMq+K8PzeXkQ9JgkICIpIySxUC4w8OfDhLFidcHt+IJqY7qgKza0shdT23kf1+txoD3HTORT5w6g9kTi1MdmoikASWLgXjm+0GiePdXYOEXUh3NAXlhYy0/+vt6nlm/g1H5OXzs5GlcffJ0TconIvtQsjhQq/8ES26Boy6B0/b/Uqmp9tyGWm5f8gbPb6yjYlQ+N517OJcvmEJJoc6kFpF3UrI4ENUr4PfXwqT5cMEdB81UHO7Ocxtq+cGSdbz4Zh1jivL59/Nnc8WCKRTmZac6PBFJY0oW+2vn2/Dry4MpOi77n2CKjjTn7vy/9UFNYulb9Ywrzuer75vN5QumUJCrJCEi/VOy2B8drXD/FdBSDx/7CxSNS3VEfXJ3nl63g9uXrOOlTfWMLy7g6+8/kkuPn6wkISL7RckiUe7w8PWwZRlceh9MOCbVEfXK3fnHGzXcvmQdr2xuYGJJAd/4wFF8aH4l+TlKEiKy/5QsEvX0d+HVB+CMf4cj3pfqaHrk7jy5NkgSyyMNTCot5JsXHsUlxylJiMjAKFkk4vU/wt//A47+EJz6r6mO5h3cg3mbfrhkHSuqGqksK+RbFx3NxfMqNeOriAwKJYv+bF0OD10HlcfD+3+UdiOfXt/axJceepUVkQYmjy7ktouP5qJ5lZqSQ0QGlZJFX3ZuC0c+jQ5HPqXP7Krt0Rh3PLGe//vEekpH5PHti+dw4bxJShIikhRKFr3paAlGPrU2wjWPBde/ThOvVjXyhQdXsGbbTi48dhJffd9sXUdCRJJKyaIn7vDHT8GWl4ORT+OPTnVEQDBd+O1/W8dPntpIxag87r5qPmcekd7Dd0VkeFCy6MlT34FVv4OzvgZHnJ/qaIDg6nRfeGAF67bv4oPHVfKV82drag4RGTJKFt299gd44ptwzOVw8mdTHQ2tHZ381+Nv8NOnNzKuuIBfXH08px+WPk1iIpIZlCzibX0lGPk0+QR43+0pH/n00qY6vvDASjbu2M3lC6bwfxYdTlGBahMiMvSULLo0VQcjn0ZWwKW/Sul1slvaO/nOY2v5+bNvMrGkkPuuOYFTZlWkLB4RESULgPZmuP9yaG2Ca/4Ko8akLJQXNtbyxd+tZFNtMx9+11T+7dzDda1rEUk5fQt1jXzaujw4l2L8USkJY3dblG//ZQ33PLeJKaNH8OtPvIsTZ5anJBYRke6SmizM7BzgdiAb+Jm739pt/1RgMTAGqAOudPeqcN8U4GfAZMCBRe7+1qAHWbsB1j0O7/k6HL5o0B8+Ec9u2MEXH1zJloYWrj55Gl9472GMyFMeF5H0kbRvJDPLBu4E3gNUAUvN7GF3fz2u2HeBe939HjM7A/gW8OFw373AN939cTMbBcSSEmjFIfCp56F4UlIevj/Pbajlw3e/yJTRI/jtJ0/k+GmjUxKHiEhfkvnzdQGw3t03ApjZ/cAFQHyymA18Llx+AvhDWHY2kOPujwO4+64kxgkllUl9+N5sb2rl079+hanlI/jjp07WSCcRSVvJnEhoEhCJW68Kt8VbAVwcLl8IFJlZOXAo0GBmvzezV8zsO2FNZR9mdq2ZLTOzZTU1NUl4CcnT0Rnj+v95hd1tUX585XFKFCKS1pKZLHo6ScG7rd8ILDSzV4CFwBYgSlDjOTXcfzwwA/joOx7M/S53n+/u88eMSd0IpgPxncfW8uJbddx68dEcOq4o1eGIiPQpmcmiiqBzukslsDW+gLtvdfeL3P1Y4Mvhtsbw2FfcfaO7Rwmap+YlMdYh9ZdV27jrqY18+F1TuWBuavpKRET2RzKTxVJglplNN7M84DLg4fgCZlZhZl0xfIlgZFTXsWVm1lVdOIN9+zoOWm/u2M0XHljBMZNL+cr5R6Q6HBGRhCQtWYQ1guuBx4DVwG/d/TUzu8XM3h8WOx1Ya2ZvAOOAb4bHdhI0QS0xs1cJmrR+mqxYh0pLeyf/fN9LZGcbd15xrC51KiIHjaQO5nf3R4BHum27OW75QeDBXo59HJiTzPiGkrvz739cxdq3d/Lzjx5PZdmIVIckIpIwXVZtiPxmaYQHX6ri02fM0qyxInLQUbIYAqu2NHLzw69x6qwKbjhzVqrDERHZb0oWSdbY3ME//+olykfmcftlx5Kdldppz0VEDoQmIEqiWMz51weWs62xld988kRGj9R1skXk4KSaRRL9+KkN/G31dr686AjmTSlLdTgiIgdMySJJnt2wg+8+tpbz5kzgqpOmpTocEZEBUbJIgrebWvnMr19hesVIbrt4Dpbiy7OKiAyU+iwGWTBB4Mvsbuvkfz7xLl3lTkSGBX2TDbJv/2UNS9+q5/bL5mqCQBEZNtQMNYj+sqqanz79piYIFJFhR8likAQTBK7UBIEiMiwpWQwCTRAoIsOd+iwGgSYIFJHhTjWLAdqxq40HX6ri46dM1wSBIjJsKVkM0KbaZgBOnFme4khERJJHyWKAquqDZDFZzU8iMowpWQxQpC5IFuqrEJHhTMligDbXNTOmKJ/CPI2AEpHhq99kYWbXm5mmTO1FpK6FyWWFqQ5DRCSpEqlZjAeWmtlvzewc06x4+4jUNzN5tJqgRGR46zdZuPtXgFnA3cBHgXVm9p9mNjPJsaW9aGeM6sZWdW6LyLCXUJ+FuzuwLby23jYvAAATpUlEQVRFgTLgQTP7dhJjS3vVja10xpzJo9UMJSLDW79ncJvZZ4CrgB3Az4AvuHuHmWUB64AvJjfE9LU5HAmlZigRGe4Sme6jArjI3TfFb3T3mJmdn5ywDg5dw2bVDCUiw10izVCPAHVdK2ZWZGYnALj76mQFdjCI1DeTnWVMKClIdSgiIkmVSLL4b2BX3PrucFvGi9S1MLG0gJxsna4iIsNbIt9yFnZwA0HzE5qtFgiHzaoJSkQyQCLJYqOZfcbMcsPbDcDGZAd2MAhOyFOyEJHhL5FkcR1wErAFqAJOAK5NZlAHg+b2KDt2tTGlXMlCRIa/fpuT3H07cNkQxHJQqapvAaBSU32ISAZI5DyLAuAa4Ehgz7Afd/9YEuNKexGdYyEiGSSRZqhfEswP9V7gH0AlsDOZQR0MdI6FiGSSRJLFIe7+78Bud78HOA84Orlhpb9IfQuFudlUjMpLdSgiIkmXSLLoCO8bzOwooASYlsiDh7PUrjWz9WZ2Uw/7p5rZEjNbaWZPmlllt/3FZrbFzO5I5PmG0ua6ZiaPLkST8IpIJkgkWdwVXs/iK8DDwOvAbf0dZGbZwJ3AucBs4HIzm92t2HeBe919DnAL8K1u+79B0PSVdiJ1OsdCRDJHn8kinCywyd3r3f0pd5/h7mPd/ScJPPYCYL27b3T3duB+4IJuZWYDS8LlJ+L3m9lxwDjgrwm+liHj7lTVt6hzW0QyRp/JIjxb+/oDfOxJQCRuvSrcFm8FcHG4fCFQZGblYZL6HvCFvp7AzK41s2VmtqympuYAw9x/Dc0d7GqLatisiGSMRJqhHjezG81sspmN7rolcFxPjfnebf1GYKGZvQIsJDjxLwr8C/CIu0fog7vf5e7z3X3+mDFjEghpcETqNWxWRDJLInM8dZ1P8am4bQ7M6Oe4KmBy3HolsDW+gLtvBS4CMLNRwMXu3mhmJwKnmtm/AKOAPDPb5e7v6CRPhUhdcEKe+ixEJFMkcgb39AN87KXALDObTlBjuAy4Ir6AmVUAdWFz15eAxeFz/lNcmY8C89MlUUD8RY/UDCUimSGRM7g/0tN2d7+3r+PcPWpm1wOPAdnAYnd/zcxuAZa5+8PA6cC3zMyBp9i39pK2IvXNlI3IpaggN9WhiIgMiUSaoY6PWy4AzgReBvpMFgDu/gjBxZPit90ct/wg8GA/j/EL4BcJxDlkInXN6q8QkYySSDPUp+PXzayEYAqQjFVV38LsCcWpDkNEZMgcyCXemoFZgx3IwaIz5mypb6FS/RUikkES6bP4E3uHvGYRnEj322QGlc7ebmqlvTPGFDVDiUgGSaTP4rtxy1Fgk7tXJSmetKfZZkUkEyWSLDYD1e7eCmBmhWY2zd3fSmpkaSoSXvRIHdwikkkS6bN4AIjFrXeG2zJSpK4ZM5hYWtB/YRGRYSKRZJETTgQIQLicsRdxiNQ3M764gPyc7FSHIiIyZBJJFjVm9v6uFTO7ANiRvJDSm86xEJFMlEifxXXAr+IuQFQF9HhWdyaI1LVw8iEVqQ5DRGRIJXJS3gbgXeFEf+buGXv97bZoJ2/vbNWcUCKScfpthjKz/zSzUnff5e47zazMzP5jKIJLN1vqW3DXsFkRyTyJ9Fmc6+4NXSvuXg8sSl5I6UvDZkUkUyWSLLLNLL9rxcwKgfw+yg9bEU1NLiIZKpEO7vuAJWb283D9auCe5IWUviJ1zeRlZzGuSOdYiEhmSaSD+9tmthI4i+BSqX8BpiY7sHQUqW+msqyQrKyerhgrIjJ8JTrr7DaCs7gvJriexeqkRZTGInUtVKq/QkQyUK81CzM7lOBSqJcDtcBvCIbOvnuIYks7kfpm5lSWpDoMEZEh11cz1BrgaeB97r4ewMw+NyRRpaGm1g4amjs0EkpEMlJfzVAXEzQ/PWFmPzWzMwn6LDJS10goXcdCRDJRr8nC3R9y90uBw4Engc8B48zsv83s7CGKL21E6sJzLHRCnohkoH47uN19t7v/yt3PByqB5cBNSY8szVTV6xwLEclc+3UNbnevc/efuPsZyQooXUXqminKz6GkMDfVoYiIDLn9ShaZLFIfDJs1y9huGxHJYEoWCYrUNTO5TE1QIpKZlCwS4O5E6ps1EkpEMpaSRQJqdrXR2hHTORYikrGULBKwZ9isRkKJSIZSskjAnmGzOsdCRDKUkkUCus7erlSyEJEMpWSRgM11zYwpyqcwLzvVoYiIpISSRQIidS0aNisiGU3JIgGR+maNhBKRjKZk0Y9oZ4zqxlZ1botIRktqsjCzc8xsrZmtN7N3TD5oZlPNbImZrTSzJ82sMtw+18yeM7PXwn2XJjPOvlQ3ttIZcw2bFZGMlrRkYWbZwJ3AucBs4HIzm92t2HeBe919DnAL8K1wezPwEXc/EjgH+IGZlSYr1r5srtOwWRGRZNYsFgDr3X2ju7cD9wMXdCszG1gSLj/Rtd/d33D3deHyVmA7MCaJsfaqa9is+ixEJJMlM1lMAiJx61XhtngrCK7IB3AhUGRm5fEFzGwBkAdsSFKcfYrUN5OdZUwoKUjF04uIpIVkJoue5vL2bus3AgvN7BVgIbAFiO55ALMJwC+Bq9099o4nMLvWzJaZ2bKamprBizxOpK6FiaUF5GRrLICIZK5kfgNWAZPj1iuBrfEF3H2ru1/k7scCXw63NQKYWTHwv8BX3P35np7A3e9y9/nuPn/MmOS0UkXqm9VfISIZL5nJYikwy8ymm1kecBnwcHwBM6sws64YvgQsDrfnAQ8RdH4/kMQY+xWckKdkISKZLWnJwt2jwPXAY8Bq4Lfu/pqZ3WJm7w+LnQ6sNbM3gHHAN8PtHwJOAz5qZsvD29xkxdqb5vYoO3a1MaVcyUJEMltOMh/c3R8BHum27ea45QeBB3s47j7gvmTGloiq+mBq8kpN9SEiGU69tn3QsFkRkYCSRR8iOiFPRARQsuhTpL6FwtxsKkblpToUEZGUUrLow+a6ZirLCjHr6ZQREZHMoWTRh0hdM1PUXyEiomTRG3enqr5FndsiIihZ9KqhuYNdbVENmxURQcmiV5F6DZsVEemiZNGLSF1wQp6GzYqIKFn0as9Fj3SFPBERJYveROqbKRuRS1FBbqpDERFJOSWLXkTqmtVfISISUrLoRVW9piYXEemiZNGDzpizpb6FSvVXiIgAShY9eruplfbOmGoWIiIhJYsedM02q6k+REQCShY9iIQXPVIHt4hIQMmiB5G6ZsxgYmlBqkMREUkLShY9iNQ3M764gPyc7FSHIiKSFpQsehCpa1bntohIHCWLHkTqNDW5iEg8JYtu2qKdvL2zVXNCiYjEUbLoZkt9C+6abVZEJJ6SRTcaNisi8k5KFt1ENDW5iMg7KFl0E6lrJi87i3FFOsdCRKSLkkU3kfpmKssKycqyVIciIpI2lCy6idS1UKn+ChGRfShZdBOpb2ZymforRETiKVnEaWrtoKG5QyOhRES6UbKIs2cklM6xEBHZh5JFnEhdcI6FrmMhIrIvJYs4VfU6x0JEpCdKFnEidc0U5edQUpib6lBERNJKUpOFmZ1jZmvNbL2Z3dTD/qlmtsTMVprZk2ZWGbfvKjNbF96uSmacXSL1wbBZM51jISISL2nJwsyygTuBc4HZwOVmNrtbse8C97r7HOAW4FvhsaOBrwInAAuAr5pZWbJi7RJcx0JNUCIi3SWzZrEAWO/uG929HbgfuKBbmdnAknD5ibj97wUed/c6d68HHgfOSWKsuHtwjoU6t0VE3iGZyWISEIlbrwq3xVsBXBwuXwgUmVl5gsdiZtea2TIzW1ZTUzOgYGt2tdHaEdNIKBGRHiQzWfTU8O/d1m8EFprZK8BCYAsQTfBY3P0ud5/v7vPHjBkzoGC7hs1qJJSIyDvlJPGxq4DJceuVwNb4Au6+FbgIwMxGARe7e6OZVQGndzv2ySTGunfYrE7IExF5h2TWLJYCs8xsupnlAZcBD8cXMLMKM+uK4UvA4nD5MeBsMysLO7bPDrclTdfZ25VKFiIi75C0ZOHuUeB6gi/51cBv3f01M7vFzN4fFjsdWGtmbwDjgG+Gx9YB3yBIOEuBW8JtSbO5rpmKUfkU5mUn82lERA5KyWyGwt0fAR7ptu3muOUHgQd7OXYxe2saSRepa2GK+itERHqkM7hDGjYrItI7JQsg2hmjurFVndsiIr1QsgCqG1vpjLmGzYqI9ELJgqBzGzRsVkSkN0oWxF30SH0WIiI9UrIg6NzOzjImlBSkOhQRkbSkZEEwbHZiaQE52Xo7RER6om9HwmGz6q8QEemVkgVBzULJQkSkdxmfLJrbo+zY1aZhsyIifcj4ZNHS3sn7j5nInMrSVIciIpK2kjo31MGgfFQ+P7z82FSHISKS1jK+ZiEiIv1TshARkX4pWYiISL+ULEREpF9KFiIi0i8lCxER6ZeShYiI9EvJQkRE+mXunuoYBoWZ1QCbBvAQFcCOQQonGRTfwCi+gVF8A5PO8U119zH9FRo2yWKgzGyZu89PdRy9UXwDo/gGRvENTLrHlwg1Q4mISL+ULEREpF9KFnvdleoA+qH4BkbxDYziG5h0j69f6rMQEZF+qWYhIiL9UrIQEZF+ZVSyMLNzzGytma03s5t62J9vZr8J979gZtOGMLbJZvaEma02s9fM7IYeypxuZo1mtjy83TxU8cXF8JaZvRo+/7Ie9puZ/TB8D1ea2bwhjO2wuPdmuZk1mdlnu5UZ0vfQzBab2XYzWxW3bbSZPW5m68L7sl6OvSoss87MrhrC+L5jZmvCv99DZtbjZST7+19IYnxfM7MtcX/DRb0c2+fnPYnx/SYutrfMbHkvxyb9/RtU7p4RNyAb2ADMAPKAFcDsbmX+BfhxuHwZ8JshjG8CMC9cLgLe6CG+04E/p/h9fAuo6GP/IuBRwIB3AS+k8O+9jeCEo5S9h8BpwDxgVdy2bwM3hcs3Abf1cNxoYGN4XxYulw1RfGcDOeHybT3Fl8j/QhLj+xpwYwJ//z4/78mKr9v+7wE3p+r9G8xbJtUsFgDr3X2ju7cD9wMXdCtzAXBPuPwgcKaZ2VAE5+7V7v5yuLwTWA1MGornHmQXAPd64Hmg1MwmpCCOM4EN7j6Qs/oHzN2fAuq6bY7/P7sH+EAPh74XeNzd69y9HngcOGco4nP3v7p7NFx9Hqgc7OdNVC/vXyIS+bwPWF/xhd8dHwJ+PdjPmwqZlCwmAZG49Sre+WW8p0z4YWkEyockujhh89exwAs97D7RzFaY2aNmduSQBhZw4K9m9pKZXdvD/kTe56FwGb1/SFP9Ho5z92oIfiQAY3soky7v48cIaoo96e9/IZmuD5vJFvfSjJcO79+pwNvuvq6X/al8//ZbJiWLnmoI3ccNJ1ImqcxsFPA74LPu3tRt98sEzSrHAD8C/jCUsYVOdvd5wLnAp8zstG770+E9zAPeDzzQw+50eA8TkQ7v45eBKPCrXor097+QLP8NzATmAtUETT3dpfz9Ay6n71pFqt6/A5JJyaIKmBy3Xgls7a2MmeUAJRxYFfiAmFkuQaL4lbv/vvt+d29y913h8iNArplVDFV84fNuDe+3Aw8RVPfjJfI+J9u5wMvu/nb3HenwHgJvdzXNhffbeyiT0vcx7FA/H/gnDxvYu0vgfyEp3P1td+909xjw016eN9XvXw5wEfCb3sqk6v07UJmULJYCs8xsevjL8zLg4W5lHga6Rp1cAvy9tw/KYAvbN+8GVrv793spM76rD8XMFhD8/WqHIr7wOUeaWVHXMkFH6KpuxR4GPhKOinoX0NjV5DKEev1Fl+r3MBT/f3YV8MceyjwGnG1mZWEzy9nhtqQzs3OAfwPe7+7NvZRJ5H8hWfHF94Fd2MvzJvJ5T6azgDXuXtXTzlS+fwcs1T3sQ3kjGKnzBsEoiS+H224h+FAAFBA0XawHXgRmDGFspxBUk1cCy8PbIuA64LqwzPXAawQjO54HThri929G+Nwrwji63sP4GA24M3yPXwXmD3GMIwi+/EvitqXsPSRIWtVAB8Gv3WsI+sGWAOvC+9Fh2fnAz+KO/Vj4v7geuHoI41tP0N7f9X/YNUJwIvBIX/8LQxTfL8P/rZUECWBC9/jC9Xd83ocivnD7L7r+5+LKDvn7N5g3TfchIiL9yqRmKBEROUBKFiIi0i8lCxER6ZeShYiI9EvJQkRE+qVkIbIfzKyz28y2gzabqZlNi5+9VCSd5KQ6AJGDTIu7z011ECJDTTULkUEQXpvgNjN7MbwdEm6famZLwknvlpjZlHD7uPBaESvC20nhQ2Wb2U8tuKbJX82sMGUvSiSOkoXI/ins1gx1ady+JndfANwB/CDcdgfBlO1zCCbk+2G4/YfAPzyY0HAewVm8ALOAO939SKABuDjJr0ckITqDW2Q/mNkudx/Vw/a3gDPcfWM4IeQ2dy83sx0E01F0hNur3b3CzGqASndvi3uMaQTXsJgVrv8bkOvu/5H8VybSN9UsRAaP97LcW5metMUtd6J+RUkTShYig+fSuPvnwuVnCWY8Bfgn4JlweQnwzwBmlm1mxUMVpMiB0K8Wkf1TaGbL49b/4u5dw2fzzewFgh9hl4fbPgMsNrMvADXA1eH2G4C7zOwaghrEPxPMXiqSltRnITIIwj6L+e6+I9WxiCSDmqFERKRfqlmIiEi/VLMQEZF+KVmIiEi/lCxERKRfShYiItIvJQsREenX/wfGSaC11pTXkQAAAABJRU5ErkJggg==\n", 273 | "text/plain": [ 274 | "
" 275 | ] 276 | }, 277 | "metadata": { 278 | "needs_background": "light" 279 | }, 280 | "output_type": "display_data" 281 | } 282 | ], 283 | "source": [ 284 | "model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(), metrics=['acc'])\n", 285 | "\n", 286 | "# Train model for a given number of epochs\n", 287 | "history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test))\n", 288 | "\n", 289 | "# Evaluate model against test data\n", 290 | "score = model.evaluate(x_test, y_test, verbose=0)\n", 291 | "print('Test loss:', score[0])\n", 292 | "print('Test accuracy:', score[1])\n", 293 | "\n", 294 | "# summarize history for accuracy\n", 295 | "plt.plot(history.history['acc'])\n", 296 | "plt.plot(history.history['val_acc'])\n", 297 | "plt.title('Model accuracy')\n", 298 | "plt.ylabel('Accuracy')\n", 299 | "plt.xlabel('Epoch')\n", 300 | "plt.legend(['Train', 'Test'], loc='upper left')\n", 301 | "plt.show()" 302 | ] 303 | }, 304 | { 305 | "cell_type": "markdown", 306 | "metadata": {}, 307 | "source": [ 308 | "Save model structure and trained weights/biases to separate files.\n", 309 | "\n", 310 | "These files will be used to restore the trained model at prediction time." 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": 9, 316 | "metadata": {}, 317 | "outputs": [], 318 | "source": [ 319 | "model_structure = model.to_json()\n", 320 | "with open(\"model.json\", \"w\") as json_file:\n", 321 | " json_file.write(model_structure)\n", 322 | "model.save_weights(\"weights.h5\")" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": null, 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [] 331 | } 332 | ], 333 | "metadata": { 334 | "anaconda-cloud": {}, 335 | "kernelspec": { 336 | "display_name": "Python 3", 337 | "language": "python", 338 | "name": "python3" 339 | }, 340 | "language_info": { 341 | "codemirror_mode": { 342 | "name": "ipython", 343 | "version": 3 344 | }, 345 | "file_extension": ".py", 346 | "mimetype": "text/x-python", 347 | "name": "python", 348 | "nbconvert_exporter": "python", 349 | "pygments_lexer": "ipython3", 350 | "version": "3.6.8" 351 | } 352 | }, 353 | "nbformat": 4, 354 | "nbformat_minor": 1 355 | } 356 | -------------------------------------------------------------------------------- /MNIST/model.json: -------------------------------------------------------------------------------- 1 | {"class_name": "Sequential", "config": {"name": "sequential_1", "layers": [{"class_name": "Flatten", "config": {"name": "flatten_1", "trainable": true, "batch_input_shape": [null, 28, 28], "dtype": "float32", "data_format": "channels_last"}}, {"class_name": "Dense", "config": {"name": "dense_1", "trainable": true, "units": 512, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Dropout", "config": {"name": "dropout_1", "trainable": true, "rate": 0.5, "noise_shape": null, "seed": null}}, {"class_name": "Dense", "config": {"name": "dense_2", "trainable": true, "units": 512, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Dropout", "config": {"name": "dropout_2", "trainable": true, "rate": 0.5, "noise_shape": null, "seed": null}}, {"class_name": "Dense", "config": {"name": "dense_3", "trainable": true, "units": 10, "activation": "softmax", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}]}, "keras_version": "2.2.4", "backend": "tensorflow"} -------------------------------------------------------------------------------- /MNIST/model_cnn.json: -------------------------------------------------------------------------------- 1 | {"class_name": "Sequential", "config": {"name": "sequential_1", "layers": [{"class_name": "Conv2D", "config": {"name": "conv2d_1", "trainable": true, "batch_input_shape": [null, 28, 28, 1], "dtype": "float32", "filters": 32, "kernel_size": [3, 3], "strides": [1, 1], "padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1], "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Conv2D", "config": {"name": "conv2d_2", "trainable": true, "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1], "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_1", "trainable": true, "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}}, {"class_name": "Dropout", "config": {"name": "dropout_1", "trainable": true, "rate": 0.25, "noise_shape": null, "seed": null}}, {"class_name": "Flatten", "config": {"name": "flatten_1", "trainable": true, "data_format": "channels_last"}}, {"class_name": "Dense", "config": {"name": "dense_1", "trainable": true, "units": 128, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Dropout", "config": {"name": "dropout_2", "trainable": true, "rate": 0.5, "noise_shape": null, "seed": null}}, {"class_name": "Dense", "config": {"name": "dense_2", "trainable": true, "units": 10, "activation": "softmax", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}]}, "keras_version": "2.2.4", "backend": "tensorflow"} -------------------------------------------------------------------------------- /MNIST/weights.h5: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/MNIST/weights.h5 -------------------------------------------------------------------------------- /MNIST/weights_cnn.h5: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/MNIST/weights_cnn.h5 -------------------------------------------------------------------------------- /Notebooks/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | model.json 3 | weights.h5 4 | -------------------------------------------------------------------------------- /Notebooks/Jupyter Notebook.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Jupyter Notebook\n", 8 | "\n", 9 | "[Jupyter Notebook](https://jupyter.org) is an open-source web application that is widely used by data scientists and machine learning practitioners. Jupyter has a rich user interface to create formatted text, add images, high quality math markup, as well as live code in a variety of languages, including Python. Code within a notebook can produce rich, high quality output such as images, video, audio, and custom MIME types. Jupyter is designed to be interactive, which is particularly useful for data science and machine learning.\n", 10 | "\n", 11 | "Jupyter can be installed locally, or accessed through a variety of cloud services, such as [Google Colab](https://colab.research.google.com/), [Amazon Sagemaker](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html), [Microsoft Azure](https://notebooks.azure.com/), [IBM Watson](https://dataplatform.cloud.ibm.com/docs/content/wsj/analyze-data/notebooks-parent.html) and many others." 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "## Cells\n", 19 | "\n", 20 | "Notebooks have cells that can contain text, code, images, and more. Text cells can contain formatted text using [markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) syntax, which is lightweight and easy to learn. You can edit a cell by double-clicking.\n", 21 | "\n", 22 | "You can create headings, links, add emphasis with *italics*, **bold**, ~~strikethrough.~~, or syntax highlighted code:\n", 23 | "\n", 24 | "```python\n", 25 | "for i in range(10):\n", 26 | " print(i)\n", 27 | "```\n", 28 | "\n", 29 | "You can add images:\n", 30 | "\n", 31 | "![Hughes 500, Honolulu, HI](https://madhu.com/images/h500.gif \"Hughes 500, Honolulu, HI\")\n", 32 | "\n", 33 | "You can create lists:\n", 34 | "\n", 35 | "1. This\n", 36 | "2. That\n", 37 | "3. The other thing\n", 38 | "\n", 39 | "Or tables:\n", 40 | "\n", 41 | "| Name | Instrument |\n", 42 | "|-------------------|---------------|\n", 43 | "| David St. Hubbins | Rhythm guitar |\n", 44 | "| Nigel Tufnel | Lead guitar |\n", 45 | "| Derek Smalls | Bass |\n", 46 | "| TBD | Drums |" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## Code Cells\n", 54 | "\n", 55 | "Below are some code cell that you can run inside this notebook." 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 1, 61 | "metadata": {}, 62 | "outputs": [ 63 | { 64 | "name": "stdout", 65 | "output_type": "stream", 66 | "text": [ 67 | "My first notebook!\n" 68 | ] 69 | } 70 | ], 71 | "source": [ 72 | "print('My first notebook!')" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 2, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "def multiplicationTable(start, end):\n", 82 | " line = ' '\n", 83 | " for i in range(start, end):\n", 84 | " line = '%s %2d ' % (line, i)\n", 85 | " print(line)\n", 86 | " for i in range(start, end):\n", 87 | " line = '%2d ' % i\n", 88 | " for j in range(start, end):\n", 89 | " line = '%s %2d ' % (line, i*j)\n", 90 | " print(line)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 3, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | " 1 2 3 4 5 6 7 8 9 \n", 103 | " 1 1 2 3 4 5 6 7 8 9 \n", 104 | " 2 2 4 6 8 10 12 14 16 18 \n", 105 | " 3 3 6 9 12 15 18 21 24 27 \n", 106 | " 4 4 8 12 16 20 24 28 32 36 \n", 107 | " 5 5 10 15 20 25 30 35 40 45 \n", 108 | " 6 6 12 18 24 30 36 42 48 54 \n", 109 | " 7 7 14 21 28 35 42 49 56 63 \n", 110 | " 8 8 16 24 32 40 48 56 64 72 \n", 111 | " 9 9 18 27 36 45 54 63 72 81 \n" 112 | ] 113 | } 114 | ], 115 | "source": [ 116 | "multiplicationTable(1, 10)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "## Visualizations\n", 124 | "\n", 125 | "Code can produce a variety of content." 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 5, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "data": { 135 | "image/png": "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\n", 136 | "text/plain": [ 137 | "
" 138 | ] 139 | }, 140 | "metadata": { 141 | "needs_background": "light" 142 | }, 143 | "output_type": "display_data" 144 | } 145 | ], 146 | "source": [ 147 | "import math\n", 148 | "import matplotlib.pyplot as plt\n", 149 | "\n", 150 | "x = [0.1*i for i in range(64)]\n", 151 | "sin = [math.sin(i) for i in x]\n", 152 | "cos = [math.cos(i) for i in x]\n", 153 | "\n", 154 | "plt.plot(x, sin, label='sin(x)', color='blue', linewidth=2.5)\n", 155 | "plt.plot(x, cos, label='cos(x)', color='red', linewidth=0.5)\n", 156 | "plt.ylabel('y')\n", 157 | "plt.xlabel('x')\n", 158 | "plt.legend(loc='upper right')\n", 159 | "plt.show()" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "## Math Notation\n", 167 | "\n", 168 | "Jupyter renders high quality math notation using [LaTeX](https://en.wikibooks.org/wiki/LaTeX/Mathematics) syntax. Here are some examples:\n", 169 | "\n", 170 | "$$ \\epsilon = \\frac{1}{m} \\sum_{i=1}^{m} (a x_i + b - y_i)^2$$\n", 171 | "\n", 172 | "$$e^{i x} = cos x + i sin x$$\n", 173 | "\n", 174 | "$$ \\begin{bmatrix}\n", 175 | "a \\\\\n", 176 | "b\n", 177 | "\\end{bmatrix} = (A^T A)^{-1} A^T y$$" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "## Magic Commands\n", 185 | "\n", 186 | "Jupyter supports a number of **magic commands**. These commands can appear in code cells and perform special operations.\n", 187 | "\n", 188 | "Below are a few magic commands, a more complete list is documented [here](https://ipython.readthedocs.io/en/stable/interactive/magics.html).\n", 189 | "\n", 190 | "* ```%system ``` or ```!```\n", 191 | " * Executes a system command\n", 192 | "* ```%run [arguments]```\n", 193 | " * Executes a python program\n", 194 | "* ```%time```\n", 195 | " * Time execution of a cell\n", 196 | "* ```%whos```\n", 197 | " * List all interactive variables\n", 198 | "* ```%load or ```\n", 199 | " * Loads this cell with contents of or a " 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "## Local Installation\n", 207 | "\n", 208 | "Jupyter can be installed locally. There are several ways to install Jupyter notebooks. If you have Python installed, you can install using pip:\n", 209 | "\n", 210 | "```> pip install notebook```\n", 211 | "\n", 212 | "To start a notebook server, execute the following command from a terminal (Mac/Unix) or command prompt (Windows):\n", 213 | "\n", 214 | "```jupyter notebook```\n", 215 | "\n", 216 | "Alternatively, you can install [Anaconda Python](https://www.anaconda.com/distribution), which includes Jupyter notebook. Anaconda Python for Windows adds Jupyter Notebook shortcuts to the start menu." 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": null, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [] 225 | } 226 | ], 227 | "metadata": { 228 | "kernelspec": { 229 | "display_name": "Python 3", 230 | "language": "python", 231 | "name": "python3" 232 | }, 233 | "language_info": { 234 | "codemirror_mode": { 235 | "name": "ipython", 236 | "version": 3 237 | }, 238 | "file_extension": ".py", 239 | "mimetype": "text/x-python", 240 | "name": "python", 241 | "nbconvert_exporter": "python", 242 | "pygments_lexer": "ipython3", 243 | "version": "3.6.8" 244 | } 245 | }, 246 | "nbformat": 4, 247 | "nbformat_minor": 2 248 | } 249 | -------------------------------------------------------------------------------- /Notebooks/Python_Quick_Start.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "2EQ3aMz5KrjT" 8 | }, 9 | "source": [ 10 | "# Python Quick Start\n", 11 | "\n", 12 | "Python is a popular programming language used for many applications. Interestingly, it is widely used for machine learning. This is due in part to it's simple syntax, interactive nature, and numerous machine learning libraries. It's easy to quickly test things out, which is important during data analysis or model development.\n", 13 | "\n", 14 | "We will focus on Python 3 here." 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": { 20 | "colab_type": "text", 21 | "id": "HHHYgpbFL4-N" 22 | }, 23 | "source": [ 24 | "## Basic Syntax\n", 25 | "\n", 26 | "[Data types](https://docs.python.org/3.4/reference/datamodel.html), [operators](https://docs.python.org/3.4/library/operator.html), and variables. Python is interactive, so we can try things out by just entering code and running it in this notebook." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": null, 32 | "metadata": { 33 | "colab": {}, 34 | "colab_type": "code", 35 | "id": "e8wn727POHDT" 36 | }, 37 | "outputs": [], 38 | "source": [ 39 | "# Numbers, e.g. int, float, bool, complex\n", 40 | "\n", 41 | "11" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": { 48 | "colab": {}, 49 | "colab_type": "code", 50 | "id": "RPm4AG4kbEw0" 51 | }, 52 | "outputs": [], 53 | "source": [ 54 | "3.1415926535897" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": { 61 | "colab": {}, 62 | "colab_type": "code", 63 | "id": "bE7teAo0bIPE" 64 | }, 65 | "outputs": [], 66 | "source": [ 67 | "True" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": { 74 | "colab": {}, 75 | "colab_type": "code", 76 | "id": "qGOImoA2bKHa" 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "# Complex or imaginary numbers\n", 81 | "\n", 82 | "1+2j" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": { 89 | "colab": {}, 90 | "colab_type": "code", 91 | "id": "IzEjfhsSG5MP" 92 | }, 93 | "outputs": [], 94 | "source": [ 95 | "# None is similar to null on other languages\n", 96 | "\n", 97 | "a = None\n", 98 | "print(a)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": null, 104 | "metadata": { 105 | "colab": {}, 106 | "colab_type": "code", 107 | "id": "3bGPFjxJUjla" 108 | }, 109 | "outputs": [], 110 | "source": [ 111 | "# type() can tell us the type of a variable\n", 112 | "\n", 113 | "a = 12.0\n", 114 | "type(a)" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": { 121 | "colab": {}, 122 | "colab_type": "code", 123 | "id": "6J9HxRECRiDi" 124 | }, 125 | "outputs": [], 126 | "source": [ 127 | "# Strings can be defined with single or double quotes\n", 128 | "\n", 129 | "'This is a string'" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": { 136 | "colab": {}, 137 | "colab_type": "code", 138 | "id": "6iel--V5Rod7" 139 | }, 140 | "outputs": [], 141 | "source": [ 142 | "\"This is also a string\"" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": null, 148 | "metadata": { 149 | "colab": {}, 150 | "colab_type": "code", 151 | "id": "DkCP-uPTRsO4" 152 | }, 153 | "outputs": [], 154 | "source": [ 155 | "# Get the length of a string\n", 156 | "\n", 157 | "len('some string')" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": { 164 | "colab": {}, 165 | "colab_type": "code", 166 | "id": "vGnLAm1OR1L6" 167 | }, 168 | "outputs": [], 169 | "source": [ 170 | "# Select a character within a string\n", 171 | "\n", 172 | "a = 'some string'\n", 173 | "a[0]" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": { 180 | "colab": {}, 181 | "colab_type": "code", 182 | "id": "OwtwX0K6SgVz" 183 | }, 184 | "outputs": [], 185 | "source": [ 186 | "# Python checks array bounds\n", 187 | "\n", 188 | "a = 'some string'\n", 189 | "# a[20]" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": { 196 | "colab": {}, 197 | "colab_type": "code", 198 | "id": "xKZ3jhLISNzA" 199 | }, 200 | "outputs": [], 201 | "source": [ 202 | "# Negative indexes select from the end\n", 203 | "\n", 204 | "a = 'some string'\n", 205 | "a[-1]" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": { 212 | "colab": {}, 213 | "colab_type": "code", 214 | "id": "Osb-GVD7SBHh" 215 | }, 216 | "outputs": [], 217 | "source": [ 218 | "# Select a range of characters, uses a left closed, right open interval\n", 219 | "\n", 220 | "a = 'some string'\n", 221 | "a[0:5]" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": { 228 | "colab": {}, 229 | "colab_type": "code", 230 | "id": "14ciHg-BSava" 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "# Negative index work with ranges also\n", 235 | "\n", 236 | "a = 'some string'\n", 237 | "a[5:-2]" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": { 243 | "colab_type": "text", 244 | "id": "Kd3FLpHXaT2N" 245 | }, 246 | "source": [ 247 | "### String formatting\n", 248 | "\n", 249 | "Python supports multiple styles of string formatting:\n", 250 | "\n", 251 | "\n", 252 | "* [printf](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting)\n", 253 | "* [format()](https://docs.python.org/3.4/library/string.html#formatspec)\n", 254 | "\n" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": null, 260 | "metadata": { 261 | "colab": {}, 262 | "colab_type": "code", 263 | "id": "AVtaLbChTXc2" 264 | }, 265 | "outputs": [], 266 | "source": [ 267 | "# printf style formatting\n", 268 | "\n", 269 | "answer = 42\n", 270 | "'The answer to the ultimate question of life, the universe, and everything is %d' % answer" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [ 279 | "# multiple values\n", 280 | "\n", 281 | "length = 8.0\n", 282 | "width = 4.0\n", 283 | "'The dimensions are %.2f feet long and %.2f feet wide' % (length, width)" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [ 292 | "# format(...) method\n", 293 | "\n", 294 | "answer = 42\n", 295 | "'The answer to the ultimate question of life, the universe, and everything is {0:d}'.format(answer)" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [ 304 | "# named values\n", 305 | "\n", 306 | "length = 8.0\n", 307 | "width = 4.0\n", 308 | "'The dimensions are {length:.2f} feet long and {width:.2f} feet wide'.format(width=width, length=length)" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": { 314 | "colab_type": "text", 315 | "id": "5m4XM7qjWfJo" 316 | }, 317 | "source": [ 318 | "### Type Conversion" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": { 325 | "colab": {}, 326 | "colab_type": "code", 327 | "id": "JMzoX-ipWkcA" 328 | }, 329 | "outputs": [], 330 | "source": [ 331 | "pi = 3.1415926535897\n", 332 | "type(pi)" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": null, 338 | "metadata": { 339 | "colab": {}, 340 | "colab_type": "code", 341 | "id": "0BBZv2o4Wu6g" 342 | }, 343 | "outputs": [], 344 | "source": [ 345 | "int(pi)" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": null, 351 | "metadata": { 352 | "colab": {}, 353 | "colab_type": "code", 354 | "id": "FzbZ1NQ4W-Xg" 355 | }, 356 | "outputs": [], 357 | "source": [ 358 | "complex(pi)" 359 | ] 360 | }, 361 | { 362 | "cell_type": "code", 363 | "execution_count": null, 364 | "metadata": { 365 | "colab": {}, 366 | "colab_type": "code", 367 | "id": "4avOgb6iWxrx" 368 | }, 369 | "outputs": [], 370 | "source": [ 371 | "int('42')" 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": null, 377 | "metadata": { 378 | "colab": {}, 379 | "colab_type": "code", 380 | "id": "bSgBvoNeW3hJ" 381 | }, 382 | "outputs": [], 383 | "source": [ 384 | "str(42)" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": { 391 | "colab": {}, 392 | "colab_type": "code", 393 | "id": "epmKkhMIGo8I" 394 | }, 395 | "outputs": [], 396 | "source": [ 397 | "bool(0)" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "## Flow Control\n", 405 | "\n", 406 | "Spaces or tabs are used to group statements together. Unlike many languages today, whitespace is significant in Python." 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": null, 412 | "metadata": {}, 413 | "outputs": [], 414 | "source": [ 415 | "for i in range(5):\n", 416 | " print('%d, squared: %d' % (i, i*i))" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": null, 422 | "metadata": {}, 423 | "outputs": [], 424 | "source": [ 425 | "i = 0\n", 426 | "while i < 5:\n", 427 | " print('%d, squared: %d' % (i, i*i))\n", 428 | " i = i + 1" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": null, 434 | "metadata": {}, 435 | "outputs": [], 436 | "source": [ 437 | "for i in range(1, 10):\n", 438 | " if i % 2 == 0:\n", 439 | " print('%d is divisible by two' % (i))\n", 440 | " elif i % 3 == 0:\n", 441 | " print('%d is divisible by three' % (i))\n", 442 | " else:\n", 443 | " print('%d is not divisible by two or three' % (i))" 444 | ] 445 | }, 446 | { 447 | "cell_type": "markdown", 448 | "metadata": { 449 | "colab_type": "text", 450 | "id": "MiNZ8-THMGaQ" 451 | }, 452 | "source": [ 453 | "## Data Structures\n", 454 | "\n", 455 | "### Lists\n", 456 | "\n", 457 | "Lists contain any number of ordered values." 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": null, 463 | "metadata": { 464 | "colab": {}, 465 | "colab_type": "code", 466 | "id": "n6zfxlBYQwqc" 467 | }, 468 | "outputs": [], 469 | "source": [ 470 | "[1, 2, 3]" 471 | ] 472 | }, 473 | { 474 | "cell_type": "code", 475 | "execution_count": null, 476 | "metadata": { 477 | "colab": {}, 478 | "colab_type": "code", 479 | "id": "wgIvI40zQ2iJ" 480 | }, 481 | "outputs": [], 482 | "source": [ 483 | "a = [1, 2, 3]\n", 484 | "len(a)" 485 | ] 486 | }, 487 | { 488 | "cell_type": "code", 489 | "execution_count": null, 490 | "metadata": {}, 491 | "outputs": [], 492 | "source": [ 493 | "# Iterate through a list\n", 494 | "\n", 495 | "for value in a:\n", 496 | " print('Value is %d' % value)" 497 | ] 498 | }, 499 | { 500 | "cell_type": "code", 501 | "execution_count": null, 502 | "metadata": {}, 503 | "outputs": [], 504 | "source": [ 505 | "a = [1, 2, 3]\n", 506 | "a.append(4)\n", 507 | "a" 508 | ] 509 | }, 510 | { 511 | "cell_type": "code", 512 | "execution_count": null, 513 | "metadata": { 514 | "colab": {}, 515 | "colab_type": "code", 516 | "id": "33i5smW9HadB" 517 | }, 518 | "outputs": [], 519 | "source": [ 520 | "# Add two lists\n", 521 | "\n", 522 | "a = [1, 2, 3]\n", 523 | "b = [7, 8, 9]\n", 524 | "\n", 525 | "a+b" 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": null, 531 | "metadata": { 532 | "colab": {}, 533 | "colab_type": "code", 534 | "id": "sN4Oe48mHkkw" 535 | }, 536 | "outputs": [], 537 | "source": [ 538 | "# List comprehension\n", 539 | "\n", 540 | "a = [2*i for i in range(10)]\n", 541 | "a" 542 | ] 543 | }, 544 | { 545 | "cell_type": "code", 546 | "execution_count": null, 547 | "metadata": { 548 | "colab": {}, 549 | "colab_type": "code", 550 | "id": "4C1d30LxHsK4" 551 | }, 552 | "outputs": [], 553 | "source": [ 554 | "# Reverse a list\n", 555 | "\n", 556 | "a = [2*i for i in range(10)]\n", 557 | "a.reverse()\n", 558 | "a" 559 | ] 560 | }, 561 | { 562 | "cell_type": "code", 563 | "execution_count": null, 564 | "metadata": { 565 | "colab": {}, 566 | "colab_type": "code", 567 | "id": "SSERRxx8Ic4c" 568 | }, 569 | "outputs": [], 570 | "source": [ 571 | "a.sort()\n", 572 | "a" 573 | ] 574 | }, 575 | { 576 | "cell_type": "markdown", 577 | "metadata": {}, 578 | "source": [ 579 | "### Dictionaries\n", 580 | "\n", 581 | "Dictionaries contain key-value pairs. Similar to Java HashMap." 582 | ] 583 | }, 584 | { 585 | "cell_type": "code", 586 | "execution_count": null, 587 | "metadata": {}, 588 | "outputs": [], 589 | "source": [ 590 | "band = { 'David St. Hubbins':'Rhythm Guitar', 'Nigel Tufnel':'Lead Guitar', 'Derek Smalls':'Bass', 'Drums':'Unknown' }\n", 591 | "band" 592 | ] 593 | }, 594 | { 595 | "cell_type": "code", 596 | "execution_count": null, 597 | "metadata": {}, 598 | "outputs": [], 599 | "source": [ 600 | "for name in band:\n", 601 | " print('Name: %s, instrument: %s' % (name, band[name]))" 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": null, 607 | "metadata": {}, 608 | "outputs": [], 609 | "source": [ 610 | "for name, instrument in band.items():\n", 611 | " print('Name: %s, instrument: %s' % (name, instrument))" 612 | ] 613 | }, 614 | { 615 | "cell_type": "code", 616 | "execution_count": null, 617 | "metadata": {}, 618 | "outputs": [], 619 | "source": [ 620 | "band['Drums'] = 'John \"Stumpy\" Pepys'\n", 621 | "\n", 622 | "for name in band:\n", 623 | " print('Name: %s, instrument: %s' % (name, band[name]))" 624 | ] 625 | }, 626 | { 627 | "cell_type": "markdown", 628 | "metadata": { 629 | "colab_type": "text", 630 | "id": "zH7zPFeoMCU6" 631 | }, 632 | "source": [ 633 | "## Functions and Methods\n", 634 | "\n", 635 | "Functions and methods are similar, but differ slightly." 636 | ] 637 | }, 638 | { 639 | "cell_type": "code", 640 | "execution_count": null, 641 | "metadata": { 642 | "colab": {}, 643 | "colab_type": "code", 644 | "id": "2BS31fldUKDz" 645 | }, 646 | "outputs": [], 647 | "source": [ 648 | "# len() is a method\n", 649 | "\n", 650 | "a = 'some string'\n", 651 | "len(a)" 652 | ] 653 | }, 654 | { 655 | "cell_type": "code", 656 | "execution_count": null, 657 | "metadata": { 658 | "colab": {}, 659 | "colab_type": "code", 660 | "id": "bL_N3deVUQWK" 661 | }, 662 | "outputs": [], 663 | "source": [ 664 | "# upper() is a method\n", 665 | "\n", 666 | "a = 'some string'\n", 667 | "a.upper()" 668 | ] 669 | }, 670 | { 671 | "cell_type": "code", 672 | "execution_count": null, 673 | "metadata": { 674 | "colab": {}, 675 | "colab_type": "code", 676 | "id": "e2ps7j1TUe4Z" 677 | }, 678 | "outputs": [], 679 | "source": [ 680 | "# dir() lists attributes and methods of an object\n", 681 | "\n", 682 | "a = 'some string'\n", 683 | "dir(a)" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": null, 689 | "metadata": { 690 | "colab": {}, 691 | "colab_type": "code", 692 | "id": "pVXM5ZACVhnT" 693 | }, 694 | "outputs": [], 695 | "source": [ 696 | "# Use def to define a function\n", 697 | "\n", 698 | "def average(array):\n", 699 | " n = len(array)\n", 700 | " total = 0.0\n", 701 | " for a in array:\n", 702 | " total = total + a\n", 703 | " return total / n\n", 704 | "\n", 705 | "average([1, 2, 3])" 706 | ] 707 | }, 708 | { 709 | "cell_type": "code", 710 | "execution_count": null, 711 | "metadata": { 712 | "colab": {}, 713 | "colab_type": "code", 714 | "id": "bSC0VjeDXNXY" 715 | }, 716 | "outputs": [], 717 | "source": [ 718 | "# Functions can return tuples\n", 719 | "\n", 720 | "def statistics(array):\n", 721 | " avg = average(array)\n", 722 | " n = len(array)\n", 723 | " total = 0.0\n", 724 | " for a in array:\n", 725 | " variance = a - avg\n", 726 | " total += variance ** 2\n", 727 | " stddev = total / n\n", 728 | " return (avg, stddev)\n", 729 | "\n", 730 | "statistics([1, 2, 3])" 731 | ] 732 | }, 733 | { 734 | "cell_type": "code", 735 | "execution_count": null, 736 | "metadata": { 737 | "colab": {}, 738 | "colab_type": "code", 739 | "id": "6NbDMklxX-hs" 740 | }, 741 | "outputs": [], 742 | "source": [ 743 | "# Assign to a tuple\n", 744 | "\n", 745 | "(avg, stddev) = statistics([1, 2, 3])\n", 746 | "print('The average is %.2f and the standard deviation is %.2f' % (avg, stddev))" 747 | ] 748 | }, 749 | { 750 | "cell_type": "markdown", 751 | "metadata": { 752 | "colab_type": "text", 753 | "id": "6D7CKgOPQSzF" 754 | }, 755 | "source": [ 756 | "## Classes\n", 757 | "\n", 758 | "Use the class keyword to define classses." 759 | ] 760 | }, 761 | { 762 | "cell_type": "code", 763 | "execution_count": null, 764 | "metadata": { 765 | "colab": {}, 766 | "colab_type": "code", 767 | "id": "9ztIx4IjKqvW" 768 | }, 769 | "outputs": [], 770 | "source": [ 771 | "class BankAccount(object):\n", 772 | " def __init__(self, accountNumber, initialBalance, interestRate):\n", 773 | " self.accountNumber = accountNumber\n", 774 | " self.balance = initialBalance\n", 775 | " self.interestRate = interestRate\n", 776 | " \n", 777 | " def deposit(self, amount):\n", 778 | " self.balance += amount\n", 779 | " \n", 780 | " def withdraw(self, amount):\n", 781 | " if self.balance >= amount:\n", 782 | " self.balance -= amount\n", 783 | " return amount\n", 784 | " raise Exception('Insufficient balance for withdrawal: only %.2f in account %d' % (self.balance, self.accountNumber))\n", 785 | " \n", 786 | " def addInterest(self):\n", 787 | " self.balance *= 1.0 + self.interestRate/100.0\n", 788 | " \n", 789 | " def transferTo(self, otherAccount, amount):\n", 790 | " otherAccount.deposit(self.withdraw(amount))\n", 791 | " \n", 792 | " def __str__(self):\n", 793 | " return 'Account %d, balance: %.2f' % (self.accountNumber, self.balance)" 794 | ] 795 | }, 796 | { 797 | "cell_type": "code", 798 | "execution_count": null, 799 | "metadata": { 800 | "colab": {}, 801 | "colab_type": "code", 802 | "id": "RR7vPMAtDh-7" 803 | }, 804 | "outputs": [], 805 | "source": [ 806 | "checking = BankAccount(101, 100.0, 1.0)\n", 807 | "savings = BankAccount(201, 1000.0, 5.0)\n", 808 | "\n", 809 | "print(checking)\n", 810 | "print(savings)\n", 811 | "checking.addInterest()\n", 812 | "savings.addInterest()\n", 813 | "\n", 814 | "savings.transferTo(checking, 500)\n", 815 | "\n", 816 | "print(checking)\n", 817 | "print(savings)\n", 818 | "\n", 819 | "# savings.transferTo(checking, 1000)" 820 | ] 821 | }, 822 | { 823 | "cell_type": "markdown", 824 | "metadata": { 825 | "colab_type": "text", 826 | "id": "URDoWEMQJEdg" 827 | }, 828 | "source": [ 829 | "## Reading and Writing files" 830 | ] 831 | }, 832 | { 833 | "cell_type": "code", 834 | "execution_count": null, 835 | "metadata": { 836 | "colab": {}, 837 | "colab_type": "code", 838 | "id": "A_v0ZAX6JIwf" 839 | }, 840 | "outputs": [], 841 | "source": [ 842 | "# Write a file, 'w' opens a file for writing, 'a' appends to an existing file\n", 843 | "\n", 844 | "with open('somefile.txt', 'w') as f:\n", 845 | " f.write('First line\\n')\n", 846 | " f.write('Second line\\n')" 847 | ] 848 | }, 849 | { 850 | "cell_type": "code", 851 | "execution_count": null, 852 | "metadata": { 853 | "colab": {}, 854 | "colab_type": "code", 855 | "id": "jx3mqmASJt_X" 856 | }, 857 | "outputs": [], 858 | "source": [ 859 | "# strip() removes the trailing \\n\n", 860 | "\n", 861 | "with open('somefile.txt') as f:\n", 862 | " print(f.readline().strip())" 863 | ] 864 | }, 865 | { 866 | "cell_type": "code", 867 | "execution_count": null, 868 | "metadata": { 869 | "colab": {}, 870 | "colab_type": "code", 871 | "id": "k2lTneQUKRfD" 872 | }, 873 | "outputs": [], 874 | "source": [ 875 | "with open('somefile.txt') as f:\n", 876 | " print(f.readlines())" 877 | ] 878 | }, 879 | { 880 | "cell_type": "markdown", 881 | "metadata": { 882 | "colab_type": "text", 883 | "id": "cxv30sH9bm4N" 884 | }, 885 | "source": [ 886 | "## Modules\n", 887 | "\n", 888 | "[import](https://docs.python.org/3/reference/simple_stmts.html#import) can be used to refer to modules." 889 | ] 890 | }, 891 | { 892 | "cell_type": "code", 893 | "execution_count": null, 894 | "metadata": { 895 | "colab": {}, 896 | "colab_type": "code", 897 | "id": "pYjERSx-bmQJ" 898 | }, 899 | "outputs": [], 900 | "source": [ 901 | "import matplotlib.pyplot as plt\n", 902 | "import math\n", 903 | "\n", 904 | "x = [0.1*i for i in range(64)]\n", 905 | "sin = [math.sin(i) for i in x]\n", 906 | "cos = [math.cos(i) for i in x]\n", 907 | "\n", 908 | "plt.plot(x, sin, label='sin(x)', color='blue', linewidth=2.5)\n", 909 | "plt.plot(x, cos, label='cos(x)', color='red', linewidth=0.5)\n", 910 | "plt.ylabel('y')\n", 911 | "plt.xlabel('x')\n", 912 | "plt.legend(loc='upper right')\n", 913 | "plt.show()" 914 | ] 915 | }, 916 | { 917 | "cell_type": "code", 918 | "execution_count": null, 919 | "metadata": {}, 920 | "outputs": [], 921 | "source": [] 922 | } 923 | ], 924 | "metadata": { 925 | "colab": { 926 | "collapsed_sections": [], 927 | "name": "Python Quick Start.ipynb", 928 | "provenance": [] 929 | }, 930 | "kernelspec": { 931 | "display_name": "Python 3", 932 | "language": "python", 933 | "name": "python3" 934 | }, 935 | "language_info": { 936 | "codemirror_mode": { 937 | "name": "ipython", 938 | "version": 3 939 | }, 940 | "file_extension": ".py", 941 | "mimetype": "text/x-python", 942 | "name": "python", 943 | "nbconvert_exporter": "python", 944 | "pygments_lexer": "ipython3", 945 | "version": "3.6.8" 946 | } 947 | }, 948 | "nbformat": 4, 949 | "nbformat_minor": 1 950 | } 951 | -------------------------------------------------------------------------------- /Notebooks/data/Khufu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/Notebooks/data/Khufu.png -------------------------------------------------------------------------------- /Notebooks/data/imports-85.data: -------------------------------------------------------------------------------- 1 | 3,?,alfa-romero,gas,std,two,convertible,rwd,front,88.60,168.80,64.10,48.80,2548,dohc,four,130,mpfi,3.47,2.68,9.00,111,5000,21,27,13495 2 | 3,?,alfa-romero,gas,std,two,convertible,rwd,front,88.60,168.80,64.10,48.80,2548,dohc,four,130,mpfi,3.47,2.68,9.00,111,5000,21,27,16500 3 | 1,?,alfa-romero,gas,std,two,hatchback,rwd,front,94.50,171.20,65.50,52.40,2823,ohcv,six,152,mpfi,2.68,3.47,9.00,154,5000,19,26,16500 4 | 2,164,audi,gas,std,four,sedan,fwd,front,99.80,176.60,66.20,54.30,2337,ohc,four,109,mpfi,3.19,3.40,10.00,102,5500,24,30,13950 5 | 2,164,audi,gas,std,four,sedan,4wd,front,99.40,176.60,66.40,54.30,2824,ohc,five,136,mpfi,3.19,3.40,8.00,115,5500,18,22,17450 6 | 2,?,audi,gas,std,two,sedan,fwd,front,99.80,177.30,66.30,53.10,2507,ohc,five,136,mpfi,3.19,3.40,8.50,110,5500,19,25,15250 7 | 1,158,audi,gas,std,four,sedan,fwd,front,105.80,192.70,71.40,55.70,2844,ohc,five,136,mpfi,3.19,3.40,8.50,110,5500,19,25,17710 8 | 1,?,audi,gas,std,four,wagon,fwd,front,105.80,192.70,71.40,55.70,2954,ohc,five,136,mpfi,3.19,3.40,8.50,110,5500,19,25,18920 9 | 1,158,audi,gas,turbo,four,sedan,fwd,front,105.80,192.70,71.40,55.90,3086,ohc,five,131,mpfi,3.13,3.40,8.30,140,5500,17,20,23875 10 | 0,?,audi,gas,turbo,two,hatchback,4wd,front,99.50,178.20,67.90,52.00,3053,ohc,five,131,mpfi,3.13,3.40,7.00,160,5500,16,22,? 11 | 2,192,bmw,gas,std,two,sedan,rwd,front,101.20,176.80,64.80,54.30,2395,ohc,four,108,mpfi,3.50,2.80,8.80,101,5800,23,29,16430 12 | 0,192,bmw,gas,std,four,sedan,rwd,front,101.20,176.80,64.80,54.30,2395,ohc,four,108,mpfi,3.50,2.80,8.80,101,5800,23,29,16925 13 | 0,188,bmw,gas,std,two,sedan,rwd,front,101.20,176.80,64.80,54.30,2710,ohc,six,164,mpfi,3.31,3.19,9.00,121,4250,21,28,20970 14 | 0,188,bmw,gas,std,four,sedan,rwd,front,101.20,176.80,64.80,54.30,2765,ohc,six,164,mpfi,3.31,3.19,9.00,121,4250,21,28,21105 15 | 1,?,bmw,gas,std,four,sedan,rwd,front,103.50,189.00,66.90,55.70,3055,ohc,six,164,mpfi,3.31,3.19,9.00,121,4250,20,25,24565 16 | 0,?,bmw,gas,std,four,sedan,rwd,front,103.50,189.00,66.90,55.70,3230,ohc,six,209,mpfi,3.62,3.39,8.00,182,5400,16,22,30760 17 | 0,?,bmw,gas,std,two,sedan,rwd,front,103.50,193.80,67.90,53.70,3380,ohc,six,209,mpfi,3.62,3.39,8.00,182,5400,16,22,41315 18 | 0,?,bmw,gas,std,four,sedan,rwd,front,110.00,197.00,70.90,56.30,3505,ohc,six,209,mpfi,3.62,3.39,8.00,182,5400,15,20,36880 19 | 2,121,chevrolet,gas,std,two,hatchback,fwd,front,88.40,141.10,60.30,53.20,1488,l,three,61,2bbl,2.91,3.03,9.50,48,5100,47,53,5151 20 | 1,98,chevrolet,gas,std,two,hatchback,fwd,front,94.50,155.90,63.60,52.00,1874,ohc,four,90,2bbl,3.03,3.11,9.60,70,5400,38,43,6295 21 | 0,81,chevrolet,gas,std,four,sedan,fwd,front,94.50,158.80,63.60,52.00,1909,ohc,four,90,2bbl,3.03,3.11,9.60,70,5400,38,43,6575 22 | 1,118,dodge,gas,std,two,hatchback,fwd,front,93.70,157.30,63.80,50.80,1876,ohc,four,90,2bbl,2.97,3.23,9.41,68,5500,37,41,5572 23 | 1,118,dodge,gas,std,two,hatchback,fwd,front,93.70,157.30,63.80,50.80,1876,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,31,38,6377 24 | 1,118,dodge,gas,turbo,two,hatchback,fwd,front,93.70,157.30,63.80,50.80,2128,ohc,four,98,mpfi,3.03,3.39,7.60,102,5500,24,30,7957 25 | 1,148,dodge,gas,std,four,hatchback,fwd,front,93.70,157.30,63.80,50.60,1967,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,31,38,6229 26 | 1,148,dodge,gas,std,four,sedan,fwd,front,93.70,157.30,63.80,50.60,1989,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,31,38,6692 27 | 1,148,dodge,gas,std,four,sedan,fwd,front,93.70,157.30,63.80,50.60,1989,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,31,38,7609 28 | 1,148,dodge,gas,turbo,?,sedan,fwd,front,93.70,157.30,63.80,50.60,2191,ohc,four,98,mpfi,3.03,3.39,7.60,102,5500,24,30,8558 29 | -1,110,dodge,gas,std,four,wagon,fwd,front,103.30,174.60,64.60,59.80,2535,ohc,four,122,2bbl,3.34,3.46,8.50,88,5000,24,30,8921 30 | 3,145,dodge,gas,turbo,two,hatchback,fwd,front,95.90,173.20,66.30,50.20,2811,ohc,four,156,mfi,3.60,3.90,7.00,145,5000,19,24,12964 31 | 2,137,honda,gas,std,two,hatchback,fwd,front,86.60,144.60,63.90,50.80,1713,ohc,four,92,1bbl,2.91,3.41,9.60,58,4800,49,54,6479 32 | 2,137,honda,gas,std,two,hatchback,fwd,front,86.60,144.60,63.90,50.80,1819,ohc,four,92,1bbl,2.91,3.41,9.20,76,6000,31,38,6855 33 | 1,101,honda,gas,std,two,hatchback,fwd,front,93.70,150.00,64.00,52.60,1837,ohc,four,79,1bbl,2.91,3.07,10.10,60,5500,38,42,5399 34 | 1,101,honda,gas,std,two,hatchback,fwd,front,93.70,150.00,64.00,52.60,1940,ohc,four,92,1bbl,2.91,3.41,9.20,76,6000,30,34,6529 35 | 1,101,honda,gas,std,two,hatchback,fwd,front,93.70,150.00,64.00,52.60,1956,ohc,four,92,1bbl,2.91,3.41,9.20,76,6000,30,34,7129 36 | 0,110,honda,gas,std,four,sedan,fwd,front,96.50,163.40,64.00,54.50,2010,ohc,four,92,1bbl,2.91,3.41,9.20,76,6000,30,34,7295 37 | 0,78,honda,gas,std,four,wagon,fwd,front,96.50,157.10,63.90,58.30,2024,ohc,four,92,1bbl,2.92,3.41,9.20,76,6000,30,34,7295 38 | 0,106,honda,gas,std,two,hatchback,fwd,front,96.50,167.50,65.20,53.30,2236,ohc,four,110,1bbl,3.15,3.58,9.00,86,5800,27,33,7895 39 | 0,106,honda,gas,std,two,hatchback,fwd,front,96.50,167.50,65.20,53.30,2289,ohc,four,110,1bbl,3.15,3.58,9.00,86,5800,27,33,9095 40 | 0,85,honda,gas,std,four,sedan,fwd,front,96.50,175.40,65.20,54.10,2304,ohc,four,110,1bbl,3.15,3.58,9.00,86,5800,27,33,8845 41 | 0,85,honda,gas,std,four,sedan,fwd,front,96.50,175.40,62.50,54.10,2372,ohc,four,110,1bbl,3.15,3.58,9.00,86,5800,27,33,10295 42 | 0,85,honda,gas,std,four,sedan,fwd,front,96.50,175.40,65.20,54.10,2465,ohc,four,110,mpfi,3.15,3.58,9.00,101,5800,24,28,12945 43 | 1,107,honda,gas,std,two,sedan,fwd,front,96.50,169.10,66.00,51.00,2293,ohc,four,110,2bbl,3.15,3.58,9.10,100,5500,25,31,10345 44 | 0,?,isuzu,gas,std,four,sedan,rwd,front,94.30,170.70,61.80,53.50,2337,ohc,four,111,2bbl,3.31,3.23,8.50,78,4800,24,29,6785 45 | 1,?,isuzu,gas,std,two,sedan,fwd,front,94.50,155.90,63.60,52.00,1874,ohc,four,90,2bbl,3.03,3.11,9.60,70,5400,38,43,? 46 | 0,?,isuzu,gas,std,four,sedan,fwd,front,94.50,155.90,63.60,52.00,1909,ohc,four,90,2bbl,3.03,3.11,9.60,70,5400,38,43,? 47 | 2,?,isuzu,gas,std,two,hatchback,rwd,front,96.00,172.60,65.20,51.40,2734,ohc,four,119,spfi,3.43,3.23,9.20,90,5000,24,29,11048 48 | 0,145,jaguar,gas,std,four,sedan,rwd,front,113.00,199.60,69.60,52.80,4066,dohc,six,258,mpfi,3.63,4.17,8.10,176,4750,15,19,32250 49 | 0,?,jaguar,gas,std,four,sedan,rwd,front,113.00,199.60,69.60,52.80,4066,dohc,six,258,mpfi,3.63,4.17,8.10,176,4750,15,19,35550 50 | 0,?,jaguar,gas,std,two,sedan,rwd,front,102.00,191.70,70.60,47.80,3950,ohcv,twelve,326,mpfi,3.54,2.76,11.50,262,5000,13,17,36000 51 | 1,104,mazda,gas,std,two,hatchback,fwd,front,93.10,159.10,64.20,54.10,1890,ohc,four,91,2bbl,3.03,3.15,9.00,68,5000,30,31,5195 52 | 1,104,mazda,gas,std,two,hatchback,fwd,front,93.10,159.10,64.20,54.10,1900,ohc,four,91,2bbl,3.03,3.15,9.00,68,5000,31,38,6095 53 | 1,104,mazda,gas,std,two,hatchback,fwd,front,93.10,159.10,64.20,54.10,1905,ohc,four,91,2bbl,3.03,3.15,9.00,68,5000,31,38,6795 54 | 1,113,mazda,gas,std,four,sedan,fwd,front,93.10,166.80,64.20,54.10,1945,ohc,four,91,2bbl,3.03,3.15,9.00,68,5000,31,38,6695 55 | 1,113,mazda,gas,std,four,sedan,fwd,front,93.10,166.80,64.20,54.10,1950,ohc,four,91,2bbl,3.08,3.15,9.00,68,5000,31,38,7395 56 | 3,150,mazda,gas,std,two,hatchback,rwd,front,95.30,169.00,65.70,49.60,2380,rotor,two,70,4bbl,?,?,9.40,101,6000,17,23,10945 57 | 3,150,mazda,gas,std,two,hatchback,rwd,front,95.30,169.00,65.70,49.60,2380,rotor,two,70,4bbl,?,?,9.40,101,6000,17,23,11845 58 | 3,150,mazda,gas,std,two,hatchback,rwd,front,95.30,169.00,65.70,49.60,2385,rotor,two,70,4bbl,?,?,9.40,101,6000,17,23,13645 59 | 3,150,mazda,gas,std,two,hatchback,rwd,front,95.30,169.00,65.70,49.60,2500,rotor,two,80,mpfi,?,?,9.40,135,6000,16,23,15645 60 | 1,129,mazda,gas,std,two,hatchback,fwd,front,98.80,177.80,66.50,53.70,2385,ohc,four,122,2bbl,3.39,3.39,8.60,84,4800,26,32,8845 61 | 0,115,mazda,gas,std,four,sedan,fwd,front,98.80,177.80,66.50,55.50,2410,ohc,four,122,2bbl,3.39,3.39,8.60,84,4800,26,32,8495 62 | 1,129,mazda,gas,std,two,hatchback,fwd,front,98.80,177.80,66.50,53.70,2385,ohc,four,122,2bbl,3.39,3.39,8.60,84,4800,26,32,10595 63 | 0,115,mazda,gas,std,four,sedan,fwd,front,98.80,177.80,66.50,55.50,2410,ohc,four,122,2bbl,3.39,3.39,8.60,84,4800,26,32,10245 64 | 0,?,mazda,diesel,std,?,sedan,fwd,front,98.80,177.80,66.50,55.50,2443,ohc,four,122,idi,3.39,3.39,22.70,64,4650,36,42,10795 65 | 0,115,mazda,gas,std,four,hatchback,fwd,front,98.80,177.80,66.50,55.50,2425,ohc,four,122,2bbl,3.39,3.39,8.60,84,4800,26,32,11245 66 | 0,118,mazda,gas,std,four,sedan,rwd,front,104.90,175.00,66.10,54.40,2670,ohc,four,140,mpfi,3.76,3.16,8.00,120,5000,19,27,18280 67 | 0,?,mazda,diesel,std,four,sedan,rwd,front,104.90,175.00,66.10,54.40,2700,ohc,four,134,idi,3.43,3.64,22.00,72,4200,31,39,18344 68 | -1,93,mercedes-benz,diesel,turbo,four,sedan,rwd,front,110.00,190.90,70.30,56.50,3515,ohc,five,183,idi,3.58,3.64,21.50,123,4350,22,25,25552 69 | -1,93,mercedes-benz,diesel,turbo,four,wagon,rwd,front,110.00,190.90,70.30,58.70,3750,ohc,five,183,idi,3.58,3.64,21.50,123,4350,22,25,28248 70 | 0,93,mercedes-benz,diesel,turbo,two,hardtop,rwd,front,106.70,187.50,70.30,54.90,3495,ohc,five,183,idi,3.58,3.64,21.50,123,4350,22,25,28176 71 | -1,93,mercedes-benz,diesel,turbo,four,sedan,rwd,front,115.60,202.60,71.70,56.30,3770,ohc,five,183,idi,3.58,3.64,21.50,123,4350,22,25,31600 72 | -1,?,mercedes-benz,gas,std,four,sedan,rwd,front,115.60,202.60,71.70,56.50,3740,ohcv,eight,234,mpfi,3.46,3.10,8.30,155,4750,16,18,34184 73 | 3,142,mercedes-benz,gas,std,two,convertible,rwd,front,96.60,180.30,70.50,50.80,3685,ohcv,eight,234,mpfi,3.46,3.10,8.30,155,4750,16,18,35056 74 | 0,?,mercedes-benz,gas,std,four,sedan,rwd,front,120.90,208.10,71.70,56.70,3900,ohcv,eight,308,mpfi,3.80,3.35,8.00,184,4500,14,16,40960 75 | 1,?,mercedes-benz,gas,std,two,hardtop,rwd,front,112.00,199.20,72.00,55.40,3715,ohcv,eight,304,mpfi,3.80,3.35,8.00,184,4500,14,16,45400 76 | 1,?,mercury,gas,turbo,two,hatchback,rwd,front,102.70,178.40,68.00,54.80,2910,ohc,four,140,mpfi,3.78,3.12,8.00,175,5000,19,24,16503 77 | 2,161,mitsubishi,gas,std,two,hatchback,fwd,front,93.70,157.30,64.40,50.80,1918,ohc,four,92,2bbl,2.97,3.23,9.40,68,5500,37,41,5389 78 | 2,161,mitsubishi,gas,std,two,hatchback,fwd,front,93.70,157.30,64.40,50.80,1944,ohc,four,92,2bbl,2.97,3.23,9.40,68,5500,31,38,6189 79 | 2,161,mitsubishi,gas,std,two,hatchback,fwd,front,93.70,157.30,64.40,50.80,2004,ohc,four,92,2bbl,2.97,3.23,9.40,68,5500,31,38,6669 80 | 1,161,mitsubishi,gas,turbo,two,hatchback,fwd,front,93,157.30,63.80,50.80,2145,ohc,four,98,spdi,3.03,3.39,7.60,102,5500,24,30,7689 81 | 3,153,mitsubishi,gas,turbo,two,hatchback,fwd,front,96.30,173.00,65.40,49.40,2370,ohc,four,110,spdi,3.17,3.46,7.50,116,5500,23,30,9959 82 | 3,153,mitsubishi,gas,std,two,hatchback,fwd,front,96.30,173.00,65.40,49.40,2328,ohc,four,122,2bbl,3.35,3.46,8.50,88,5000,25,32,8499 83 | 3,?,mitsubishi,gas,turbo,two,hatchback,fwd,front,95.90,173.20,66.30,50.20,2833,ohc,four,156,spdi,3.58,3.86,7.00,145,5000,19,24,12629 84 | 3,?,mitsubishi,gas,turbo,two,hatchback,fwd,front,95.90,173.20,66.30,50.20,2921,ohc,four,156,spdi,3.59,3.86,7.00,145,5000,19,24,14869 85 | 3,?,mitsubishi,gas,turbo,two,hatchback,fwd,front,95.90,173.20,66.30,50.20,2926,ohc,four,156,spdi,3.59,3.86,7.00,145,5000,19,24,14489 86 | 1,125,mitsubishi,gas,std,four,sedan,fwd,front,96.30,172.40,65.40,51.60,2365,ohc,four,122,2bbl,3.35,3.46,8.50,88,5000,25,32,6989 87 | 1,125,mitsubishi,gas,std,four,sedan,fwd,front,96.30,172.40,65.40,51.60,2405,ohc,four,122,2bbl,3.35,3.46,8.50,88,5000,25,32,8189 88 | 1,125,mitsubishi,gas,turbo,four,sedan,fwd,front,96.30,172.40,65.40,51.60,2403,ohc,four,110,spdi,3.17,3.46,7.50,116,5500,23,30,9279 89 | -1,137,mitsubishi,gas,std,four,sedan,fwd,front,96.30,172.40,65.40,51.60,2403,ohc,four,110,spdi,3.17,3.46,7.50,116,5500,23,30,9279 90 | 1,128,nissan,gas,std,two,sedan,fwd,front,94.50,165.30,63.80,54.50,1889,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,5499 91 | 1,128,nissan,diesel,std,two,sedan,fwd,front,94.50,165.30,63.80,54.50,2017,ohc,four,103,idi,2.99,3.47,21.90,55,4800,45,50,7099 92 | 1,128,nissan,gas,std,two,sedan,fwd,front,94.50,165.30,63.80,54.50,1918,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,6649 93 | 1,122,nissan,gas,std,four,sedan,fwd,front,94.50,165.30,63.80,54.50,1938,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,6849 94 | 1,103,nissan,gas,std,four,wagon,fwd,front,94.50,170.20,63.80,53.50,2024,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,7349 95 | 1,128,nissan,gas,std,two,sedan,fwd,front,94.50,165.30,63.80,54.50,1951,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,7299 96 | 1,128,nissan,gas,std,two,hatchback,fwd,front,94.50,165.60,63.80,53.30,2028,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,7799 97 | 1,122,nissan,gas,std,four,sedan,fwd,front,94.50,165.30,63.80,54.50,1971,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,7499 98 | 1,103,nissan,gas,std,four,wagon,fwd,front,94.50,170.20,63.80,53.50,2037,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,7999 99 | 2,168,nissan,gas,std,two,hardtop,fwd,front,95.10,162.40,63.80,53.30,2008,ohc,four,97,2bbl,3.15,3.29,9.40,69,5200,31,37,8249 100 | 0,106,nissan,gas,std,four,hatchback,fwd,front,97.20,173.40,65.20,54.70,2324,ohc,four,120,2bbl,3.33,3.47,8.50,97,5200,27,34,8949 101 | 0,106,nissan,gas,std,four,sedan,fwd,front,97.20,173.40,65.20,54.70,2302,ohc,four,120,2bbl,3.33,3.47,8.50,97,5200,27,34,9549 102 | 0,128,nissan,gas,std,four,sedan,fwd,front,100.40,181.70,66.50,55.10,3095,ohcv,six,181,mpfi,3.43,3.27,9.00,152,5200,17,22,13499 103 | 0,108,nissan,gas,std,four,wagon,fwd,front,100.40,184.60,66.50,56.10,3296,ohcv,six,181,mpfi,3.43,3.27,9.00,152,5200,17,22,14399 104 | 0,108,nissan,gas,std,four,sedan,fwd,front,100.40,184.60,66.50,55.10,3060,ohcv,six,181,mpfi,3.43,3.27,9.00,152,5200,19,25,13499 105 | 3,194,nissan,gas,std,two,hatchback,rwd,front,91.30,170.70,67.90,49.70,3071,ohcv,six,181,mpfi,3.43,3.27,9.00,160,5200,19,25,17199 106 | 3,194,nissan,gas,turbo,two,hatchback,rwd,front,91.30,170.70,67.90,49.70,3139,ohcv,six,181,mpfi,3.43,3.27,7.80,200,5200,17,23,19699 107 | 1,231,nissan,gas,std,two,hatchback,rwd,front,99.20,178.50,67.90,49.70,3139,ohcv,six,181,mpfi,3.43,3.27,9.00,160,5200,19,25,18399 108 | 0,161,peugot,gas,std,four,sedan,rwd,front,107.90,186.70,68.40,56.70,3020,l,four,120,mpfi,3.46,3.19,8.40,97,5000,19,24,11900 109 | 0,161,peugot,diesel,turbo,four,sedan,rwd,front,107.90,186.70,68.40,56.70,3197,l,four,152,idi,3.70,3.52,21.00,95,4150,28,33,13200 110 | 0,?,peugot,gas,std,four,wagon,rwd,front,114.20,198.90,68.40,58.70,3230,l,four,120,mpfi,3.46,3.19,8.40,97,5000,19,24,12440 111 | 0,?,peugot,diesel,turbo,four,wagon,rwd,front,114.20,198.90,68.40,58.70,3430,l,four,152,idi,3.70,3.52,21.00,95,4150,25,25,13860 112 | 0,161,peugot,gas,std,four,sedan,rwd,front,107.90,186.70,68.40,56.70,3075,l,four,120,mpfi,3.46,2.19,8.40,95,5000,19,24,15580 113 | 0,161,peugot,diesel,turbo,four,sedan,rwd,front,107.90,186.70,68.40,56.70,3252,l,four,152,idi,3.70,3.52,21.00,95,4150,28,33,16900 114 | 0,?,peugot,gas,std,four,wagon,rwd,front,114.20,198.90,68.40,56.70,3285,l,four,120,mpfi,3.46,2.19,8.40,95,5000,19,24,16695 115 | 0,?,peugot,diesel,turbo,four,wagon,rwd,front,114.20,198.90,68.40,58.70,3485,l,four,152,idi,3.70,3.52,21.00,95,4150,25,25,17075 116 | 0,161,peugot,gas,std,four,sedan,rwd,front,107.90,186.70,68.40,56.70,3075,l,four,120,mpfi,3.46,3.19,8.40,97,5000,19,24,16630 117 | 0,161,peugot,diesel,turbo,four,sedan,rwd,front,107.90,186.70,68.40,56.70,3252,l,four,152,idi,3.70,3.52,21.00,95,4150,28,33,17950 118 | 0,161,peugot,gas,turbo,four,sedan,rwd,front,108.00,186.70,68.30,56.00,3130,l,four,134,mpfi,3.61,3.21,7.00,142,5600,18,24,18150 119 | 1,119,plymouth,gas,std,two,hatchback,fwd,front,93.70,157.30,63.80,50.80,1918,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,37,41,5572 120 | 1,119,plymouth,gas,turbo,two,hatchback,fwd,front,93.70,157.30,63.80,50.80,2128,ohc,four,98,spdi,3.03,3.39,7.60,102,5500,24,30,7957 121 | 1,154,plymouth,gas,std,four,hatchback,fwd,front,93.70,157.30,63.80,50.60,1967,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,31,38,6229 122 | 1,154,plymouth,gas,std,four,sedan,fwd,front,93.70,167.30,63.80,50.80,1989,ohc,four,90,2bbl,2.97,3.23,9.40,68,5500,31,38,6692 123 | 1,154,plymouth,gas,std,four,sedan,fwd,front,93.70,167.30,63.80,50.80,2191,ohc,four,98,2bbl,2.97,3.23,9.40,68,5500,31,38,7609 124 | -1,74,plymouth,gas,std,four,wagon,fwd,front,103.30,174.60,64.60,59.80,2535,ohc,four,122,2bbl,3.35,3.46,8.50,88,5000,24,30,8921 125 | 3,?,plymouth,gas,turbo,two,hatchback,rwd,front,95.90,173.20,66.30,50.20,2818,ohc,four,156,spdi,3.59,3.86,7.00,145,5000,19,24,12764 126 | 3,186,porsche,gas,std,two,hatchback,rwd,front,94.50,168.90,68.30,50.20,2778,ohc,four,151,mpfi,3.94,3.11,9.50,143,5500,19,27,22018 127 | 3,?,porsche,gas,std,two,hardtop,rwd,rear,89.50,168.90,65.00,51.60,2756,ohcf,six,194,mpfi,3.74,2.90,9.50,207,5900,17,25,32528 128 | 3,?,porsche,gas,std,two,hardtop,rwd,rear,89.50,168.90,65.00,51.60,2756,ohcf,six,194,mpfi,3.74,2.90,9.50,207,5900,17,25,34028 129 | 3,?,porsche,gas,std,two,convertible,rwd,rear,89.50,168.90,65.00,51.60,2800,ohcf,six,194,mpfi,3.74,2.90,9.50,207,5900,17,25,37028 130 | 1,?,porsche,gas,std,two,hatchback,rwd,front,98.40,175.70,72.30,50.50,3366,dohcv,eight,203,mpfi,3.94,3.11,10.00,288,5750,17,28,? 131 | 0,?,renault,gas,std,four,wagon,fwd,front,96.10,181.50,66.50,55.20,2579,ohc,four,132,mpfi,3.46,3.90,8.70,?,?,23,31,9295 132 | 2,?,renault,gas,std,two,hatchback,fwd,front,96.10,176.80,66.60,50.50,2460,ohc,four,132,mpfi,3.46,3.90,8.70,?,?,23,31,9895 133 | 3,150,saab,gas,std,two,hatchback,fwd,front,99.10,186.60,66.50,56.10,2658,ohc,four,121,mpfi,3.54,3.07,9.31,110,5250,21,28,11850 134 | 2,104,saab,gas,std,four,sedan,fwd,front,99.10,186.60,66.50,56.10,2695,ohc,four,121,mpfi,3.54,3.07,9.30,110,5250,21,28,12170 135 | 3,150,saab,gas,std,two,hatchback,fwd,front,99.10,186.60,66.50,56.10,2707,ohc,four,121,mpfi,2.54,2.07,9.30,110,5250,21,28,15040 136 | 2,104,saab,gas,std,four,sedan,fwd,front,99.10,186.60,66.50,56.10,2758,ohc,four,121,mpfi,3.54,3.07,9.30,110,5250,21,28,15510 137 | 3,150,saab,gas,turbo,two,hatchback,fwd,front,99.10,186.60,66.50,56.10,2808,dohc,four,121,mpfi,3.54,3.07,9.00,160,5500,19,26,18150 138 | 2,104,saab,gas,turbo,four,sedan,fwd,front,99.10,186.60,66.50,56.10,2847,dohc,four,121,mpfi,3.54,3.07,9.00,160,5500,19,26,18620 139 | 2,83,subaru,gas,std,two,hatchback,fwd,front,93.70,156.90,63.40,53.70,2050,ohcf,four,97,2bbl,3.62,2.36,9.00,69,4900,31,36,5118 140 | 2,83,subaru,gas,std,two,hatchback,fwd,front,93.70,157.90,63.60,53.70,2120,ohcf,four,108,2bbl,3.62,2.64,8.70,73,4400,26,31,7053 141 | 2,83,subaru,gas,std,two,hatchback,4wd,front,93.30,157.30,63.80,55.70,2240,ohcf,four,108,2bbl,3.62,2.64,8.70,73,4400,26,31,7603 142 | 0,102,subaru,gas,std,four,sedan,fwd,front,97.20,172.00,65.40,52.50,2145,ohcf,four,108,2bbl,3.62,2.64,9.50,82,4800,32,37,7126 143 | 0,102,subaru,gas,std,four,sedan,fwd,front,97.20,172.00,65.40,52.50,2190,ohcf,four,108,2bbl,3.62,2.64,9.50,82,4400,28,33,7775 144 | 0,102,subaru,gas,std,four,sedan,fwd,front,97.20,172.00,65.40,52.50,2340,ohcf,four,108,mpfi,3.62,2.64,9.00,94,5200,26,32,9960 145 | 0,102,subaru,gas,std,four,sedan,4wd,front,97.00,172.00,65.40,54.30,2385,ohcf,four,108,2bbl,3.62,2.64,9.00,82,4800,24,25,9233 146 | 0,102,subaru,gas,turbo,four,sedan,4wd,front,97.00,172.00,65.40,54.30,2510,ohcf,four,108,mpfi,3.62,2.64,7.70,111,4800,24,29,11259 147 | 0,89,subaru,gas,std,four,wagon,fwd,front,97.00,173.50,65.40,53.00,2290,ohcf,four,108,2bbl,3.62,2.64,9.00,82,4800,28,32,7463 148 | 0,89,subaru,gas,std,four,wagon,fwd,front,97.00,173.50,65.40,53.00,2455,ohcf,four,108,mpfi,3.62,2.64,9.00,94,5200,25,31,10198 149 | 0,85,subaru,gas,std,four,wagon,4wd,front,96.90,173.60,65.40,54.90,2420,ohcf,four,108,2bbl,3.62,2.64,9.00,82,4800,23,29,8013 150 | 0,85,subaru,gas,turbo,four,wagon,4wd,front,96.90,173.60,65.40,54.90,2650,ohcf,four,108,mpfi,3.62,2.64,7.70,111,4800,23,23,11694 151 | 1,87,toyota,gas,std,two,hatchback,fwd,front,95.70,158.70,63.60,54.50,1985,ohc,four,92,2bbl,3.05,3.03,9.00,62,4800,35,39,5348 152 | 1,87,toyota,gas,std,two,hatchback,fwd,front,95.70,158.70,63.60,54.50,2040,ohc,four,92,2bbl,3.05,3.03,9.00,62,4800,31,38,6338 153 | 1,74,toyota,gas,std,four,hatchback,fwd,front,95.70,158.70,63.60,54.50,2015,ohc,four,92,2bbl,3.05,3.03,9.00,62,4800,31,38,6488 154 | 0,77,toyota,gas,std,four,wagon,fwd,front,95.70,169.70,63.60,59.10,2280,ohc,four,92,2bbl,3.05,3.03,9.00,62,4800,31,37,6918 155 | 0,81,toyota,gas,std,four,wagon,4wd,front,95.70,169.70,63.60,59.10,2290,ohc,four,92,2bbl,3.05,3.03,9.00,62,4800,27,32,7898 156 | 0,91,toyota,gas,std,four,wagon,4wd,front,95.70,169.70,63.60,59.10,3110,ohc,four,92,2bbl,3.05,3.03,9.00,62,4800,27,32,8778 157 | 0,91,toyota,gas,std,four,sedan,fwd,front,95.70,166.30,64.40,53.00,2081,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,30,37,6938 158 | 0,91,toyota,gas,std,four,hatchback,fwd,front,95.70,166.30,64.40,52.80,2109,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,30,37,7198 159 | 0,91,toyota,diesel,std,four,sedan,fwd,front,95.70,166.30,64.40,53.00,2275,ohc,four,110,idi,3.27,3.35,22.50,56,4500,34,36,7898 160 | 0,91,toyota,diesel,std,four,hatchback,fwd,front,95.70,166.30,64.40,52.80,2275,ohc,four,110,idi,3.27,3.35,22.50,56,4500,38,47,7788 161 | 0,91,toyota,gas,std,four,sedan,fwd,front,95.70,166.30,64.40,53.00,2094,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,38,47,7738 162 | 0,91,toyota,gas,std,four,hatchback,fwd,front,95.70,166.30,64.40,52.80,2122,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,28,34,8358 163 | 0,91,toyota,gas,std,four,sedan,fwd,front,95.70,166.30,64.40,52.80,2140,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,28,34,9258 164 | 1,168,toyota,gas,std,two,sedan,rwd,front,94.50,168.70,64.00,52.60,2169,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,29,34,8058 165 | 1,168,toyota,gas,std,two,hatchback,rwd,front,94.50,168.70,64.00,52.60,2204,ohc,four,98,2bbl,3.19,3.03,9.00,70,4800,29,34,8238 166 | 1,168,toyota,gas,std,two,sedan,rwd,front,94.50,168.70,64.00,52.60,2265,dohc,four,98,mpfi,3.24,3.08,9.40,112,6600,26,29,9298 167 | 1,168,toyota,gas,std,two,hatchback,rwd,front,94.50,168.70,64.00,52.60,2300,dohc,four,98,mpfi,3.24,3.08,9.40,112,6600,26,29,9538 168 | 2,134,toyota,gas,std,two,hardtop,rwd,front,98.40,176.20,65.60,52.00,2540,ohc,four,146,mpfi,3.62,3.50,9.30,116,4800,24,30,8449 169 | 2,134,toyota,gas,std,two,hardtop,rwd,front,98.40,176.20,65.60,52.00,2536,ohc,four,146,mpfi,3.62,3.50,9.30,116,4800,24,30,9639 170 | 2,134,toyota,gas,std,two,hatchback,rwd,front,98.40,176.20,65.60,52.00,2551,ohc,four,146,mpfi,3.62,3.50,9.30,116,4800,24,30,9989 171 | 2,134,toyota,gas,std,two,hardtop,rwd,front,98.40,176.20,65.60,52.00,2679,ohc,four,146,mpfi,3.62,3.50,9.30,116,4800,24,30,11199 172 | 2,134,toyota,gas,std,two,hatchback,rwd,front,98.40,176.20,65.60,52.00,2714,ohc,four,146,mpfi,3.62,3.50,9.30,116,4800,24,30,11549 173 | 2,134,toyota,gas,std,two,convertible,rwd,front,98.40,176.20,65.60,53.00,2975,ohc,four,146,mpfi,3.62,3.50,9.30,116,4800,24,30,17669 174 | -1,65,toyota,gas,std,four,sedan,fwd,front,102.40,175.60,66.50,54.90,2326,ohc,four,122,mpfi,3.31,3.54,8.70,92,4200,29,34,8948 175 | -1,65,toyota,diesel,turbo,four,sedan,fwd,front,102.40,175.60,66.50,54.90,2480,ohc,four,110,idi,3.27,3.35,22.50,73,4500,30,33,10698 176 | -1,65,toyota,gas,std,four,hatchback,fwd,front,102.40,175.60,66.50,53.90,2414,ohc,four,122,mpfi,3.31,3.54,8.70,92,4200,27,32,9988 177 | -1,65,toyota,gas,std,four,sedan,fwd,front,102.40,175.60,66.50,54.90,2414,ohc,four,122,mpfi,3.31,3.54,8.70,92,4200,27,32,10898 178 | -1,65,toyota,gas,std,four,hatchback,fwd,front,102.40,175.60,66.50,53.90,2458,ohc,four,122,mpfi,3.31,3.54,8.70,92,4200,27,32,11248 179 | 3,197,toyota,gas,std,two,hatchback,rwd,front,102.90,183.50,67.70,52.00,2976,dohc,six,171,mpfi,3.27,3.35,9.30,161,5200,20,24,16558 180 | 3,197,toyota,gas,std,two,hatchback,rwd,front,102.90,183.50,67.70,52.00,3016,dohc,six,171,mpfi,3.27,3.35,9.30,161,5200,19,24,15998 181 | -1,90,toyota,gas,std,four,sedan,rwd,front,104.50,187.80,66.50,54.10,3131,dohc,six,171,mpfi,3.27,3.35,9.20,156,5200,20,24,15690 182 | -1,?,toyota,gas,std,four,wagon,rwd,front,104.50,187.80,66.50,54.10,3151,dohc,six,161,mpfi,3.27,3.35,9.20,156,5200,19,24,15750 183 | 2,122,volkswagen,diesel,std,two,sedan,fwd,front,97.30,171.70,65.50,55.70,2261,ohc,four,97,idi,3.01,3.40,23.00,52,4800,37,46,7775 184 | 2,122,volkswagen,gas,std,two,sedan,fwd,front,97.30,171.70,65.50,55.70,2209,ohc,four,109,mpfi,3.19,3.40,9.00,85,5250,27,34,7975 185 | 2,94,volkswagen,diesel,std,four,sedan,fwd,front,97.30,171.70,65.50,55.70,2264,ohc,four,97,idi,3.01,3.40,23.00,52,4800,37,46,7995 186 | 2,94,volkswagen,gas,std,four,sedan,fwd,front,97.30,171.70,65.50,55.70,2212,ohc,four,109,mpfi,3.19,3.40,9.00,85,5250,27,34,8195 187 | 2,94,volkswagen,gas,std,four,sedan,fwd,front,97.30,171.70,65.50,55.70,2275,ohc,four,109,mpfi,3.19,3.40,9.00,85,5250,27,34,8495 188 | 2,94,volkswagen,diesel,turbo,four,sedan,fwd,front,97.30,171.70,65.50,55.70,2319,ohc,four,97,idi,3.01,3.40,23.00,68,4500,37,42,9495 189 | 2,94,volkswagen,gas,std,four,sedan,fwd,front,97.30,171.70,65.50,55.70,2300,ohc,four,109,mpfi,3.19,3.40,10.00,100,5500,26,32,9995 190 | 3,?,volkswagen,gas,std,two,convertible,fwd,front,94.50,159.30,64.20,55.60,2254,ohc,four,109,mpfi,3.19,3.40,8.50,90,5500,24,29,11595 191 | 3,256,volkswagen,gas,std,two,hatchback,fwd,front,94.50,165.70,64.00,51.40,2221,ohc,four,109,mpfi,3.19,3.40,8.50,90,5500,24,29,9980 192 | 0,?,volkswagen,gas,std,four,sedan,fwd,front,100.40,180.20,66.90,55.10,2661,ohc,five,136,mpfi,3.19,3.40,8.50,110,5500,19,24,13295 193 | 0,?,volkswagen,diesel,turbo,four,sedan,fwd,front,100.40,180.20,66.90,55.10,2579,ohc,four,97,idi,3.01,3.40,23.00,68,4500,33,38,13845 194 | 0,?,volkswagen,gas,std,four,wagon,fwd,front,100.40,183.10,66.90,55.10,2563,ohc,four,109,mpfi,3.19,3.40,9.00,88,5500,25,31,12290 195 | -2,103,volvo,gas,std,four,sedan,rwd,front,104.30,188.80,67.20,56.20,2912,ohc,four,141,mpfi,3.78,3.15,9.50,114,5400,23,28,12940 196 | -1,74,volvo,gas,std,four,wagon,rwd,front,104.30,188.80,67.20,57.50,3034,ohc,four,141,mpfi,3.78,3.15,9.50,114,5400,23,28,13415 197 | -2,103,volvo,gas,std,four,sedan,rwd,front,104.30,188.80,67.20,56.20,2935,ohc,four,141,mpfi,3.78,3.15,9.50,114,5400,24,28,15985 198 | -1,74,volvo,gas,std,four,wagon,rwd,front,104.30,188.80,67.20,57.50,3042,ohc,four,141,mpfi,3.78,3.15,9.50,114,5400,24,28,16515 199 | -2,103,volvo,gas,turbo,four,sedan,rwd,front,104.30,188.80,67.20,56.20,3045,ohc,four,130,mpfi,3.62,3.15,7.50,162,5100,17,22,18420 200 | -1,74,volvo,gas,turbo,four,wagon,rwd,front,104.30,188.80,67.20,57.50,3157,ohc,four,130,mpfi,3.62,3.15,7.50,162,5100,17,22,18950 201 | -1,95,volvo,gas,std,four,sedan,rwd,front,109.10,188.80,68.90,55.50,2952,ohc,four,141,mpfi,3.78,3.15,9.50,114,5400,23,28,16845 202 | -1,95,volvo,gas,turbo,four,sedan,rwd,front,109.10,188.80,68.80,55.50,3049,ohc,four,141,mpfi,3.78,3.15,8.70,160,5300,19,25,19045 203 | -1,95,volvo,gas,std,four,sedan,rwd,front,109.10,188.80,68.90,55.50,3012,ohcv,six,173,mpfi,3.58,2.87,8.80,134,5500,18,23,21485 204 | -1,95,volvo,diesel,turbo,four,sedan,rwd,front,109.10,188.80,68.90,55.50,3217,ohc,six,145,idi,3.01,3.40,23.00,106,4800,26,27,22470 205 | -1,95,volvo,gas,turbo,four,sedan,rwd,front,109.10,188.80,68.90,55.50,3062,ohc,four,141,mpfi,3.78,3.15,9.50,114,5400,19,25,22625 206 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MachineLearning 2 | This is a collection of machine learning models and related examples. 3 | 4 | Many of these examples are part of my online courses: 5 | 6 | Intro Icon 7 | 8 | [Practical Introduction to Machine Learning](https://www.udemy.com/course/practical-machine-learning). If you want to quickly learn the essentials of machine learning, then this course is for you. You don't have to have any prior knowledge of machine learning, but some development experience is helpful. 9 | 10 | Example Icon 11 | 12 | [Practical Machine Learning by Example in Python](https://www.udemy.com/course/practical-machine-learning-python/) This is a more in-depth course for developers who want to learn how to build machine learning models using Tensorflow, NumPy, Pandas, and more. 13 | 14 | You can run these examples locally or in the cloud, using [Google Colab](https://colab.research.google.com/notebooks/welcome.ipynb). Google Colab is a free Jupyter notebook environment that requires no setup and runs entirely in the cloud. 15 | 16 | If you want to run Jupyter notebooks locally, follow the steps below to install Anaconda Python, Tensorflow, and Keras. 17 | 18 | ## Anaconda Python 19 | 20 | * Install Anaconda version 3.x 21 | 22 | Tensorflow 1.13 does not support Python 3.7, so Anaconda must be downgraded to 3.6 to support Tensorflow 1.13. 23 | 24 | On Windows, it is necessary to run Anaconda Prompt as Administrator for the following step only: 25 | 26 | ``` 27 | conda install python=3.6 28 | ``` 29 | 30 | For the remaining steps, run Anaconda Prompt normally (Administrator is not required): 31 | 32 | ``` 33 | pip install tensorflow==1.15 34 | pip install Keras 35 | ``` 36 | -------------------------------------------------------------------------------- /Regression/LogisticRegression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Logistic Regression\n", 8 | "\n", 9 | "[Logisitic regression](https://en.wikipedia.org/wiki/Logistic_regression) is a statistical model used to predict a binary dependent variable, not unlike a binary classifier. Logistic regression is similar to a [single layer perceptron](https://en.wikipedia.org/wiki/Feedforward_neural_network#Single-layer_perceptron), which is the basis for feedforward [artifical neural networks](https://en.wikipedia.org/wiki/Artificial_neural_network).\n", 10 | "\n", 11 | "The mathematical definition of logistic regression is presented below, as well as the basics of the [backpropagation](https://en.wikipedia.org/wiki/Backpropagation) algorithm used for training. Snippets of the equivalent Python code using numpy is also available.\n", 12 | "\n", 13 | "A network of single layer perceptrons can be combined to build a [multilayer perceptron](https://en.wikipedia.org/wiki/Multilayer_perceptron) for [deep learning](https://en.wikipedia.org/wiki/Deep_learning). More sophisticated structures, such [Convolutional Neural Networks](https://en.wikipedia.org/wiki/Convolutional_neural_network) (CNNs), [Recurrent Neural Networks](https://en.wikipedia.org/wiki/Recurrent_neural_network) (RNNs), or [autoencoders](https://en.wikipedia.org/wiki/Autoencoder) can also be assembled as a network of single layer perceptrons.\n", 14 | "\n", 15 | "### Forward Propagation\n", 16 | "\n", 17 | "Given a weight vector $W$, bias scalar $b$, and activation function $\\sigma$, activation $a$ describing forward propagation is given by:\n", 18 | "\n", 19 | "$$ a = \\sigma (W^T x + b) = (a_1, a_2, ..., a_{m-1}, a_m) \\tag{1}$$\n", 20 | "\n", 21 | "The equivalent Python code is:\n", 22 | "\n", 23 | "`a = sigmoid(np.dot(W.T, x) + b)`\n", 24 | "\n", 25 | "Other activation functions, such as a [rectified linear unit](https://en.wikipedia.org/wiki/Rectifier_(neural_networks)) (ReLU) or [softmax](https://en.wikipedia.org/wiki/Softmax_function) can also be used in place of [sigmoid functions](https://en.wikipedia.org/wiki/Sigmoid_function). ReLU does not suffer from the [vanishing gradient problem](https://en.wikipedia.org/wiki/Vanishing_gradient_problem) as found in the traditional sigmoid function. For this reason, ReLU is preferred in hidden layers of deep neural networks. Softmax is often used at the output layer of a classification model." 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "### Cost Function\n", 33 | "\n", 34 | "Training through backpropagation is an iterative process of computing the vector $W$ and bias $b$. Training attempts to minimize _loss_ or the _cost function_ given by $J$:\n", 35 | "\n", 36 | "$$ J = -\\frac{1}{m} \\sum_{i=1}^{m} y_i log(a_i) + (1 - y_i) log(1 - a_i)\\tag{2}$$\n", 37 | "\n", 38 | "`j = (-1/m)*(y.dot(np.log(a.T)) + (1-y).dot(np.log(1 - a.T)))`" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "### Gradients\n", 46 | "\n", 47 | "Gradients are partial derivatives used to iteratively update weights and biases. The _learning rate_ $\\alpha$ is a hyperparameter tuned for optimal training. This the most basic form of backpropagation. More sophisticated algorithms, such as [Adaptive Moment Estimation](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Adam) (ADAM) are more efficient.\n", 48 | "\n", 49 | "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m} x \\cdot (a - y)^T \\tag{3}$$\n", 50 | "\n", 51 | "`dw = (1/m) * np.dot(x, (a - y).T)`" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^{m} (a_i - y_i) \\tag{4}$$\n", 59 | "\n", 60 | "`db = (1/m) * np.sum(a - y)`" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "$$ W_{n+1} = W_n - \\alpha \\frac{\\partial J}{\\partial w}\\tag{5}$$\n", 68 | "\n", 69 | "`w = w - learning_rate * dw`" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "$$ b_{n+1} = b_n - \\alpha \\frac{\\partial J}{\\partial b}\\tag{6}$$\n", 77 | "\n", 78 | "`b = b - learning_rate * db`" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "### Gradient Derivation\n", 86 | "\n", 87 | "To compute the gradient, it is necessary to compute the derivative of the loss function. In simplified form, it looks like this:\n", 88 | "\n", 89 | "$$ \\mathcal L = -(y log(a) + (1 - y) log(1 - a))$$\n", 90 | "\n", 91 | "The sigmoid function is:\n", 92 | "\n", 93 | "$$ a = \\sigma(z) = \\frac{1}{1 + e^{-z}} $$\n", 94 | "\n", 95 | "To find the derivative of $\\mathcal L$ with respect to $z$, we can use the chain rule:\n", 96 | "\n", 97 | "$$ \\frac{d \\mathcal L}{dz} = \\frac{d\\mathcal L}{da} \\frac{da}{dz}$$\n", 98 | "\n", 99 | "Using basic derivative rules, we can find these derivatives. It is based on known derivatives of elementary functions and algebraic substitutions. The first term is:\n", 100 | "\n", 101 | "$$ \\frac{d\\mathcal L}{da} = -\\frac{y}{a} + \\frac{1-y}{1-a}$$\n", 102 | "\n", 103 | "The second term is:\n", 104 | "\n", 105 | "$$ \\frac{da}{dz} = a (1 - a)$$\n", 106 | "\n", 107 | "Then substituting above:\n", 108 | "\n", 109 | "$$ \\frac{d\\mathcal L}{dz} = \\left(-\\frac{y}{a} + \\frac{1-y}{1-a} \\right) (a (1 - a))$$\n", 110 | "\n", 111 | "Then simplifying:\n", 112 | "\n", 113 | "$$ \\frac{d\\mathcal L}{dz} = -y(1-a) + a(1-y)$$\n", 114 | "\n", 115 | "This produces a surprisingly simple result:\n", 116 | "\n", 117 | "$$ \\frac{d\\mathcal L}{dz} = a - y $$" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [] 126 | } 127 | ], 128 | "metadata": { 129 | "kernelspec": { 130 | "display_name": "Python 3", 131 | "language": "python", 132 | "name": "python3" 133 | }, 134 | "language_info": { 135 | "codemirror_mode": { 136 | "name": "ipython", 137 | "version": 3 138 | }, 139 | "file_extension": ".py", 140 | "mimetype": "text/x-python", 141 | "name": "python", 142 | "nbconvert_exporter": "python", 143 | "pygments_lexer": "ipython3", 144 | "version": "3.6.8" 145 | } 146 | }, 147 | "nbformat": 4, 148 | "nbformat_minor": 2 149 | } 150 | -------------------------------------------------------------------------------- /Regression/images/iris_versicolor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/Regression/images/iris_versicolor.png -------------------------------------------------------------------------------- /Regression/images/perceptron75.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/Regression/images/perceptron75.png -------------------------------------------------------------------------------- /Sequence/data/airline-passengers.csv: -------------------------------------------------------------------------------- 1 | "Month","Passengers" 2 | "1949-01",112 3 | "1949-02",118 4 | "1949-03",132 5 | "1949-04",129 6 | "1949-05",121 7 | "1949-06",135 8 | "1949-07",148 9 | "1949-08",148 10 | "1949-09",136 11 | "1949-10",119 12 | "1949-11",104 13 | "1949-12",118 14 | "1950-01",115 15 | "1950-02",126 16 | "1950-03",141 17 | "1950-04",135 18 | "1950-05",125 19 | "1950-06",149 20 | "1950-07",170 21 | "1950-08",170 22 | "1950-09",158 23 | "1950-10",133 24 | "1950-11",114 25 | "1950-12",140 26 | "1951-01",145 27 | "1951-02",150 28 | "1951-03",178 29 | "1951-04",163 30 | "1951-05",172 31 | "1951-06",178 32 | "1951-07",199 33 | "1951-08",199 34 | "1951-09",184 35 | "1951-10",162 36 | "1951-11",146 37 | "1951-12",166 38 | "1952-01",171 39 | "1952-02",180 40 | "1952-03",193 41 | "1952-04",181 42 | "1952-05",183 43 | "1952-06",218 44 | "1952-07",230 45 | "1952-08",242 46 | "1952-09",209 47 | "1952-10",191 48 | "1952-11",172 49 | "1952-12",194 50 | "1953-01",196 51 | "1953-02",196 52 | "1953-03",236 53 | "1953-04",235 54 | "1953-05",229 55 | "1953-06",243 56 | "1953-07",264 57 | "1953-08",272 58 | "1953-09",237 59 | "1953-10",211 60 | "1953-11",180 61 | "1953-12",201 62 | "1954-01",204 63 | "1954-02",188 64 | "1954-03",235 65 | "1954-04",227 66 | "1954-05",234 67 | "1954-06",264 68 | "1954-07",302 69 | "1954-08",293 70 | "1954-09",259 71 | "1954-10",229 72 | "1954-11",203 73 | "1954-12",229 74 | "1955-01",242 75 | "1955-02",233 76 | "1955-03",267 77 | "1955-04",269 78 | "1955-05",270 79 | "1955-06",315 80 | "1955-07",364 81 | "1955-08",347 82 | "1955-09",312 83 | "1955-10",274 84 | "1955-11",237 85 | "1955-12",278 86 | "1956-01",284 87 | "1956-02",277 88 | "1956-03",317 89 | "1956-04",313 90 | "1956-05",318 91 | "1956-06",374 92 | "1956-07",413 93 | "1956-08",405 94 | "1956-09",355 95 | "1956-10",306 96 | "1956-11",271 97 | "1956-12",306 98 | "1957-01",315 99 | "1957-02",301 100 | "1957-03",356 101 | "1957-04",348 102 | "1957-05",355 103 | "1957-06",422 104 | "1957-07",465 105 | "1957-08",467 106 | "1957-09",404 107 | "1957-10",347 108 | "1957-11",305 109 | "1957-12",336 110 | "1958-01",340 111 | "1958-02",318 112 | "1958-03",362 113 | "1958-04",348 114 | "1958-05",363 115 | "1958-06",435 116 | "1958-07",491 117 | "1958-08",505 118 | "1958-09",404 119 | "1958-10",359 120 | "1958-11",310 121 | "1958-12",337 122 | "1959-01",360 123 | "1959-02",342 124 | "1959-03",406 125 | "1959-04",396 126 | "1959-05",420 127 | "1959-06",472 128 | "1959-07",548 129 | "1959-08",559 130 | "1959-09",463 131 | "1959-10",407 132 | "1959-11",362 133 | "1959-12",405 134 | "1960-01",417 135 | "1960-02",391 136 | "1960-03",419 137 | "1960-04",461 138 | "1960-05",472 139 | "1960-06",535 140 | "1960-07",622 141 | "1960-08",606 142 | "1960-09",508 143 | "1960-10",461 144 | "1960-11",390 145 | "1960-12",432 -------------------------------------------------------------------------------- /Text/.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Byte-compiled / optimized / DLL files 3 | __pycache__/ 4 | *.py[cod] 5 | *$py.class 6 | 7 | # Jupyter Notebook 8 | .ipynb_checkpoints 9 | 10 | data 11 | -------------------------------------------------------------------------------- /Text/Alphabet.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Learning the Alphabet\n", 8 | "\n", 9 | "This is an example of a simple [LSTM](https://en.wikipedia.org/wiki/Long_short-term_memory) that is powerful enough to learn the alphabet. It is trained with strings that look like the alphabet.\n", 10 | "\n", 11 | "While this seems trivial, RNNs are capable of learning more complex text sequences, such as the works of Shakespeare or computer source code. Although training RNNs is computationally more expensive compared with other network structures, this example is simple enough to train on a CPU." 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "name": "stderr", 21 | "output_type": "stream", 22 | "text": [ 23 | "Using TensorFlow backend.\n" 24 | ] 25 | } 26 | ], 27 | "source": [ 28 | "# See https://machinelearningmastery.com/text-generation-lstm-recurrent-neural-networks-python-keras/\n", 29 | "# Small LSTM Network to Generate Text for Alice in Wonderland\n", 30 | "import sys\n", 31 | "import numpy\n", 32 | "from keras.models import Sequential\n", 33 | "from keras.layers import Dense\n", 34 | "from keras.layers import Dropout\n", 35 | "from keras.layers import LSTM\n", 36 | "from keras.callbacks import ModelCheckpoint\n", 37 | "from keras.utils import np_utils\n", 38 | "from matplotlib import pyplot as plt" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "## Training Data\n", 46 | "\n", 47 | "The training data is generated using characters from 'a' to 'z'. Several sequences are concatenated to produce a longer sequence of characters." 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 2, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "name": "stdout", 57 | "output_type": "stream", 58 | "text": [ 59 | "Subset of training data: abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl\n", 60 | "Total Characters: 208\n", 61 | "Total Vocab: 26\n" 62 | ] 63 | } 64 | ], 65 | "source": [ 66 | "# load ascii text and covert to lowercase\n", 67 | "raw_text = ''.join([chr(x) for x in range(ord('a'), ord('z')+1)])\n", 68 | "raw_text += raw_text\n", 69 | "raw_text += raw_text\n", 70 | "raw_text += raw_text\n", 71 | "# create mapping of unique chars to integers\n", 72 | "chars = sorted(list(set(raw_text)))\n", 73 | "char_to_int = dict((c, i) for i, c in enumerate(chars))\n", 74 | "int_to_char = dict((i, c) for i, c in enumerate(chars))\n", 75 | "\n", 76 | "print(\"Subset of training data: %s\" % raw_text[0:64])\n", 77 | "# summarize the loaded data\n", 78 | "n_chars = len(raw_text)\n", 79 | "n_vocab = len(chars)\n", 80 | "print(\"Total Characters: \", n_chars)\n", 81 | "print(\"Total Vocab: \", n_vocab)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "## Prepare Sequences\n", 89 | "\n", 90 | "Input and expected output sequences are prepared and encoded as integers." 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 3, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | "Total Patterns: 198\n" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "seq_length = 10\n", 108 | "dataX = []\n", 109 | "dataY = []\n", 110 | "for i in range(0, n_chars - seq_length, 1):\n", 111 | " seq_in = raw_text[i:i + seq_length]\n", 112 | " seq_out = raw_text[i + seq_length]\n", 113 | " dataX.append([char_to_int[char] for char in seq_in])\n", 114 | " dataY.append(char_to_int[seq_out])\n", 115 | "n_patterns = len(dataX)\n", 116 | "print(\"Total Patterns: \", n_patterns)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "## Train Model" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 4, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "name": "stdout", 133 | "output_type": "stream", 134 | "text": [ 135 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", 136 | "Instructions for updating:\n", 137 | "Colocations handled automatically by placer.\n", 138 | "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n", 139 | "Instructions for updating:\n", 140 | "Use tf.cast instead.\n", 141 | "Epoch 1/100\n", 142 | " - 2s - loss: 3.2691\n", 143 | "Epoch 2/100\n", 144 | " - 1s - loss: 3.2344\n", 145 | "Epoch 3/100\n", 146 | " - 2s - loss: 3.1111\n", 147 | "Epoch 4/100\n", 148 | " - 2s - loss: 2.7656\n", 149 | "Epoch 5/100\n", 150 | " - 2s - loss: 2.4020\n", 151 | "Epoch 6/100\n", 152 | " - 2s - loss: 2.1680\n", 153 | "Epoch 7/100\n", 154 | " - 2s - loss: 2.0238\n", 155 | "Epoch 8/100\n", 156 | " - 2s - loss: 1.9023\n", 157 | "Epoch 9/100\n", 158 | " - 2s - loss: 1.8063\n", 159 | "Epoch 10/100\n", 160 | " - 1s - loss: 1.7181\n", 161 | "Epoch 11/100\n", 162 | " - 1s - loss: 1.6487\n", 163 | "Epoch 12/100\n", 164 | " - 2s - loss: 1.5739\n", 165 | "Epoch 13/100\n", 166 | " - 2s - loss: 1.5074\n", 167 | "Epoch 14/100\n", 168 | " - 1s - loss: 1.4387\n", 169 | "Epoch 15/100\n", 170 | " - 1s - loss: 1.3887\n", 171 | "Epoch 16/100\n", 172 | " - 1s - loss: 1.3486\n", 173 | "Epoch 17/100\n", 174 | " - 2s - loss: 1.2746\n", 175 | "Epoch 18/100\n", 176 | " - 1s - loss: 1.2188\n", 177 | "Epoch 19/100\n", 178 | " - 2s - loss: 1.1613\n", 179 | "Epoch 20/100\n", 180 | " - 2s - loss: 1.1377\n", 181 | "Epoch 21/100\n", 182 | " - 2s - loss: 1.0963\n", 183 | "Epoch 22/100\n", 184 | " - 2s - loss: 1.1027\n", 185 | "Epoch 23/100\n", 186 | " - 2s - loss: 1.0026\n", 187 | "Epoch 24/100\n", 188 | " - 2s - loss: 0.9680\n", 189 | "Epoch 25/100\n", 190 | " - 2s - loss: 0.9487\n", 191 | "Epoch 26/100\n", 192 | " - 2s - loss: 0.9370\n", 193 | "Epoch 27/100\n", 194 | " - 2s - loss: 0.8963\n", 195 | "Epoch 28/100\n", 196 | " - 2s - loss: 0.8549\n", 197 | "Epoch 29/100\n", 198 | " - 2s - loss: 0.8634\n", 199 | "Epoch 30/100\n", 200 | " - 2s - loss: 0.8034\n", 201 | "Epoch 31/100\n", 202 | " - 2s - loss: 0.7815\n", 203 | "Epoch 32/100\n", 204 | " - 2s - loss: 0.8020\n", 205 | "Epoch 33/100\n", 206 | " - 2s - loss: 0.8441\n", 207 | "Epoch 34/100\n", 208 | " - 2s - loss: 0.7404\n", 209 | "Epoch 35/100\n", 210 | " - 2s - loss: 0.6956\n", 211 | "Epoch 36/100\n", 212 | " - 2s - loss: 0.6741\n", 213 | "Epoch 37/100\n", 214 | " - 2s - loss: 0.7116\n", 215 | "Epoch 38/100\n", 216 | " - 2s - loss: 0.6610\n", 217 | "Epoch 39/100\n", 218 | " - 2s - loss: 0.6172\n", 219 | "Epoch 40/100\n", 220 | " - 2s - loss: 0.6118\n", 221 | "Epoch 41/100\n", 222 | " - 2s - loss: 0.6096\n", 223 | "Epoch 42/100\n", 224 | " - 2s - loss: 0.6296\n", 225 | "Epoch 43/100\n", 226 | " - 2s - loss: 0.6748\n", 227 | "Epoch 44/100\n", 228 | " - 2s - loss: 0.5279\n", 229 | "Epoch 45/100\n", 230 | " - 2s - loss: 0.5105\n", 231 | "Epoch 46/100\n", 232 | " - 2s - loss: 0.4956\n", 233 | "Epoch 47/100\n", 234 | " - 2s - loss: 0.4951\n", 235 | "Epoch 48/100\n", 236 | " - 2s - loss: 0.5804\n", 237 | "Epoch 49/100\n", 238 | " - 2s - loss: 0.4541\n", 239 | "Epoch 50/100\n", 240 | " - 2s - loss: 0.4520\n", 241 | "Epoch 51/100\n", 242 | " - 2s - loss: 0.4722\n", 243 | "Epoch 52/100\n", 244 | " - 2s - loss: 0.4726\n", 245 | "Epoch 53/100\n", 246 | " - 2s - loss: 0.4023\n", 247 | "Epoch 54/100\n", 248 | " - 2s - loss: 0.5296\n", 249 | "Epoch 55/100\n", 250 | " - 2s - loss: 0.7200\n", 251 | "Epoch 56/100\n", 252 | " - 1s - loss: 0.4212\n", 253 | "Epoch 57/100\n", 254 | " - 2s - loss: 0.3737\n", 255 | "Epoch 58/100\n", 256 | " - 2s - loss: 0.3740\n", 257 | "Epoch 59/100\n", 258 | " - 2s - loss: 0.3553\n", 259 | "Epoch 60/100\n", 260 | " - 1s - loss: 0.3753\n", 261 | "Epoch 61/100\n", 262 | " - 2s - loss: 0.3418\n", 263 | "Epoch 62/100\n", 264 | " - 2s - loss: 0.3338\n", 265 | "Epoch 63/100\n", 266 | " - 2s - loss: 0.3265\n", 267 | "Epoch 64/100\n", 268 | " - 2s - loss: 0.4111\n", 269 | "Epoch 65/100\n", 270 | " - 2s - loss: 0.5852\n", 271 | "Epoch 66/100\n", 272 | " - 2s - loss: 0.3046\n", 273 | "Epoch 67/100\n", 274 | " - 2s - loss: 0.2961\n", 275 | "Epoch 68/100\n", 276 | " - 1s - loss: 0.2914\n", 277 | "Epoch 69/100\n", 278 | " - 2s - loss: 0.2834\n", 279 | "Epoch 70/100\n", 280 | " - 2s - loss: 0.4003\n", 281 | "Epoch 71/100\n", 282 | " - 1s - loss: 0.6798\n", 283 | "Epoch 72/100\n", 284 | " - 1s - loss: 0.3171\n", 285 | "Epoch 73/100\n", 286 | " - 1s - loss: 0.2666\n", 287 | "Epoch 74/100\n", 288 | " - 2s - loss: 0.2647\n", 289 | "Epoch 75/100\n", 290 | " - 2s - loss: 0.2496\n", 291 | "Epoch 76/100\n", 292 | " - 1s - loss: 0.2631\n", 293 | "Epoch 77/100\n", 294 | " - 1s - loss: 0.2533\n", 295 | "Epoch 78/100\n", 296 | " - 2s - loss: 0.2433\n", 297 | "Epoch 79/100\n", 298 | " - 1s - loss: 0.2386\n", 299 | "Epoch 80/100\n", 300 | " - 2s - loss: 0.2398\n", 301 | "Epoch 81/100\n", 302 | " - 1s - loss: 0.2918\n", 303 | "Epoch 82/100\n", 304 | " - 1s - loss: 0.3496\n", 305 | "Epoch 83/100\n", 306 | " - 1s - loss: 0.2171\n", 307 | "Epoch 84/100\n", 308 | " - 1s - loss: 0.2155\n", 309 | "Epoch 85/100\n", 310 | " - 1s - loss: 0.2028\n", 311 | "Epoch 86/100\n", 312 | " - 1s - loss: 0.2057\n", 313 | "Epoch 87/100\n", 314 | " - 1s - loss: 0.8091\n", 315 | "Epoch 88/100\n", 316 | " - 1s - loss: 0.4556\n", 317 | "Epoch 89/100\n", 318 | " - 1s - loss: 0.2023\n", 319 | "Epoch 90/100\n", 320 | " - 1s - loss: 0.2025\n", 321 | "Epoch 91/100\n", 322 | " - 1s - loss: 0.1921\n", 323 | "Epoch 92/100\n", 324 | " - 2s - loss: 0.2001\n", 325 | "Epoch 93/100\n", 326 | " - 2s - loss: 0.1850\n", 327 | "Epoch 94/100\n", 328 | " - 2s - loss: 0.1820\n", 329 | "Epoch 95/100\n", 330 | " - 2s - loss: 0.1812\n", 331 | "Epoch 96/100\n", 332 | " - 2s - loss: 0.1807\n", 333 | "Epoch 97/100\n", 334 | " - 2s - loss: 0.1694\n", 335 | "Epoch 98/100\n", 336 | " - 2s - loss: 0.1850\n", 337 | "Epoch 99/100\n", 338 | " - 2s - loss: 0.2218\n", 339 | "Epoch 100/100\n", 340 | " - 2s - loss: 0.8065\n" 341 | ] 342 | } 343 | ], 344 | "source": [ 345 | "# reshape X to be [samples, time steps, features]\n", 346 | "X = numpy.reshape(dataX, (n_patterns, seq_length, 1))\n", 347 | "# normalize\n", 348 | "X = X / float(n_vocab)\n", 349 | "# one hot encode the output variable\n", 350 | "y = np_utils.to_categorical(dataY)\n", 351 | "# define the LSTM model\n", 352 | "model = Sequential()\n", 353 | "model.add(LSTM(16, input_shape=(X.shape[1], X.shape[2])))\n", 354 | "#model.add(Dropout(0.2))\n", 355 | "model.add(Dense(y.shape[1], activation='softmax'))\n", 356 | "model.compile(loss='categorical_crossentropy', optimizer='adam')\n", 357 | "# define the checkpoint\n", 358 | "#filepath=\"weights-improvement-{epoch:02d}-{loss:.4f}.hdf5\"\n", 359 | "#checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')\n", 360 | "#callbacks_list = [checkpoint]\n", 361 | "# fit the model\n", 362 | "#model.fit(X, y, epochs=20, batch_size=128, callbacks=callbacks_list)\n", 363 | "history = model.fit(X, y, epochs=100, batch_size=1, verbose=2)" 364 | ] 365 | }, 366 | { 367 | "cell_type": "markdown", 368 | "metadata": {}, 369 | "source": [ 370 | "## Model Loss" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": 5, 376 | "metadata": {}, 377 | "outputs": [ 378 | { 379 | "data": { 380 | "image/png": "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\n", 381 | "text/plain": [ 382 | "
" 383 | ] 384 | }, 385 | "metadata": { 386 | "needs_background": "light" 387 | }, 388 | "output_type": "display_data" 389 | }, 390 | { 391 | "name": "stdout", 392 | "output_type": "stream", 393 | "text": [ 394 | "Minimum loss: 0.807\n" 395 | ] 396 | } 397 | ], 398 | "source": [ 399 | "plt.plot(history.history['loss'])\n", 400 | "plt.title('Model loss')\n", 401 | "plt.ylabel('Loss')\n", 402 | "plt.xlabel('Epoch')\n", 403 | "plt.legend(['Train'], loc='upper left')\n", 404 | "plt.show()\n", 405 | "print(\"Minimum loss: %.3f\" % history.history['loss'][-1])" 406 | ] 407 | }, 408 | { 409 | "cell_type": "markdown", 410 | "metadata": {}, 411 | "source": [ 412 | "## Prediction\n", 413 | "\n", 414 | "A random starting sequence is used to seed prediction. The output is almost perfect." 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": 6, 420 | "metadata": {}, 421 | "outputs": [ 422 | { 423 | "name": "stdout", 424 | "output_type": "stream", 425 | "text": [ 426 | "Seed:\n", 427 | "\" stuvwxyzab \"\n", 428 | "cdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\n", 429 | "All done!\n" 430 | ] 431 | } 432 | ], 433 | "source": [ 434 | "# pick a random seed\n", 435 | "start = numpy.random.randint(0, len(dataX)-1)\n", 436 | "pattern = dataX[start]\n", 437 | "#pattern = [start]\n", 438 | "print(\"Seed:\")\n", 439 | "print(\"\\\"\", ''.join([int_to_char[value] for value in pattern]), \"\\\"\")\n", 440 | "# generate characters\n", 441 | "for i in range(100):\n", 442 | " x = numpy.reshape(pattern, (1, len(pattern), 1))\n", 443 | " x = x / float(n_vocab)\n", 444 | " prediction = model.predict(x, verbose=0)\n", 445 | " index = numpy.argmax(prediction)\n", 446 | " result = int_to_char[index]\n", 447 | " seq_in = [int_to_char[value] for value in pattern]\n", 448 | " sys.stdout.write(result)\n", 449 | " pattern.append(index)\n", 450 | " pattern = pattern[1:len(pattern)]\n", 451 | "print(\"\\nAll done!\")" 452 | ] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": null, 457 | "metadata": {}, 458 | "outputs": [], 459 | "source": [] 460 | } 461 | ], 462 | "metadata": { 463 | "kernelspec": { 464 | "display_name": "Python 3", 465 | "language": "python", 466 | "name": "python3" 467 | }, 468 | "language_info": { 469 | "codemirror_mode": { 470 | "name": "ipython", 471 | "version": 3 472 | }, 473 | "file_extension": ".py", 474 | "mimetype": "text/x-python", 475 | "name": "python", 476 | "nbconvert_exporter": "python", 477 | "pygments_lexer": "ipython3", 478 | "version": "3.6.8" 479 | } 480 | }, 481 | "nbformat": 4, 482 | "nbformat_minor": 2 483 | } 484 | -------------------------------------------------------------------------------- /images/practical_example_icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/images/practical_example_icon.png -------------------------------------------------------------------------------- /images/practical_intro_icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/msiddalingaiah/MachineLearning/024319cf6c842e18ce618fae7338b395c72c8ff4/images/practical_intro_icon.png --------------------------------------------------------------------------------