diff --git a/Jupyter Notebook/Predicting_Head_Circumference.ipynb b/Jupyter Notebook/Predicting_Head_Circumference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..e841f7074d97ff3747ea1e806c55356b59e1dcd0 --- /dev/null +++ b/Jupyter Notebook/Predicting_Head_Circumference.ipynb @@ -0,0 +1,968 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X = df.drop('prediction',axis = 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "y = df['prediction']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#mean squared error" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n", + "C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n", + " np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n", + "WARNING:tensorflow:From C:\\Users\\Ankit\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n", + "\n", + "Train: 0.255, Test: 0.259\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# mlp for regression with mse loss function\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from keras.models import Sequential\n", + "from keras.layers import Dense\n", + "from keras.optimizers import adam\n", + "from matplotlib import pyplot\n", + "import tensorflow as tf\n", + "# from tensorflow.keras.layers import Dropout\n", + "%matplotlib inline\n", + "# # standardize dataset\n", + "# X = StandardScaler().fit_transform(X)\n", + "# y = StandardScaler().fit_transform(y.reshape(len(y),1))[:,0]\n", + "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.10, random_state=101)\n", + "# # split into train and test\n", + "# n_train = 400\n", + "trainX, testX = X_train, X_test\n", + "trainy, testy = y_train, y_test\n", + "# define model\n", + "model = Sequential()\n", + "model.add(Dense(35, input_dim=300, activation='relu', kernel_initializer='he_uniform',kernel_regularizer=tf.keras.regularizers.l1(0.027)))\n", + "model.add(Dense(1, activation='linear'))\n", + "opt = adam(lr=0.007)\n", + "model.compile(loss='mean_squared_logarithmic_error', optimizer=opt)\n", + "# fit model\n", + "# model = tf.keras.layers.Dropout(0.2)(model)\n", + "history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=150, verbose=0)\n", + "# evaluate the model\n", + "train_mse = model.evaluate(trainX, trainy, verbose=0)\n", + "test_mse = model.evaluate(testX, testy, verbose=0)\n", + "print('Train: %.3f, Test: %.3f' % (train_mse, test_mse))\n", + "# plot loss during training\n", + "pyplot.title('Loss / Mean Squared Error')\n", + "pyplot.plot(history.history['loss'], label='train')\n", + "pyplot.plot(history.history['val_loss'], label='test')\n", + "pyplot.legend()\n", + "pyplot.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "dense_1 (Dense) (None, 35) 10535 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 1) 36 \n", + "=================================================================\n", + "Total params: 10,571\n", + "Trainable params: 10,571\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 469, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[162.75146],\n", + " [151.50139],\n", + " [155.3321 ],\n", + " [158.67656],\n", + " [151.41573],\n", + " [154.4763 ],\n", + " [155.77385],\n", + " [158.97722],\n", + " [154.92319],\n", + " [161.4363 ],\n", + " [154.85971],\n", + " [165.7712 ],\n", + " [152.89317],\n", + " [156.19144],\n", + " [159.28343],\n", + " [152.13078],\n", + " [162.68411],\n", + " [160.30142],\n", + " [152.42526],\n", + " [152.1954 ],\n", + " [151.62784],\n", + " [152.07858],\n", + " [164.87306],\n", + " [157.25246],\n", + " [158.15411],\n", + " [153.04169],\n", + " [152.0335 ],\n", + " [159.03221],\n", + " [156.83546],\n", + " [156.05266],\n", + " [151.72386],\n", + " [155.62827],\n", + " [157.19202],\n", + " [158.28992],\n", + " [151.59874],\n", + " [154.05344],\n", + " [161.24487],\n", + " [162.09244],\n", + " [156.13434],\n", + " [157.12901],\n", + " [164.66698],\n", + " [151.78601],\n", + " [159.86244],\n", + " [158.68507]], dtype=float32)" + ] + }, + "execution_count": 469, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict(testX)" + ] + }, + { + "cell_type": "code", + "execution_count": 470, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.axes._subplots.AxesSubplot at 0x1ffd7d5cc88>" + ] + }, + "execution_count": 470, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "sns.distplot(testy)\n", + "sns.distplot(model.predict(testX))" + ] + }, + { + "cell_type": "code", + "execution_count": 471, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(testy)" + ] + }, + { + "cell_type": "code", + "execution_count": 472, + "metadata": {}, + "outputs": [], + "source": [ + "df['a'] = model.predict(testX)" + ] + }, + { + "cell_type": "code", + "execution_count": 473, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>prediction</th>\n", + " <th>a</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>12</th>\n", + " <td>121.31</td>\n", + " <td>162.751465</td>\n", + " </tr>\n", + " <tr>\n", + " <th>19</th>\n", + " <td>100.70</td>\n", + " <td>151.501389</td>\n", + " </tr>\n", + " <tr>\n", + " <th>268</th>\n", + " <td>169.04</td>\n", + " <td>155.332108</td>\n", + " </tr>\n", + " <tr>\n", + " <th>379</th>\n", + " <td>177.52</td>\n", + " <td>158.676559</td>\n", + " </tr>\n", + " <tr>\n", + " <th>202</th>\n", + " <td>164.96</td>\n", + " <td>151.415726</td>\n", + " </tr>\n", + " <tr>\n", + " <th>395</th>\n", + " <td>168.86</td>\n", + " <td>154.476303</td>\n", + " </tr>\n", + " <tr>\n", + " <th>398</th>\n", + " <td>177.90</td>\n", + " <td>155.773849</td>\n", + " </tr>\n", + " <tr>\n", + " <th>370</th>\n", + " <td>169.61</td>\n", + " <td>158.977219</td>\n", + " </tr>\n", + " <tr>\n", + " <th>216</th>\n", + " <td>175.09</td>\n", + " <td>154.923187</td>\n", + " </tr>\n", + " <tr>\n", + " <th>413</th>\n", + " <td>195.90</td>\n", + " <td>161.436295</td>\n", + " </tr>\n", + " <tr>\n", + " <th>209</th>\n", + " <td>166.40</td>\n", + " <td>154.859711</td>\n", + " </tr>\n", + " <tr>\n", + " <th>89</th>\n", + " <td>165.60</td>\n", + " <td>165.771194</td>\n", + " </tr>\n", + " <tr>\n", + " <th>382</th>\n", + " <td>173.85</td>\n", + " <td>152.893173</td>\n", + " </tr>\n", + " <tr>\n", + " <th>374</th>\n", + " <td>183.62</td>\n", + " <td>156.191437</td>\n", + " </tr>\n", + " <tr>\n", + " <th>289</th>\n", + " <td>175.87</td>\n", + " <td>159.283432</td>\n", + " </tr>\n", + " <tr>\n", + " <th>376</th>\n", + " <td>166.70</td>\n", + " <td>152.130783</td>\n", + " </tr>\n", + " <tr>\n", + " <th>408</th>\n", + " <td>171.35</td>\n", + " <td>162.684113</td>\n", + " </tr>\n", + " <tr>\n", + " <th>277</th>\n", + " <td>177.06</td>\n", + " <td>160.301422</td>\n", + " </tr>\n", + " <tr>\n", + " <th>349</th>\n", + " <td>171.69</td>\n", + " <td>152.425262</td>\n", + " </tr>\n", + " <tr>\n", + " <th>283</th>\n", + " <td>184.60</td>\n", + " <td>152.195404</td>\n", + " </tr>\n", + " <tr>\n", + " <th>291</th>\n", + " <td>168.35</td>\n", + " <td>151.627838</td>\n", + " </tr>\n", + " <tr>\n", + " <th>117</th>\n", + " <td>166.89</td>\n", + " <td>152.078583</td>\n", + " </tr>\n", + " <tr>\n", + " <th>130</th>\n", + " <td>168.92</td>\n", + " <td>164.873062</td>\n", + " </tr>\n", + " <tr>\n", + " <th>423</th>\n", + " <td>174.70</td>\n", + " <td>157.252457</td>\n", + " </tr>\n", + " <tr>\n", + " <th>91</th>\n", + " <td>176.30</td>\n", + " <td>158.154114</td>\n", + " </tr>\n", + " <tr>\n", + " <th>156</th>\n", + " <td>175.00</td>\n", + " <td>153.041687</td>\n", + " </tr>\n", + " <tr>\n", + " <th>168</th>\n", + " <td>163.18</td>\n", + " <td>152.033493</td>\n", + " </tr>\n", + " <tr>\n", + " <th>161</th>\n", + " <td>164.40</td>\n", + " <td>159.032211</td>\n", + " </tr>\n", + " <tr>\n", + " <th>69</th>\n", + " <td>171.98</td>\n", + " <td>156.835464</td>\n", + " </tr>\n", + " <tr>\n", + " <th>153</th>\n", + " <td>166.80</td>\n", + " <td>156.052658</td>\n", + " </tr>\n", + " <tr>\n", + " <th>304</th>\n", + " <td>180.43</td>\n", + " <td>151.723862</td>\n", + " </tr>\n", + " <tr>\n", + " <th>307</th>\n", + " <td>172.19</td>\n", + " <td>155.628265</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>106.52</td>\n", + " <td>157.192017</td>\n", + " </tr>\n", + " <tr>\n", + " <th>106</th>\n", + " <td>174.13</td>\n", + " <td>158.289917</td>\n", + " </tr>\n", + " <tr>\n", + " <th>31</th>\n", + " <td>125.25</td>\n", + " <td>151.598740</td>\n", + " </tr>\n", + " <tr>\n", + " <th>128</th>\n", + " <td>162.33</td>\n", + " <td>154.053436</td>\n", + " </tr>\n", + " <tr>\n", + " <th>167</th>\n", + " <td>174.89</td>\n", + " <td>161.244873</td>\n", + " </tr>\n", + " <tr>\n", + " <th>39</th>\n", + " <td>156.27</td>\n", + " <td>162.092438</td>\n", + " </tr>\n", + " <tr>\n", + " <th>233</th>\n", + " <td>180.47</td>\n", + " <td>156.134338</td>\n", + " </tr>\n", + " <tr>\n", + " <th>213</th>\n", + " <td>175.62</td>\n", + " <td>157.129013</td>\n", + " </tr>\n", + " <tr>\n", + " <th>267</th>\n", + " <td>165.74</td>\n", + " <td>164.666977</td>\n", + " </tr>\n", + " <tr>\n", + " <th>356</th>\n", + " <td>166.80</td>\n", + " <td>151.786011</td>\n", + " </tr>\n", + " <tr>\n", + " <th>215</th>\n", + " <td>176.18</td>\n", + " <td>159.862442</td>\n", + " </tr>\n", + " <tr>\n", + " <th>81</th>\n", + " <td>176.80</td>\n", + " <td>158.685074</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " prediction a\n", + "12 121.31 162.751465\n", + "19 100.70 151.501389\n", + "268 169.04 155.332108\n", + "379 177.52 158.676559\n", + "202 164.96 151.415726\n", + "395 168.86 154.476303\n", + "398 177.90 155.773849\n", + "370 169.61 158.977219\n", + "216 175.09 154.923187\n", + "413 195.90 161.436295\n", + "209 166.40 154.859711\n", + "89 165.60 165.771194\n", + "382 173.85 152.893173\n", + "374 183.62 156.191437\n", + "289 175.87 159.283432\n", + "376 166.70 152.130783\n", + "408 171.35 162.684113\n", + "277 177.06 160.301422\n", + "349 171.69 152.425262\n", + "283 184.60 152.195404\n", + "291 168.35 151.627838\n", + "117 166.89 152.078583\n", + "130 168.92 164.873062\n", + "423 174.70 157.252457\n", + "91 176.30 158.154114\n", + "156 175.00 153.041687\n", + "168 163.18 152.033493\n", + "161 164.40 159.032211\n", + "69 171.98 156.835464\n", + "153 166.80 156.052658\n", + "304 180.43 151.723862\n", + "307 172.19 155.628265\n", + "2 106.52 157.192017\n", + "106 174.13 158.289917\n", + "31 125.25 151.598740\n", + "128 162.33 154.053436\n", + "167 174.89 161.244873\n", + "39 156.27 162.092438\n", + "233 180.47 156.134338\n", + "213 175.62 157.129013\n", + "267 165.74 164.666977\n", + "356 166.80 151.786011\n", + "215 176.18 159.862442\n", + "81 176.80 158.685074" + ] + }, + "execution_count": 473, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 474, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12 0.341616\n", + "19 0.504483\n", + "268 0.081093\n", + "379 0.106148\n", + "202 0.082106\n", + "395 0.085181\n", + "398 0.124374\n", + "370 0.062690\n", + "216 0.115180\n", + "413 0.175925\n", + "209 0.069353\n", + "89 0.001034\n", + "382 0.120545\n", + "374 0.149377\n", + "289 0.094312\n", + "376 0.087398\n", + "408 0.050574\n", + "277 0.094649\n", + "349 0.112207\n", + "283 0.175540\n", + "291 0.099330\n", + "117 0.088750\n", + "130 0.023958\n", + "423 0.099871\n", + "91 0.102926\n", + "156 0.125476\n", + "168 0.068308\n", + "161 0.032651\n", + "69 0.088060\n", + "153 0.064433\n", + "304 0.159098\n", + "307 0.096183\n", + "2 0.475704\n", + "106 0.090967\n", + "31 0.210369\n", + "128 0.050986\n", + "167 0.078021\n", + "39 0.037259\n", + "233 0.134846\n", + "213 0.105290\n", + "267 0.006474\n", + "356 0.090012\n", + "215 0.092619\n", + "81 0.102460\n", + "dtype: float64" + ] + }, + "execution_count": 474, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(((df['prediction'] - df['a'])/df['prediction'])**2)**0.5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}