{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load in \n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the \"../input/\" directory.\n# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n\nimport os\nprint(os.listdir(\"../input\"))\nimport gc\ngc.collect()\n# Any results you write to the current directory are saved as output.","execution_count":1,"outputs":[{"output_type":"stream","text":"['test', 'train.csv', 'sample_submission.csv']\n","name":"stdout"},{"output_type":"execute_result","execution_count":1,"data":{"text/plain":"0"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"### Importing Data by changing bits so as to fully Load the data in memory"},{"metadata":{"trusted":true},"cell_type":"code","source":"import pandas as pd\ntrain_df=pd.read_csv('../input/train.csv',iterator=True,chunksize=150_000, dtype={'acoustic_data':np.int16,'time_to_failure':np.float32})","execution_count":2,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Checking no of rows in sample_submission.csv"},{"metadata":{"trusted":true},"cell_type":"code","source":"submission=pd.read_csv('../input/sample_submission.csv')\nprint(\"No. of rows in submission :{}\".format(submission.shape[0]))","execution_count":3,"outputs":[{"output_type":"stream","text":"No. of rows in submission :2624\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"### No of files in test.zip "},{"metadata":{"trusted":true},"cell_type":"code","source":"len(os.listdir('../input/test'))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### since we have same No. of folders in test directory as No. of rows in submission, means we have to predict time_to_failure for all of the test files"},{"metadata":{"trusted":true},"cell_type":"code","source":"def gen_features(X):\n    strain = []\n    strain.append(X.mean())\n    strain.append(X.std())\n    strain.append(X.max())\n    strain.append(X.min())\n    strain.append(X.kurtosis())\n    strain.append(X.skew())\n    strain.append(np.quantile(X,0.01))\n    strain.append(np.quantile(X,0.05))\n    strain.append(np.quantile(X,0.95))\n    strain.append(np.quantile(X,0.99))\n    strain.append(np.abs(X).max())\n    strain.append(np.abs(X).mean())\n    strain.append(np.abs(X).std())\n    return pd.Series(strain)\n","execution_count":4,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#train = pd.read_csv('train.csv', iterator=True, chunksize=150_000, dtype={'acoustic_data': np.int16, 'time_to_failure': np.float64})\n\nX_train = pd.DataFrame()\ny_train = pd.Series()\nfor df in train_df:\n    ch = gen_features(df['acoustic_data'])\n    X_train = X_train.append(ch, ignore_index=True)\n    y_train = y_train.append(pd.Series(df['time_to_failure'].values[-1]))","execution_count":5,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train.columns=['ave', 'std', 'max', 'min','kurtosis','skew','1%_quantile','5%_quantile','95%_quantile',\n                                '99%_quantile','abs_max','abs_mean','abs_std']","execution_count":6,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\nscaler = StandardScaler()\nscaler.fit(X_train)\nX_train_scaled = scaler.transform(X_train)","execution_count":7,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"y_train.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nplt.figure(figsize=(10,10))\nsns.heatmap(X_train.corr(),cmap='YlGnBu')\nplt.show()","execution_count":12,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 720x720 with 2 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAm4AAAJ8CAYAAABHti2DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XucXXV97//XewIx3AqKSoFyqYoVDYiQIhxEoVrFK16wKtgjqI1WLNojtnikiooWtNafgrWNF9CiQqsVqCKoHFCkisRyCRdvRVoFFKFgQSAkzOf3x16J22GSTJjJrP1NXk8f+zHrttf67GUy+fD+rrV2qgpJkiSNvrG+C5AkSdLU2LhJkiQ1wsZNkiSpETZukiRJjbBxkyRJaoSNmyRJUiNs3CRJkhph4yZJktQIGzdJkqRGbNR3AeuLTXZ82Uh8BcUTP/L6vksYOXP8z5ORNT4Sf2vgf3453ncJK43Kl9lsvsVo/MUZG40yALj11tH4c7L11qNzUi589n6ZzePN5r+1d//XZ2f1s03V6Py/L0mSpNWycZMkSWqEQ6WSJKkJiXmTZ0CSJKkRJm6SJKkJMW/yDEiSJLXCxE2SJDXBa9xM3CRJkpph4iZJkppg4mbiJkmS1AwTN0mS1IRkJL+FalaZuEmSJDXCxE2SJDXCvMkzIEmS1AgTN0mS1ATvKjVxkyRJaoaNmyRJUiMcKpUkSU1wqNTETZIkqRkbVOKW5ExgB2Ae8EEGjesjq+rN3frDgQVV9fokLweOAuYClwCvq6r7eilckiQR86YN7gy8sqr2AhYwaMq+ALxgaP1LgNOT7NpN71dVewD3AYdN3FmShUkWJ1m8/M4frfvqJUnSBm2DStyAo5KsaNR2AH4XuC7JPsAPgccAFwNHAnsBl3Zfr7EJcPPEnVXVImARwCY7vqzWefWSJG3AvMZtA2rckhwAPA3Yt6ruSnIhgyHT04E/Ar4HfKGqKoNu7ZNV9Za+6pUkSZpoQ2pdtwRu65q2xwD7dMu/ABwMvIxBEwdwPnBIkocDJHlIkp1mu2BJkvRrydisvUbV6FY2884FNkpyLXAC8G2AqroNuBbYqaq+0y27BjgW+EqSK4GvAtv2UrUkSVJngxkqraqlwDNXse45kyw7AzhjXdclSZKmZpSTsNniGZAkSWrEBpO4SZKktoX0XULvTNwkSZIaYeImSZKa4DVuJm6SJEnNMHGTJElNMHEzcZMkSWqGjZskSVIjHCqVJElNcKjUxE2SJKkZJm6SJKkR5k2eAUmSpEaYuEmSpCZ4jZuJmyRJUjNM3GbIEz/y+r5LAOCSPz257xJW2mjOvL5LAOCX1x3ddwkAPOKdP+27hJW2332zvksA4BvP36rvEgBYNn5H3yWstNP8f+m7BADuXnpr3yUAMD5+X98ljJwfjd/bdwm/9l/7zerhTNxM3CRJkpph4iZJkpoQ8ybPgCRJUitM3CRJUhO8xs3ETZIkqRkmbpIkqQlJ+i6hdyZukiRJjTBxkyRJTfAaNxM3SZKkZti4SZIkraUkByX5fpIfJTlmkvU7JrkgyWVJrkzyrJk4rkOlkiSpCaPyAN4kc4APA38I/BS4NMnZVXXN0GbHAv9UVR9J8ljgHGDn6R57NM6AJElSO/YGflRV11XVvcDpwMETtingt7rpLYEbZ+LAJm6SJKkJs3lzQpKFwMKhRYuqalE3vT3wk6F1PwWeOGEXxwFfSfJnwGbA02aiLhs3SZKkCbombdEaN1y1lwGnVtX7k+wL/GOS+VU1Pp26bNwkSVITRuhxIDcAOwzN/063bNirgIMAqupbSeYBDwVuns6BR+YMSJIkNeJSYJckv5tkLvBS4OwJ2/wX8FSAJLsC84BfTPfAJm6SJKkJo3JXaVUtT/J64DxgDvCJqro6yTuBxVV1NvAm4KNJ/pzBjQqHV1VN99g2bkCSNzK46PCuSdYdDiyoqtfPemGSJGkkVdU5DB7xMbzsbUPT1wD7zfRxR6N17d8bgU37LkKSJK1GxmbvNaI2uMQtyWbAPzG4kHAO8M/AdsAFSW6pqgOTHAG8BbgduAJY2le9kiRJK2xwjRuDOzxurKpnAyTZEjgCOLCqbkmyLfAOYC/gl8AFwGV9FStJkgZG6K7S3myIZ2AJ8IdJTkyyf1X9csL6JwIXVtUvuqchn7GqHSVZmGRxksU3nnvWuqxZkiRpw0vcquoHSfYEngUcn+T8aexr5cP5DvjSxdO+U0SSJK1akr5L6N0Gl7gl2Q64q6pOA94H7AncAWzRbXIJ8JQkWyfZGHhxP5VKkiT9pg0ucQN2A96XZBxYBvwpsC9wbpIbu5sTjgO+xeDmhMt7q1SSJK00Ks9x69MG17hV1XkMHpg3bDFw0tA2pwCnzGZdkiRJa2LrKkmS1IgNLnGTJElt8nEgJm6SJEnNMHGTJElt8HEgJm6SJEmtMHGTJEltMG7yFEiSJLXCxE2SJLXBa9xM3CRJklph4iZJktpg4mbiJkmS1AoTN0mS1AbjJk+BJElSK0zcJElSE8pr3EzcJEmSWmHitp7ZaM68vktYafl99/RdwkgZu+GOvktY6Y5HbNp3CQAsG7+z7xIAuHf8V32XsNK8uQ/uuwQAqsb7LgGAO+/+Wd8lrDQq/98sWz46f15nnYGbiZskSVIrbNwkSZIa4VCpJElqw5hjpSZukiRJjTBxkyRJbfBxICZukiRJrTBxkyRJbTBwM3GTJElqhYmbJElqg3eVmrhJkiS1wsRNkiS1wbtKTdwkSZJaYeImSZLaYOBm4iZJktQKEzdJktQG7yo1cZMkSWqFiZskSWqDgZuJmyRJUitM3CRJUhPK57it34lbkp2TfC/JqUl+kOTTSZ6W5OIkP0yyd/f6VpLLkvxbkt/r3vvnST7RTe+W5Kokm/b7iSRJ0oZsvW7cOo8C3g88pnsdCjwJOBr4v8D3gP2r6gnA24D3dO/7IPCoJC8ATgFeU1V3zXLtkiRJK20IjduPq2pJVY0DVwPnV1UBS4CdgS2Bf05yFfAB4HEA3faHA/8IfL2qLp644yQLkyxOsvjGc8+alQ8jSdIGayyz9xpRG0LjtnRoenxofpzBNX7vAi6oqvnAc4F5Q9vvAtwJbDfZjqtqUVUtqKoF2x108IwXLkmSNGxDaNzWZEvghm768BULk2wJfAh4MrB1kkNmvzRJkrRSZvE1omzc4L3AXye5jN+8y/YDwIer6gfAq4ATkjy8jwIlSZJgPX8cSFVdD8wfmj98FesePfS2Y7v1rxza9icMbnKQJEl98XEgJm6SJEmtWK8TN0mStB4Z4bs9Z4uJmyRJUiNM3CRJUhsM3EzcJEmSWmHiJkmS2uBdpSZukiRJrTBxkyRJbTBxM3GTJElqhYmbJElqg3GTp0CSJKkVNm6SJEmNcKhUkiS1wZsTTNwkSZJaYeImSZLaYOBm4zZT5oxIdvnL647uu4SRs9lOx/ddAgBf+vYf913CSu++YjT+wO40//N9lwDAg+Zu2XcJK129eN++SwBg47FN+y4BgAfNeUjfJay0bPzOvksAYKPM67sE9cjGTZIkNaHGjNxG4z+7JUmStEYmbpIkqQ3eVWriJkmS1AoTN0mS1AYDNxM3SZKkVpi4SZKkNnhXqYmbJElSK0zcJElSG7yr1MRNkiSpFSZukiSpDQZuJm6SJEmtsHGTJElqhEOlkiSpDT4OxMRNkiSpFSZukiSpDSZuJm6SJEmtMHHrJHke8NiqOqHvWiRJ0v2VgZuN2wpVdTZwdt91SJIkrcoG0bgl2Rk4F/g28L+AS4FTgHcADwcOAx4LLKiq1yc5FfgfYAHw28BfVNXnZr1wSZL0a17jtkFd4/Yo4P3AY7rXocCTgKOB/zvJ9tt2658DTDp8mmRhksVJFt/w5bPWSdGSJEkrbBCJW+fHVbUEIMnVwPlVVUmWADtPsv2ZVTUOXJNkm8l2WFWLgEUAT/3yxbVuypYkSYBfMs+GlbgtHZoeH5ofZ/IGdnh7/6RIkqTebUiJmyRJapnXuG1QiZskSVLTNojEraquB+YPzR++inWnTlzfzW++biuUJElrZNzkKZAkSWrFBpG4SZKk9YB3lZq4SZIktcLGTZIkqREOlUqSpDb4OBATN0mSpFaYuEmSpCaUNyeYuEmSJLXCxk2SJLVhbBZfa5DkoCTfT/KjJMesZrsXJakkC9b+A9+fjZskSdJaSDIH+DDwTOCxwMuSPHaS7bYA3gBcMlPHtnGTJEltGMvsvVZvb+BHVXVdVd0LnA4cPMl27wJOBO6ZsVMwUzuSJElaXyRZmGTx0Gvh0OrtgZ8Mzf+0Wzb8/j2BHarqSzNZl3eVSpKkNsziXaVVtQhY9EDem2QM+Fvg8JmsCUzcJEmS1tYNwA5D87/TLVthC2A+cGGS64F9gLNn4gYFEzdJktSG0fnmhEuBXZL8LoOG7aXAoStWVtUvgYeumE9yIXB0VS2e7oFt3NYzj3jnT/suYaWxG+7ouwQAvvTtP+67BACevc8/9l3CSo86/nV9lwDA6z7zjL5LAGC8+q7g13b7h9H4tTw+fm/fJQCw0dVX9V3CSvc96sF9lwBA7rql7xJWuv7tj+u7hF5U1fIkrwfOA+YAn6iqq5O8E1hcVWevq2OPxm8ISZKkNRmZwA2q6hzgnAnL3raKbQ+YqeN6jZskSVIjTNwkSVITanSuceuNiZskSVIjbNwkSZIa4VCpJElqg0OlJm6SJEmtMHGTJEltmMWvvBpVJm6SJEmNMHGTJEltMG7yFEiSJLXCxE2SJLXBa9xM3CRJklph4iZJktrgc9xM3CRJklph4iZJktpg4mbiJkmS1IqRbNyS7Jzkqmm8/41JNn2A731nkqc90GNLkqR1o5JZe42qkWzcpiPJHOCNwANq3KrqbVX1tZmtSpIkafpGvnFL8ogklyV5c5KTh5Z/MckB3fSdSd6f5ArgrcB2wAVJLujWvyzJkiRXJTmxWzYnyandsiVJ/rxbfmqSQ7rpE5Jck+TKJH8zu59ckiT9hrFZfI2okb45IcnvAacDhwNPAHZaxaabAZdU1Zu6970SOLCqbkmyHXAisBdwG/CVJM8HfgJsX1Xzu/dsNeHYWwMvAB5TVTVxfbfNQmAhwO/92ZvZ/pkHT/MTS5IkrdoI95Q8DDgLOKyqrljDtvcBn1/Fut8HLqyqX1TVcuDTwJOB64BHJDkpyUHA/0x43y+Be4CPJ3khcNfEHVfVoqpaUFULbNokSdK6NsqN2y+B/wKe1M0v5zfrnTc0fU9V3bc2O6+q24DHAxcCrwU+NmH9cmBv4HPAc4Bz12b/kiRphiWz9xpRozxUei+DocrzktwJXA+8LskYsD2DpmpV7gC2AG4BvgN8KMlDGQyVvgw4qZu/t6o+n+T7wGnDO0iyObBpVZ2T5GIGCZ0kSVJvRrlxo6p+leQ5wFeB44EfA9cA1wL/vpq3LgLOTXJjVR2Y5BjgAiDAl6rqrCSPB07pGkGAt0zYxxbAWUnmde/7PzP2wSRJ0trzAbyj2bhV1fXA/G76dgbXqcHgmrfJtt98wvxJwElD858FPjthmyuAPSfZ1+FDs6tL9SRJkmbVSDZukiRJ92PiNtI3J0iSJGmIiZskSWqDgZuJmyRJUitM3CRJUhPKa9xM3CRJklph4iZJktowwt9oMFtM3CRJkhph4iZJktrgNW4mbpIkSa0wcZMkSW0wcDNxkyRJaoWNmyRJUiMcKpUkSU0YM24ycZMkSWqFidt6ZvvdN+u7hJXueMSmfZcAwLuvGI3/PnnU8a/ru4SVfnTs3/VdAgCLPz4a52S8RueK5x127LuC0bJ02236LmGluXP7rmBg/L4RKaQHPn/XxE2SJKkZJm6SJKkJJm4mbpIkSc0wcZMkSU2IkZuJmyRJUitM3CRJUhMM3EzcJEmSmmHiJkmSmmDiZuImSZLUDBM3SZLUhBg3mbhJkiS1wsRNkiQ1wWvcTNwkSZKaYeMmSZLUCIdKJUlSE8YcKjVxkyRJaoWJmyRJaoI3J2wAiVuS65M8tO86JEmSpsvETZIkNcHEbT1L3JJsluRLSa5IclWSlwyt2yTJl5P8STf/8iTfSXJ5kn9IMifJi5P8bbf+DUmu66YfkeTifj6VJEnSwHrVuAEHATdW1eOraj5wbrd8c+Bfgc9W1UeT7Aq8BNivqvYA7gMOAy4C9u/esz9wa5Ltu+lvTDxYkoVJFidZfMOXz1qnH0ySpA1dkll7jar1rXFbAvxhkhOT7F9Vv+yWnwWcUlWf6uafCuwFXJrk8m7+EVX1M2DzJFsAOwCfAZ7MoHG7aOLBqmpRVS2oqgXbP/PgdfvJJEnSBm+9usatqn6QZE/gWcDxSc7vVl0MHJTkM1VVQIBPVtVbJtnNvwFHAN9n0Ky9EtgXeNM6/wCSJGmV/JL59SxxS7IdcFdVnQa8D9izW/U24Dbgw938+cAhSR7eve8hSXbq1l0EHM1gaPQy4EBg6VB6J0mS1Iv1qnEDdgO+0w1/vh04fmjdG4BNkry3qq4BjgW+kuRK4KvAtt12FzEYJv1GVd0H/AT45mx9AEmSNLlk9l6jan0bKj0POG/C4p2Hpo8Y2vYM4IxJ9vEfDIZSV8w/fWarlCRJemDWq8ZNkiStv0Y5CZst69tQqSRJ0nrLxE2SJDXBxM3ETZIkqRk2bpIkSY1wqFSSJDVhzKFSEzdJkqRWmLhJkqQmeHOCiZskSVIzTNwkSVITTNxM3CRJkpph4iZJkpoQbys1cZMkSWqFiZskSWqC17jZuM2Y8eq7goFvPH+rvktYadn4nX2XAMBO8z/fdwkAvO4zz+i7hJUWf/x1fZcAwNde9Xd9lwDA3I236LuElW794ZF9lwDARmOb9F0CAEvvu73vElaaO2c0/pyM17K+S1CPbNwkSVITTNy8xk2SJKkZJm6SJKkJJm4mbpIkSc0wcZMkSU3wMW4mbpIkSc2wcZMkSWqEQ6WSJKkJ3pxg4iZJktQMEzdJktSEGDeZuEmSJLXCxE2SJDXBa9xM3CRJkpph4iZJkpoQIzcTN0mSpFaYuEmSpCYYuJm4SZIkNcPETZIkNcHEbZqJW5JPJLk5yVVDy05McmWSTw0te3mSN07nWDMhyVZJXjc0v12Sz3XTByT5Yn/VSZKkViQ5KMn3k/woyTGTrH9QkjO69Zck2XkmjjvdodJTgYNWzCTZEtizqnYH7k2yW5JNgCOAD0/zWDNhK2Bl41ZVN1bVIT3WI0mSpiiZvdfq68gcBn3NM4HHAi9L8tgJm70KuK2qHgV8ADhxJs7BtBq3qvoG8N9Di8aBjTO4X3dTYBlwNHBSVS1b3b6SbJLk9CTXJvlC150u6NbdObTdIUlO7aaf2213WZKvJdmmW35clwZemOS6JEd1bz8BeGSSy5O8L8nOw2nh0DE2697/nW7fBz/QcyRJktY7ewM/qqrrqupe4HRgYq9wMPDJbvpzwFMzA88zmdGbE6rqDuAc4DLgJuCXwBOr6swpvP1Pgbuqalfg7cBeU3jPN4F9quoJDE7aXwytewzwDAYn9+1JNgaOAf6jqvaoqjevZr9vBf5fVe0NHAi8L8lmEzdKsjDJ4iSLb/zyWVMoV5IkPVBjmb3X8L/x3WvhUCnbAz8Zmv9pt4zJtqmq5Qx6oq2new5m/OaEqnov8F6AJB8D3pbk1cDTgSur6vhVvPXJwIe6fVyZ5MopHO53gDOSbAvMBX48tO5LVbUUWJrkZmCbtfgYTweel+Tobn4esCNw7fBGVbUIWARw4DkX11rsX5IkjbDhf+NHyTp7HEiSJwABvg+8uKr+iMEw5S4PYHfDTdG8oemTgJOrajfgNRPWLR2avo+1a1IDvKhL5vaoqh2r6to1vkuSJK0zs5m4rcENwA5D87/TLZt0myQbAVsCt077HEx3B6vxLuCvgI2BOd2ycQbXvk3mG8ChAEnmA7sPrft5kl2TjAEvGFq+Jb8+Ua+YQk13AFtMYbvzgD9bMRbdNaGSJEkAlwK7JPndJHOBlwJnT9jmbH7dmxzC4BKsaY/OTfdxIJ8FvgX8XpKfJnlVt/z5wOLurs3bgcuTLAHmVdUVq9jdR4DNk1wLvBP47tC6Y4AvAv/G4Nq5FY4D/jnJd4Fb1lRvVd0KXJzkqiTvW82m72LQcF6Z5OpuXpIkacU1a69nEPRcC/xTVV2d5J1Jntdt9nFg6yQ/Av4Pg15m2qZ1jVtVvWwVy88EzhyaP5rB3aWr29fdDDpWAJJcOLTucwzuyJj4nrOA+90VUFXHTZifPzR96ITN53fLLwQuHKrlNaurV5Ikza6xjM7l5FV1DoMbMoeXvW1o+h7gxTN9XL/ySpIkqRGz/pVXSZ7B/R9C9+OqGr52jao6YNaKkiRJI28KNw2s92a9cauq8xiMCUuSJGkt+CXzkiSpCV7f5TmQJElqhombJElqwijdVdoXEzdJkqRGmLhJkqQmeFepiZskSVIzTNwkSVITTJs8B5IkSc0wcZMkSU3wGjcTN0mSpGaYuEmSpCbE57jZuM2U//nleN8lALBs/I6+S1jp3vFf9V0CAA+au2XfJQAwPkK/b8ZrNMYb5m68Rd8lAHDvstH5ezOW0fi1vGz8rr5LAODeEfqdlszpuwQAlo/f03cJK206Gn9cNygOlUqSJDXCXlmSJDXBmxNM3CRJkpph4iZJkppg2uQ5kCRJaoaJmyRJasKYjwMxcZMkSWqFiZskSWqCd5WauEmSJDXDxE2SJDXBtMlzIEmS1AwTN0mS1ASvcTNxkyRJaoaJmyRJaoLPcTNxkyRJaoaJmyRJaoLXuJm4SZIkNcPGTZIkqRHTatySXJ9kSZLLkyzulp2Y5Moknxra7uVJ3jjdYqcryVZJXjc0v12Sz3XTByT5Yn/VSZKk1RmbxdeomonaDqyqPapqQZItgT2ranfg3iS7JdkEOAL48Awca7q2AlY2blV1Y1Ud0mM9kiRJUzbTTeU4sHGSAJsCy4CjgZOqatnq3phkkySnJ7k2yReSXJJkQbfuzqHtDklyajf93G67y5J8Lck23fLjknwiyYVJrktyVPf2E4BHdgnh+5LsnOSqSWrZrHv/d7p9Hzz9UyNJkqZjLDVrr1E13catgK8k+W6ShVV1B3AOcBlwE/BL4IlVdeYU9vWnwF1VtSvwdmCvKbznm8A+VfUE4HTgL4bWPQZ4BrA38PYkGwPHAP/RJYRvXs1+3wr8v6raGzgQeF+SzSZulGRhksVJFt9y/tlTKFeSJOmBm+7jQJ5UVTckeTjw1STfq6r3Au8FSPIx4G1JXg08Hbiyqo5fxb6eDHwIoKquTHLlFI7/O8AZSbYF5gI/Hlr3papaCixNcjOwzVp8rqcDz0tydDc/D9gRuHZ4o6paBCwC2OuzF41uey5J0nrAx4FMM3Grqhu6nzcDX2CQbgGQ5AlAgO8DL66qP2IwTLnLAznU0PS8oemTgJOrajfgNRPWLR2avo+1a1IDvKhL5vaoqh2r6to1vkuSJGkdesCNW3cd2BYrphmkVMPXi70L+CtgY2BOt2ycwbVvk/kGcGi3v/nA7kPrfp5k1yRjwAuGlm8J3NBNv2IKZd8BbDGF7c4D/qy7Vm9FEypJkno0ltl7jarpJG7bAN9McgXwHQZDk+cCJHk+sLi7a/N24PIkS4B5VXXFKvb3EWDzJNcC7wS+O7TuGOCLwL8xuHZuheOAf07yXeCWNRVcVbcCFye5Ksn7VrPpuxg0nFcmubqblyRJ6tUDvsatqq4DHr+KdWcCZw7NH83g7tLV7e9u4KUr5pNcOLTuc8DnJnnPWcBZkyw/bsL8/KHpQydsPr9bfiFw4VAtr1ldvZIkaXaN8vPVZovnQJIkqRGz/iXzSZ4BnDhh8Y+ravjaNarqgFkrSpIkjbxRfr7abJn1xq2qzmNw8b8kSZLWwqw3bpIkSQ/EKN/tOVu8xk2SJKkRJm6SJKkJpk2eA0mSpGbYuEmSJDXCoVJJktQEb04wcZMkSWqGiZskSWpCfACviZskSVIrTNwkSVITvMbNxE2SJKkZJm4zpEZk2H2n+f/SdwkrzZv74L5LAODqxfv2XQIAu/3D6Px122HHvisYuPWHR/ZdAgBjGZ3/bzbb6fi+SwBg7sZb9F0CAFttvnPfJax0+53X910CAJs8aOu+S1jpZ9fsN6vHM23yHEiSJDVjdP4zU5IkaTXGvKvUxE2SJKkVJm6SJKkJ3lVq4iZJktQMEzdJktQEEzcTN0mSpGaYuEmSpCbM6buAEWDiJkmS1AgbN0mSpEY4VCpJkprgA3hN3CRJkpph4iZJkprg40BM3CRJkpph4iZJkppg4mbiJkmS1AwTN0mS1IQ5Jm4mbpIkSa2YUuOW5A1JrkpydZI3dsuOS3JDksu717O65fsluTLJ4iS7dMu2SvKVJL03ikkOT7Ld0PzHkjy2m74+yUP7q06SJK3KWGbvNarWOFSaZD7wJ8DewL3AuUm+2K3+QFX9zYS3vAl4FrAz8Npu/ljgPVU1PkN1T8fhwFXAjQBV9epeq5EkSZqiqSRguwKXVNVdVbUc+DrwwtVsvwzYtHstS/JIYIequnBNB0pyRJIfJPlOko8mOblbfmqSQ4a2u7P7uXmS85P8e5IlSQ7ulu+c5NpuH1d3ad8m3T4WAJ/uUsJNklyYZMEktby8q+PyJP+QxO+2lSSpR2OpWXuNqqk0blcB+yfZOsmmDNK0Hbp1r++GRT+R5MHdsr8GPgW8BTgZeDeDxG21kmwLvAPYD3gS8Ngp1HYP8IKq2hM4EHh/khUB5y7Ah6vqccDtwIuq6nPAYuCwqtqjqu5eRS27Ai8B9quqPYD7gMMm2W5hNyS8+Jb/d/YUypUkSXrg1jhUWlXXJjkR+ArwK+ByBo3MR4B3AdX9fD/wyqq6HNgHIMmTgZsGkzmDQRr3pqr6+SSHeiJwYVX9onvvGcCj11BegPd0xxkHtge26db9uKsF4LsMhm6n6qnAXsClXR+4CXDzxI2qahGwCGDPz1w0uu25JEnrgVG+9my2TOlxIFX1ceDjAEneA/x0uPlK8lHgi8Pv6ZKvY4GXAicBf8GgeToKeOta1rmcLh3sbnCY2y0/DHgYsFdVLUtyPTCvW7d06P33MWi+pirAJ6t/K6efAAAgAElEQVTqLWtZpyRJ0joz1btKH9793JHB9W2f6YY2V3gBgyHVYf8bOKeq/pvB9W7j3WvTVRzmEuAp3ZDsxsCLh9ZdzyABA3gesHE3vSVwc9e0HQjsNIWPcwewxRq2OR84ZOhzPyTJVPYtSZLWkTmz+BpVU30A7+eTbM1gqPPIqro9yUlJ9mAwVHo98JoVG3fXwh0OPL1b9LfAOQzuSj10sgNU1U1JjgO+xeCatMuHVn8UOCvJFcC5DIZsAT4N/GuSJQyuXfveFD7LqcDfJ7kb2HcVtVyT5FhgxSNMlgFHAv85hf1LkiStE1MdKt1/kmV/vJrt72Jws8CK+YuA3aZwnFOAU2DwvDUGd4DSDcvuM7TpX3bLb2EVzRcwf2i/fzM0/Xng80PbHTC0bueh6TOAM9ZUsyRJ0mzxK68kSVITvDmhp8YtySXAgyYs/uOqWrJipqpOZTCsKUmSJHpq3KrqiX0cV5IktWuUH4w7W3r/7lBJkiRNjde4SZKkJszxGjcTN0mSpFaYuEmSpCZ4V6mJmyRJUjNM3CRJUhNM3EzcJEmSmmHiJkmSmmDiZuImSZLUDBM3SZLUhDl+c4KJmyRJUitM3GbI5luMRg9899Jb+y5hparxvksAYOOxTfsuAYDx8Xv7LmHkbDS2Sd8lALBs/K6+S1hp7sZb9F0CAPcuu6PvEgC4655f9F3CSsuX3913CQDcVaNzTmbbaPxL2y/PgSRJUiNs3CRJkmZQkock+WqSH3Y/H7yabX8ryU+TnDyVfdu4SZKkJoxl9l7TdAxwflXtApzfza/Ku4BvTHXHNm6SJEkz62Dgk930J4HnT7ZRkr2AbYCvTHXHNm6SJKkJs5m4JVmYZPHQa+FalLpNVd3UTf+MQXP2G5KMAe8Hjl6bc+BdpZIkSRNU1SJg0arWJ/ka8NuTrHrrhP1UMukD6F4HnFNVP02mPjZr4yZJkpowSg/graqnrWpdkp8n2baqbkqyLXDzJJvtC+yf5HXA5sDcJHdW1equh7NxkyRJmmFnA68ATuh+njVxg6o6bMV0ksOBBWtq2sBr3CRJUiMauqv0BOAPk/wQeFo3T5IFST42nR2buEmSJM2gqroVeOokyxcDr55k+anAqVPZt42bJElqwgwkYc1zqFSSJKkRJm6SJKkJJm4mbpIkSc0wcZMkSU2YY+Jm4iZJktQKEzdJktSEsRH65oS+mLhJkiQ1YkqNW5I3JLkqydVJ3tgte3ySbyVZkuRfk/xWt3y/JFcmWZxkl27ZVkm+kqT3RjHJ4Um2G5r/WJLHdtPXJ3lof9VJkiSt2hobqSTzgT8B9gYeDzwnyaOAjwHHVNVuwBeAN3dveRPwLOCNwGu7ZccC76mq8Zkt/wE5HFjZuFXVq6vqmv7KkSRJUzE2i69RNZXadgUuqaq7qmo58HXghcCjgW9023wVeFE3vQzYtHstS/JIYIequnBNB0pyRJIfJPlOko8mOblbfmqSQ4a2u7P7uXmS85P8e5f8Hdwt3znJtd0+ru7Svk26fSwAPp3k8m7ZhUkWTFLLy7s6Lk/yD0nmTLLNwi5ZXHzTuff7/lhJkqQZNZXG7Spg/yRbJ9mUQZq2A3A1cHC3zYu7ZQB/DXwKeAtwMvBuBonbaiXZFngHsB/wJOCxU6jtHuAFVbUncCDw/iQrbhbeBfhwVT0OuB14UVV9DlgMHFZVe1TV3auoZVfgJcB+VbUHcB9w2MTtqmpRVS2oqgXbHnTwxNWSJGkGNfQl8+vMGu8qraprk5wIfAX4FXA5g0bmlcCHkvwVcDZwb7f95cA+AEmeDNw0mMwZDNK4N1XVzyc51BOBC6vqF917z2CQ6q1OgPd0xxkHtge26db9uKsF4LvAzmv6rEOeCuwFXNr1gZsAN6/F+yVJkmbclB4HUlUfBz4OkOQ9wE+r6nvA07tljwaePfyeLvk6FngpcBLwFwyap6OAt65lncvp0sHuBoe53fLDgIcBe1XVsiTXA/O6dUuH3n8fg+ZrqgJ8sqrespZ1SpKkdcQH8E79rtKHdz93ZHB922eGlo0xaND+fsLb/jdwTlX9N4Pr3ca716arOMwlwFO6IdmNGQy/rnA9gwQM4HnAxt30lsDNXdN2ILDTFD7OHcAWa9jmfOCQoc/4kCRT2bckSdI6M9UH8H4+ydYMhjqPrKrbu0eEHNmt/xfglBUbd9fCHU6XyAF/C5zDYDj10MkOUFU3JTkO+BaDa9IuH1r9UeCsJFcA5zIYsgX4NPCvSZYwuHbte1P4LKcCf5/kbmDfVdRyTZJjgRWPMFkGHAn85xT2L0mS1gEfwDv1odL9J1n2QeCDq9j+LgY3C6yYvwjYbQrHOYWuAUxyOIM7QOmuidtnaNO/7JbfwiqaL2D+0H7/Zmj688Dnh7Y7YGjdzkPTZwBnrKlmSZKk2eJXXkmSpCaM8t2es6WXxi3JJcCDJiz+46pasmKmqk5lMKwpSZIkemrcquqJfRxXkiS1y8RttL/VQZIkSUO8xk2SJDXBtMlzIEmS1AwTN0mS1IR4jZuJmyRJUits3CRJkhrhUKkkSWqCI6UmbpIkSc0wcZMkSU3w5gQTN0mSpGaYuEmSpCaYNtm4zZixEfnTND5+X98lrHTn3T/ruwQAHjTnIX2XAMBGV1/VdwkrLd12m75LAGDpfbf3XQIA947f0XcJK221+c59lwDAXff8ou8SgNH5PQIwb+6D+y4BgGXLf9V3CeqRjZskSWpCUn2X0LsRyYkkSZK0JiZukiSpCd5UauImSZLUDBM3SZLUBJ/jZuImSZLUDBM3SZLUBAM3EzdJkqRmmLhJkqQmjBm5mbhJkiS1wsZNkiSpEQ6VSpKkJjhSauImSZLUDBM3SZLUBB/Aa+ImSZLUDBM3SZLUBAM3EzdJkqRmmLhJkqQmmLiNcOKW5M6+a5AkSRolJm6SJKkJfuXViCRuSc5M8t0kVydZOLT8A92y85M8rFt2VJJrklyZ5PTV7PO4JJ9MclGS/0zywiTvTbIkyblJNu62e1uSS5NclWRRBjbqlh3QbfPXSd49yTEWJlmcZPGN55414+dFkiRp2Eg0bsArq2ovYAFwVJKtgc2AxVX1OODrwNu7bY8BnlBVuwOvXcN+Hwn8AfA84DTggqraDbgbeHa3zclV9ftVNR/YBHhOVS0HDgc+kuRpwEHAOybuvKoWVdWCqlqw3UEHP9DPLkmSpiCz+BpVo9K4HZXkCuDbwA7ALsA4cEa3/jTgSd30lcCnk7wcWL6G/X65qpYBS4A5wLnd8iXAzt30gUkuSbKEQZP3OICquhr4R+CLDBrLe6f1CSVJkqap92vcuuHIpwH7VtVdSS4E5k2yaXU/nw08GXgu8NYku3UJ2WSWAlTVeJJlVbViH+PARknmAX8HLKiqnyQ5bsKxdwNuBx7+QD+fJEmaGUmteaP13CgkblsCt3VN22OAfbrlY8Ah3fShwDeTjAE7VNUFwF927918Gsde0aTdkmTzoeOR5IXAQxg0iScl2Woax5EkSZq23hM3BsOXr01yLfB9BsOlAL8C9k5yLHAz8BIGw52nJdmSwRD0h6rq9gd64Kq6PclHgauAnwGXAiR5KHAC8NQuiTsZ+CDwigd6LEmSND2jfO3ZbOm9cauqpcAzJ1m1qiTtSatYPnG/x02Y33yydVV1LHDsJLt49NA2H5rKMSVJktal3hs3SZKkqYiRW/uNW5IjgDdMWHxxVR3ZRz2SJEnrSvONW1WdApzSdx2SJEnrWvONmyRJ2jCMwqMw+uY5kCRJaoSJmyRJaoI3J5i4SZIkNcPETZIkNcHAzcRNkiSpGSZukiSpCV7jZuImSZLUDBM3SZLUBAM3EzdJkqRmmLhJkqQmjBm52bjNlFtvHe+7hJEzb+6D+y4BgGXjd/ZdAgD3PWo0zgfA3Ll9VzAwd84WfZcAQDKn7xJWuv3O6/suAYDly+/uuwRgdH6PANxz7219lwDAnLER+QusXti4SZKkJhi4eY2bJElSM0zcJElSE5Lqu4TembhJkiQ1wsZNkiSpEQ6VSpKkJnhzgombJElSM0zcJElSE/ySeRM3SZKkZpi4SZKkJhi4mbhJkiQ1w8RNkiQ1wbTJcyBJktQMEzdJktQE7yo1cZMkSWqGiZskSWqEkZuJmyRJUiN6TdyS3FlVm/dZgyRJakNM3EzcJEmSWjFrjVuSM5N8N8nVSRYOLf9At+z8JA/rlh2V5JokVyY5fTX7PC7JJ5NclOQ/k7wwyXuTLElybpKNu+32SvL17vjnJdm2W/4nSS5NckWSzyfZtFt+apIPJfm3JNclOWTdnh1JkrQmydisvUbVbFb2yqraC1gAHJVka2AzYHFVPQ74OvD2bttjgCdU1e7Aa9ew30cCfwA8DzgNuKCqdgPuBp7dNW8nAYd0x/8E8O7uvf9SVb9fVY8HrgVeNbTfbYEnAc8BTpjswEkWJlmcZPF/X3D2lE+EJEnSAzGb17gdleQF3fQOwC7AOHBGt+w04F+66SuBTyc5EzhzDfv9clUtS7IEmAOc2y1fAuwM/B4wH/hqBg+AmQPc1G0zP8nxwFbA5sB5Q/s9s6rGgWuSbDPZgatqEbAIYLdPXVRrqFOSJGlaZqVxS3IA8DRg36q6K8mFwLxJNl3R/DwbeDLwXOCtSXarquWr2P1SgKoaT7KsqlbsY5zB5wtwdVXtO8l7TwWeX1VXJDkcOGDifld8hNV+QEmSNAv853i2hkq3BG7rmrbHAPsMHX/F9WOHAt/MYGB5h6q6APjL7r3TufP0+8DDkuwLkGTjJI/r1m0B3NQNpx42jWNIkiStc7M1VHou8Nok1zJopL7dLf8VsHeSY4GbgZcwGMo8LcmWDFrrD1XV7Q/0wFV1b3dzwYe6fW4E/H/A1cBfAZcAv+h+bvFAjyNJktYtHwcyS41bVS0FnjnJqlUlaU+a4n6PmzC/+WTrqupyBkOvE9//EeAjkyw/fFX7lSRJWp0kD2FwDf/OwPXAH1XVbZNs914Gl4eNAV8F3jB0ydekRvd+V0mSpN+QWXxNyzHA+VW1C3B+N/+bnyT5X8B+wO4MbqL8feApa9pxE41bkiOSXD7h9eG+65IkSZrEwcAnu+lPAs+fZJticKPmXOBBwMbAz9e04ya+ZL6qTgFO6bsOSZLUn1F+MO4E21TVikeP/Qy432PFqupbSS5g8IiyACdX1bVr2nETjZskSdJs6r7laeHQokXd81tXrP8a8NuTvPWtwzNVVUnud91akkcBuwK/0y36apL9q+qi1dVl4yZJkhoxe3eVDj9kfxXrn7aqdUl+nmTbqrqp+5rNmyfZ7AXAt6vqzu49Xwb2BVbbuDWTOUqSJDXibOAV3fQrgLMm2ea/gKck2ah7nuxTGHz95mrZuEmSpCZkFv83TScAf5jkhwy+OeoEgCQLknys2+ZzwH8w+IrOK4Arqupf17Rjh0olSZJmUFXdCjx1kuWLgVd30/cBr1nbfdu4SZKkJvjNCQ6VSpIkNcPETZIkNcK8yTMgSZLUCBs3SZKkRjhUKkmSmpB4c4KN2wzZeuvRCC9/NH5v3yWstGz5r/ouAYCNMq/vEgDIXbf0XcJK4/fN7bsEAMZrWd8lALB8/J6+S1hpkwdt3XcJANxVv+i7BGB0fo8AzBkbjb83943Q73nNPhs3SZLUCBO30YiJJEmStEYmbpIkqQk+gNfETZIkqRkmbpIkqRHmTZ4BSZKkRpi4SZKkJniNm4mbJElSM0zcJElSE/zmBBM3SZKkZpi4SZKkRpi4mbhJkiQ1wsRNkiQ1IeZNngFJkqRW2LhJkiQ1wqFSSZLUCG9OMHGTJElqhImbJElqgg/gbTBxS3LnOtjnzkkOXc36C5MsmOnjSpIkrY3mGrd1ZGdglY2bJEkaBZnF12ga6cYtyZlJvpvk6iQLh5Z/oFt2fpKHdcuOSnJNkiuTnL6afT4lyeXd67IkWwAnAPt3y/48ySZJTk9ybZIvAJus8w8rSZK0BiPduAGvrKq9gAXAUUm2BjYDFlfV44CvA2/vtj0GeEJV7Q68djX7PBo4sqr2APYH7u7ee1FV7VFVHwD+FLirqnbt9r/XZDtKsjDJ4iSLbzz3rGl/WEmStGphbNZeo2p0Kxs4KskVwLeBHYBdgHHgjG79acCTuukrgU8neTmwfDX7vBj42yRHAVtV1WTbPrnbN1V1Zbfv+6mqRVW1oKoWbHfQwWv3ySRJktbSyDZuSQ4AngbsW1WPBy4D5k2yaXU/nw18GNgTuDTJpHfMVtUJwKsZDH9enOQxM1y6JElaJ7zGbWQbN2BL4Laquqtrrvbplo8Bh3TThwLfTDIG7FBVFwB/2b1388l2muSRVbWkqk4ELgUeA9wBbDG02Te6fZNkPrD7jH4ySZKkB2CUn+N2LvDaJNcC32cwXArwK2DvJMcCNwMvAeYApyXZkkGb/KGqun0V+31jkgMZDLleDXy5m76vG5Y9FfgIcEp37GuB766DzydJktZCRjgJmy0j27hV1VLgmZOsmjRJ49fXuq1pv3+2ilV/MGH+pVPZnyRJ0mwZ2cZNkiRpmN+csB43bkmOAN4wYfHFVXVkH/VIkiRN13rbuFXVKcApfdchSZJmyijfUzk7PAOSJEmNsHGTJElqxHo7VCpJktYvPg7ExE2SJKkZJm6SJKkRJm4mbpIkSY0wcZMkSU3wAbwmbpIkSc0wcZMkSY0wb/IMSJIkNcLETZIkNcHnuJm4SZIkNSNV1XcN6iRZWFWL+q4DRqeWUakDRqcW67i/UanFOu5vVGqxjvsbpVo0dSZuo2Vh3wUMGZVaRqUOGJ1arOP+RqUW67i/UanFOu5vlGrRFNm4SZIkNcLGTZIkqRE2bqNllK41GJVaRqUOGJ1arOP+RqUW67i/UanFOu5vlGrRFHlzgiRJUiNM3CRJkhph4yZJktQIGzdJkqRG+JVXPUsS4DDgEVX1ziQ7Ar9dVd/pubTeJJlXVfdMWPbQqrqlr5qk1UmyCbBjVX2/xxpG5nfJKNWigSR7rm59Vf37bNWi6fHmhJ4l+QgwDvxBVe2a5MHAV6rq92fp+CcBq/xDUFVHzUYdw5IsAf6kqr7dzb8I+OuqevQs1/FC4ETg4UC6V1XVb81mHV0t7wWOB+4GzgV2B/68qk6b5Tq+CXwduAi4uKrumM3jT1LPKDRMzwX+BphbVb+bZA/gnVX1vFmuo9ffJaNYS5J3Ae+oquXd/G8BH6yqI2a5jt5/lyS5oJucBywArujq2B1YXFX7zlYtmh6HSvv3xKo6ErgHoKpuA+b+/+2de9jlY7nHP9/RZJremamEckokojQjdLiQScihxNja2BXZKl1l1O6AMJgODiGkE64UI9WWHEqUMEnDGDNmTHRAlCg7Bqlh8N1/PM+aWfPOOwc0z/Osd+7Pda3rXb/fmnU932u98/7W/Xvu+/7eBde/CZhG+mPeDPh9fowurKObfYDTJZ0oaRJwIPC2CjpOAN5le5TtkbZH1AjaMjvYfgTYFfgj8CrgUxV0vBf4LTAOuF7STZJOqaCjEzDNIAWySBot6ZIKUo4GtgTmANieAbyygo7a15IWtTwPuEHSppK2B6aSrnelqX4tsT3W9ljgPmAz25vbfgMwBri3pJbguRGp0vrMk7QSeddL0qqkO9Ui2P52XvcgYKuuO9Ovk3ZVimN7lqTPA+cCjwLb2P5zBSl/tX1bhXUHovO3ugvwA9sPp2xUWWzfJWku8ER+jAVeU1xI4mhSwHRN1jZDUo2Aad4Av48aqYyq15IWtdg+TNLPgRuAh0jXkj+U1kFb15INbc/qHNi+VVKtv+HgWRCBW31OAy4CVsvByp7AERV0vBgYCTyYj/vyueJIOhtYn7SF/2rgMkmn2z6jsJSbJH0P+BHweOek7R8W1gHpM7idlCo9KH8Rzl3Ke/7tSLoD+D/gfOBs4GO2qwUHjQRMsyXtA6wkaQPgYOD6CjpauZY0o0XSNlnLscDrSDv5B9j+S2EpLV1LZkk6C+iUWewLzKygI3iWRI1bA0jaCNiOVG9wVY07M0n7k3Ywrs46tiHVhpxTQcshpDqUzt36KOBk2wcU1vGtAU7b9gdK6ugg6SXAw7afkjQcGGn7/sIaxgNbAWsDt5Pq3SbbvqOkjqzlbOAq4FBS6vZgYKjtDxfWMRz4LLAD6W/nCmBi/wabQlqqX0ta0iLpRmA/27/Jx3sAX7C9UWEdzVxLJA0DDiJd4wEmA1+1/fji3xW0RARulZF0GnCB7Rp36P21vAx4Yz68oXRQECyKpLfZ/kX+wlmESnfsSOoD9gc+Caxle6UKGpoJmGqSA/rFYvvBJb0+WLUASFrJ9lP9zq1i++8ldbSEpPG2T13auaBdInCrjKT3A+8BNiSlFi6wfVMFHVfZ3m5p5wpp2QD4IrAxqWkCANvrFVr/07ZPWFzHbclOW0nH2J7Qyh27pJNIO259pHTgdcAvbd9ZUkcLSLqUJXdkF+kqlXRX1tGdM+4cu9TfTWtaujTtAmzCwteSYwtrGAYcMICOGjtuN9verN+56bbHlNYSPDuixq0yuTng2/lOdRxwvKR1bG9QYv18QRkOvDS37HcuuCOBNUtoGIBvAROAU0jF7/tTtgO6k9K5iTo1U/OxPSH/LGpfsAR+DZxg+6+1BLQSMJEsQKpju0ZDxoC0pAXmN1kNJ11HziLV2tXwkjuXVFqwI6nebl8WXGeKIGlvUsf+K/t1X3fXNgc9QOy4NYKkLUk7b7sBt9l+Z6F1xwOHAGuQWsJF+lJ8FPhmhYYAJE2z/QZJs2y/rvtcYR1bAIcD67LgJse2Ny2pI2sZTwpoHwXOJFm3HGr7ysI6hpAv/rYn1jBWlfTWJb1u+9pSWlpA0ka2b1+cwaoLGqu2pCXrmWl7066ffcDltrcurGO67TFdOoaSdqrfVFDDK0g2NV8k1YV2eBSY2XEUCNondtwqo2SsujtwB3ABqUZnTqn1c13DqZKOAr5s+xFJR5ICg1+X0tGPx3OA8HtJHyUFlH0VdJxH8kqbRT1bhQ4fsH2qpB2BVUh+aucCRQM34AyysSowkXTRvxAoZqzaSmAm6fu291IyjB4opV4qwP8E8EHgpAFeM2U9EFvSAqkLG+CfktYA/g68vLAGgHn55xxJrwXuJ5nxFsP23cDdkt4O/Mv205JeDWxEusYFPUIEbvW5A3gLsB6wMrCpJGxPLqxjT6fRNFuRLq5fAr7GgmaFkownpTcOJgUHY4H3VdDxgO0ahq4D0Ulh7wx8x/Zs1TByS8aqm0maDslYVVJRY9WGAqbx+eeuhdYbENsfzE936t+YkUshVkgtmcskvQg4EbiZ9P/lrAo6vplLUY4ELiHdiB5VQQekLtKts54rSabE7yGlb4MeIAK3+jwN/AJYi+QC/ybSTlfpO9NO59UuwJm2fyzpc4U1dDBpN+kVwNB87kySr1tJJmS/o6uo7700TdKVpFTHYZJGUGcXsAVj1VYCpvvy04/Y/kz3a5KOBz6z6LuWK9eTdsqXdm6F0WJ7Yn56oaTLgGG2Hy6pIevoBIvXkm7SayLb/5R0AMkG5ARJMyprCp4BEbjV52BSmmmK7bHZ++gLFXTcK+kbwPakBomVqTcSbRJtpCj3J6URhnbpMFAjcDuANIbsznzRXSXrK81AxqpHlhTQYMC0/QBr7lRKR7bxWRN4gaQxLNxgNLyEhha1ZD0rkW5G1yV/3+WMxsmFdaxOuq6vYXsnSRsDb7Z9dkkdC+TozaQdto43ZnE7n+DZE4FbfebanisJSSvnwt4NK+jYC3gH8CXbcyS9nDqzMKGdFOUWtmv8LhYh16OsBeyTM6TX2r60go5JkqaxwFj13RVNXmsHTAcBHwHWk9TtPD8C+FUJDZkdgf1Iu/bdAcmjpOaakrSkBeBS0oSR2jeB55Caiz6bj38HfI80faQ044HDgItyycV6JOP1oEeIrtLKSLqItHNyCCk9+hDJ/X3nqsIqImk7YG8qpyizd9qJHdf1mkg6jrQzOymf2huYarvol6HSuKCz+507zvahi3vPctAwP2Ai1Yh2GAH8yvZ/FdIxijQWbpEuvdJGs1nPONsXll53IFrR0unibEDHVNtbdPulSZphe3Rtbf1RGi/4sdo6gsUTgVtDZJuDUcBPbT9RW08tJJ1HSlHOpitFWcFs9jbSzNS7SAFkx0S0hh3ITGC081zQnAKaXlqLpJ8Ak2xPysdnkOqGio0jay1gyppWAlanK4th+57CGlYmeUGu209HUbPZlrTk1PlVpW1zBtBxDenz+Flu7nkTcLztJVrb1GAgg96gLSJV2hCt2Bw0QCspynfUFtCPF7HAKHNUJQ3jgEskPU36fOaUDNoAcnH5w8De/QKmPkl9FQKmj5Lm/P6VhWshSwf4F5M+l2l07VRXohUtU4CLsr3QPBbcfI0srOMTpG7S9SX9CliVVB8aBM+Y2HELmqOlFGUrZNfz40i1KCINiD7M9gWF1u+eQTkC+BGpjusoKD+DMmsaMGCqsAv5B5JNStX5l5Jutf3amho6tKJFaQTXbsAsV/6yk/Q80mhDAb+1PW8pb6lC7Li1TwRuQXO0lKJsidww0jG6vdH2/QXX7sygnH8q/zSUmyPbT1MrAdPVwPa1neclfRM43XZ1M9VWtEiaDGzbKTGoqGOR7lageHfrsqCYW9o8kSoNWqS1FGV1JF1leztSuqX/ueWO8wxKSXuRajC7J2xMXOKblx9/IqXjanMncI2kH7NwM03pL+WtgP1ykF37hqcVLZ3fzeXU/d200t26EDmF3Gf7ka7Tp9bSEywbEbgFzZFHswTMd5sfDrw0O513+2KtWUHSEba/38iEjVYCpnvy4/n5UYudKq7dn1a03JUftX83a7WSMZB0PvBhkun6VGCkpFNtnwhg+5yK8oJlIAK3IGibD5GsYtYgFXp3ArdHgK9U0NPShI0mAibbx9Rau5vODY+k1YAa49C1T00AAAqtSURBVKWa07K0301B64vLJe1Qu7s1s3HeMd8XuJzUmT2NNBYs6AGixi0IGifXxxzeNb6nppbLgHtJ5rebkYZ432j79VWFVSSP/fo0sAldQYrtomPrJL2LNNx9DeBvpJFxt9nepKSO1rQsiVKF+JJ2B84jTaOp2d2KpNmkKSznA1+xfa2kW1bkv+Feo9ZIoyAIlhHbTwF71NaR2Qu4AtjR9hzgJVSasCFpVUknSvqJpF90HhWkTAJuJ82RPQb4IykFVZqJpFnHv8s1iduR7DBq0JKWFjgZeDMw3PZI2yNqBG2Zb5D+j74QmCzpFaQd/KBHiMAtCHqDqySNU553VQvb/7T9Q9u/z8f3VUz/tBIwrZKnScyzfW02ii6625aZlztsh0gaYvtqYPMKOlrT0gJ/Am6tbUkCYPs022va3tmJu4GxtXUFy07UuAVBb/Ahkonnk5LmUjHV0hCr2D5b0vhsXn2tpBqBW8eP6z5JuwB/Ie1ElmaOpD5gMjBJ0t+AxyroaE3Lkih1I9RKdyuSVgEmkDp/DVwHHAtUtdUJlp0I3IKgB7A9oraGBmklYPpcHsP1P8DppI7fj1fQsRvJcuLjwL6k6RrFx101qAWobn3RSncrwAWkgHpcPt6XNPD+7dUUBc+IaE4Igh5A0jYDnbc9ubSWVpC0K/BLYG0WBEzH2L5kiW8MVhgGsr4A5ltftELJwe4DTbWQNMv260qsHzx3InALgh5A0qVdh8OALYFppTsXg0XJI9oWuZDmWreSOh7t0vF8YCjwWKXOxSa0SJphe3S2vtiMbH3Riqdah5JjpiSdDNwIfD+f2hPY0vYnS6wfPHciVRoEPYDtd3YfS1ob+HIlOU3QSsAEXNb1fBiwOyltW5TudHpuYtmN1NlZnIa0DJU0FHg3yfpinqQVcreiK5gWyRvy3PzSSsA/gAjceoTYcQuCHiR/Gc62vXFtLbWQNK7rcH7AZPvgSpKA+bVU19l+S00dWUszcydraJF0MPAZ4BaSafQ6wHm2ty6pY2mUHuwu6SXABizsO3htqfWD50bsuAVBDyDpdBbsLg0BxpDczldYbF/YfSzpu6QOudpsAKxWelFJ3V5/Q0j2G3NL62hJi+3TgNO6Tt0tqUXri2I2P5L+GxgPrAXMIO2EXk/y2gt6gAjcgqA3uBt4ID9/EvgudTooW6ZWwNSdgjJwP2mXpzTd6fQnSb52u1XQAY1oadH6ooHB7uOBLYAptsdK2gj4QsH1g+dIpEqDoAeQdDPwftuz8vHewCG2awx3b4LFBEyH9d+JC1ZcJP2MZH1xXj61L7Ct7aLWFy11t0qaansLSTOAN9p+XNLs1saRBYsnArcg6AEkrQf8L7APsDXwPmBX2w9XFRYgaYm1SbZvLqTjtCW9XrL2rxUtrVhftNTdKukiYH9Sg8LbgIeAobZ3Lq0leHZEqjQIegDbd0r6T+BHwD3ADrb/VVlWVVoJmICvkr6MZ5J2/zYFbiLVdJly46+GARuTzFQB/gP4DfDrQuu3qOXK/HfTbX1xRWEN0FB3q+3d89OjJV1NMkf+aQ0twbMjdtyCoGEkzWJhy4vVgIfJY3Na86MqiaQpLCFgKuVxJ+mHwISuNPZrgaNt71li/S4dU4CtbD+Zj4cCv7Rd3IajtpZ+afQXklKUkK0vKvjJ9UR3a9AbxI5bELTNrrUFNMxfgANrB0zAhh0NALZvlfSawhoAXkyqnXowH/flczWoqqWfj9wi1hel6aHu1qAHiMAtCBrG9t21NTRMKwHTTElnsXAB/MwKOo4Dpuf0l4BtgKMr6GhGSyvWFy12twa9S6RKgyDoSbJv22MsHDD12d67sI5hwEGk4ARSF+PXbBf3LZP0MqDTaXyD7fu7XtvE9uwVSUsuNehYX4zuWF/Y3mMpb/1362iiuzUYHETgFgRBT9JSwLQkJF1oe9zS/+Vy11HUnX9JlNLSivVFK92tweAgUqVBEPQkOUA7JT8WoZWACVivtoBMMXf+ZaCUlj9LehGpG/tnkh4imVmXppXu1mAQEDtuQRAMSlqZ09nKTlcrOqCOFklvJVtf2H6i0JpNdbcGg4PYcQuCYLASd6XBfGoMUW+tuzUYHETgFgRBsHxpJUVZZJdpGWlJy3Knle7WYHAwpLaAIAiC5UTxgEnS+pL6F5wXHTgvaVVJn5N0kqQNOucrGfE2o6UyncHud9seC4whGWkHwTMmdtyCIOh5JK0PDO/2daN8wHQ48CrgaUkr234vgO0rS+oATgLOJKWKzycFDLVoSUtN5tqeK4n8f+N2SRvWFhX0JhG4BUHQ09QKmPIYozNsdwrOX2/7Pfm1Yga8kq4APm97cj71fOCPpGBp5VI6WtPSGK10twaDgOgqDYKgp+gfMEn6XnfAVGp+q6R9gf2A021fIukA0jD1IcAttj9VSMco4AhS/dQRef0JwAuAU2xfV0JHa1papUZ3azC4iMAtCIKeopWAKWsZBnwS2BI4CvgdMNR28folSesBnyfNcJ1oe05pDS1qCYLBRgRuQRD0HK0ETJI2AeYBjwAT8+kju8c7FdCwPmmCxBPAV4D1SbtdP2bhVO4KpSUIBisRuAVB0HM0EjCdkzUMB+61/WlJY0jDw6faPraQjhuBQ0gGr4fa3i6ffx/w/s7xiqYlCAYr0ZwQBEFPMUDAdGAOmM7MsymLBEzAGNuvz5qmA9ieDrxT0m6FNEAq+r8L6CN9JmQt35H0g4I6WtMSBIOSCNyCIOg1WgmYfpq7KIeSrC7mY/vigjoOIqUlnwA+3E/HvwrqaE1LEAxKIlUaBEFPIek4koHpUOBy2ydW1DISeNr2PyRtRaq5u7WCd1sQBCsIMTkhCIKewvahpC7Sd/UP2iTtX0qHpBttP5KDtgNJO00jgAmSDi2o4x1dz0dJOlvSTEnnS1q9lI68fp+kYyXdKulhSQ9ImiJpv5I6gmAwEztuQRAMGiTdY3udQmtNtz0mP58K7Gz7AUkvBKbY7j/6annpuNn2Zvn5WcD9pGkFewBvtf3uEjry+hcDFwE/B/YiNSlcQOosvdf24aW0BMFgJQK3IAh6iiVMJRDwattFHPol3QJsS8pcXGF7867X5gd1BXR0B24zbI/uem2h4wJabunUH+bjqba3kDQE+I3tjUppCYLBSjQnBEHQa6wO7Ag81O+8gOsL6hgFTMvrWtLLbd8nqY+yA+5Xk/SJvOZISfKCO/LS5TCPSdrK9nW5UeRBANtPSyr5mQTBoCUCtyAIeo3LgD7bM/q/IOmaUiJsr7uYl54Gdi+lg5QWHZGfnwO8FHhA0suART6j5cxBJFuWDYDZwAcAJK0KnFFYSxAMSiJVGgRB0OPkiQV7kGaEPkWaJHG+7UcqalkbeLKmliAYjERXaRAEQQ8j6WDgayTz2y3yz7WBKZK2rahl85pagmCwEjtuQRAEPYykWcBo209JGg78xPa2ktYBLi7VJNGaliAYrMSOWxAEQe/TqVdemTRuCtv3kEyKV2QtQTDoiOaEIAiC3uYsYKqkG4CtgeNhfkPAgyuwliAYlESqNAiCoMeRtAnwGtK4rdtDSxAMXiJwC4IgCIIg6BGixi0IgiAIgqBHiMAtCIIgCIKgR4jALQiCIAiCoEeIwC0IgiAIgqBHiMAtCIIgCIKgR/h/M76eYCwaGBgAAAAASUVORK5CYII=\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"import xgboost as xgb \nimport pandas as pd\nimport numpy as np\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import mean_absolute_error,mean_squared_error\n# Create the training and test sets\nX_trai, X_tes, y_trai, y_tes = train_test_split(X_train_scaled, y_train, test_size=0.2, random_state=123)\n\n# Instantiate the XGBRegressor: xg_reg\nxg_reg = xgb.XGBRegressor(objective='reg:linear',n_estimators=150,seed=123)\n#booster=\"gbtree\" is default base learner in XGBoost\n\n# Fit the regressor to the training set\nxg_reg.fit(X_trai,y_trai)\n\n# Predict the labels of the test set: preds\npreds = xg_reg.predict(X_tes)\n\n# Compute the rmse: rmse\nmae = (mean_absolute_error(y_tes, preds))\nprint(\"MAE: %f\" % (mae))","execution_count":14,"outputs":[{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/xgboost/core.py:587: FutureWarning: Series.base is deprecated and will be removed in a future version\n  if getattr(data, 'base', None) is not None and \\\n","name":"stderr"},{"output_type":"stream","text":"MAE: 2.086637\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"import xgboost as xgb\nfrom sklearn.metrics import mean_absolute_error\ndmatrix = xgb.DMatrix(data=X_train_scaled, label=y_train)\n\nreg_params = [0.05, 0.0001, 0.0005]\n\n# Create the initial parameter dictionary for varying l2 strength: params\nparams = {\"objective\":\"reg:linear\",\"max_depth\":3}\n\n# Create an empty list for storing rmses as a function of l2 complexity\nmae_l2 = []\n\n# Iterate over reg_params\nfor reg in reg_params:\n\n    # Update l2 strength\n    params[\"lambda\"] = reg\n    \n    # Pass this updated param dictionary into cv\n    cv_results_mae = xgb.cv(dtrain=dmatrix, params=params, nfold=10, num_boost_round=100, metrics=\"mae\", as_pandas=True, seed=123)\n    \n    # Append best rmse (final round) to rmses_l2\n    mae_l2.append(cv_results_mae[\"test-mae-mean\"].tail(1).values[0])\n\n# Look at best rmse per l2 param\nprint(\"Best mae as a function of l2:\")\nprint(pd.DataFrame(list(zip(reg_params, mae_l2)), columns=[\"l2\",\"mae\"]))","execution_count":15,"outputs":[{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/xgboost/core.py:587: FutureWarning: Series.base is deprecated and will be removed in a future version\n  if getattr(data, 'base', None) is not None and \\\n","name":"stderr"},{"output_type":"stream","text":"Best mae as a function of l2:\n       l2       mae\n0  0.0500  2.202916\n1  0.0001  2.200637\n2  0.0005  2.199477\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"### Using Catboost"},{"metadata":{"trusted":true},"cell_type":"code","source":"from catboost import CatBoostRegressor,Pool\ntrain_pool = Pool(X_train, y_train)\nm = CatBoostRegressor(iterations=10000, loss_function='MAE', boosting_type='Ordered')\nm.fit(X_train_scaled, y_train, silent=True)\nm.best_score_","execution_count":25,"outputs":[{"output_type":"execute_result","execution_count":25,"data":{"text/plain":"{'learn': {'MAE': 1.7833090585117057}}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''from sklearn.model_selection import GridSearchCV\nfrom sklearn.svm import NuSVR, SVR\n\n\nscaler = StandardScaler()\nscaler.fit(X_train)\nX_train_scaled = scaler.transform(X_train)\n\nparameters = [{'gamma': [0.001, 0.005, 0.01, 0.02, 0.05, 0.1],\n               'C': [0.1, 0.2, 0.25, 0.5, 1, 1.5, 2]}]\n               #'nu': [0.75, 0.8, 0.85, 0.9, 0.95, 0.97]}]\n\nreg1 = GridSearchCV(SVR(kernel='rbf', tol=0.01), parameters, cv=5, scoring='neg_mean_absolute_error')\nreg1.fit(X_train_scaled, y_train.values.flatten())\ny_pred1 = reg1.predict(X_train_scaled)\n\nprint(\"Best CV score: {:.4f}\".format(reg1.best_score_))\nprint(reg1.best_params_)'''","execution_count":17,"outputs":[{"output_type":"error","ename":"ValueError","evalue":"'mean_absolute_error' is not a valid scoring value. Use sorted(sklearn.metrics.SCORERS.keys()) to get valid options.","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)","\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/metrics/scorer.py\u001b[0m in \u001b[0;36mget_scorer\u001b[0;34m(scoring)\u001b[0m\n\u001b[1;32m    228\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 229\u001b[0;31m             \u001b[0mscorer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSCORERS\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mscoring\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    230\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyError\u001b[0m: 'mean_absolute_error'","\nDuring handling of the above exception, another exception occurred:\n","\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)","\u001b[0;32m<ipython-input-17-5593eea21f51>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0mreg1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchCV\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSVR\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkernel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'rbf'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtol\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.01\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscoring\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'mean_absolute_error'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0mreg1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train_scaled\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0my_pred1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreg1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train_scaled\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/model_selection/_search.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, groups, **fit_params)\u001b[0m\n\u001b[1;32m    652\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    653\u001b[0m         scorers, self.multimetric_ = _check_multimetric_scoring(\n\u001b[0;32m--> 654\u001b[0;31m             self.estimator, scoring=self.scoring)\n\u001b[0m\u001b[1;32m    655\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    656\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultimetric_\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/metrics/scorer.py\u001b[0m in \u001b[0;36m_check_multimetric_scoring\u001b[0;34m(estimator, scoring)\u001b[0m\n\u001b[1;32m    341\u001b[0m     if callable(scoring) or scoring is None or isinstance(scoring,\n\u001b[1;32m    342\u001b[0m                                                           six.string_types):\n\u001b[0;32m--> 343\u001b[0;31m         \u001b[0mscorers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"score\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcheck_scoring\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscoring\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscoring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mscorers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/metrics/scorer.py\u001b[0m in \u001b[0;36mcheck_scoring\u001b[0;34m(estimator, scoring, allow_none)\u001b[0m\n\u001b[1;32m    271\u001b[0m                         \"'fit' method, %r was passed\" % estimator)\n\u001b[1;32m    272\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscoring\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstring_types\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 273\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mget_scorer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscoring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    274\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscoring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m         \u001b[0;31m# Heuristic to ensure user has not passed a metric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/metrics/scorer.py\u001b[0m in \u001b[0;36mget_scorer\u001b[0;34m(scoring)\u001b[0m\n\u001b[1;32m    231\u001b[0m             raise ValueError('%r is not a valid scoring value. '\n\u001b[1;32m    232\u001b[0m                              \u001b[0;34m'Use sorted(sklearn.metrics.SCORERS.keys()) '\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 233\u001b[0;31m                              'to get valid options.' % (scoring))\n\u001b[0m\u001b[1;32m    234\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    235\u001b[0m         \u001b[0mscorer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscoring\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mValueError\u001b[0m: 'mean_absolute_error' is not a valid scoring value. Use sorted(sklearn.metrics.SCORERS.keys()) to get valid options."]}]},{"metadata":{},"cell_type":"markdown","source":"### Using Keras "},{"metadata":{"trusted":true},"cell_type":"code","source":"'''import keras \nfrom keras.layers import Dense\nfrom keras.model import Sequential\n\n# Saving Number of predictors in ncols\nncols='''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"submission = pd.read_csv('../input/sample_submission.csv', index_col='seg_id')","execution_count":21,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_test = pd.DataFrame(columns=X_train.columns, dtype=np.float64, index=submission.index)","execution_count":22,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for seg_id in X_test.index:\n    seg = pd.read_csv('../input/test/' + seg_id + '.csv')\n    \n    x = seg['acoustic_data']#.values\n    \n    X_test.loc[seg_id, 'ave'] = x.mean()\n    X_test.loc[seg_id, 'std'] = x.std()\n    X_test.loc[seg_id, 'max'] = x.max()\n    X_test.loc[seg_id, 'min'] = x.min()\n    X_test.loc[seg_id, 'kurtosis'] = x.kurtosis()\n    X_test.loc[seg_id, 'skew'] = x.skew()\n    X_test.loc[seg_id, '1%_quantile'] = np.quantile(x,0.01)\n    X_test.loc[seg_id, '5%_quantile'] = np.quantile(x,0.05)\n    X_test.loc[seg_id, '95%_quantile'] = np.quantile(x,0.95)\n    X_test.loc[seg_id, '99%_quantile'] = np.quantile(x,0.99)\n    X_test.loc[seg_id, 'abs_max'] = np.abs(x).max()\n    X_test.loc[seg_id, 'abs_mean'] = np.abs(x).mean()\n    X_test.loc[seg_id, 'abs_std'] = np.abs(x).std()","execution_count":23,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_test.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_test_scaled = scaler.transform(X_test)\nsubmission['time_to_failure'] = m.predict(X_test_scaled)\nsubmission.to_csv('submission.csv')","execution_count":26,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"submission.head()","execution_count":27,"outputs":[{"output_type":"execute_result","execution_count":27,"data":{"text/plain":"            time_to_failure\nseg_id                     \nseg_00030f         4.542910\nseg_0012b5         4.974466\nseg_00184e         4.420321\nseg_003339         7.685218\nseg_0042cc         6.596831","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>time_to_failure</th>\n    </tr>\n    <tr>\n      <th>seg_id</th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>seg_00030f</th>\n      <td>4.542910</td>\n    </tr>\n    <tr>\n      <th>seg_0012b5</th>\n      <td>4.974466</td>\n    </tr>\n    <tr>\n      <th>seg_00184e</th>\n      <td>4.420321</td>\n    </tr>\n    <tr>\n      <th>seg_003339</th>\n      <td>7.685218</td>\n    </tr>\n    <tr>\n      <th>seg_0042cc</th>\n      <td>6.596831</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.4","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}