{"cells":[{"metadata":{},"cell_type":"markdown","source":"In this kernel I present a very simple K-nearest neighbors model based on the quantiles of the distribution. Although simple, the model does quite well.  It might be possible to include the predictions from this model as a feature in some other model or they could be used as part of model averaging.  Enjoy!"},{"metadata":{},"cell_type":"markdown","source":"First load in the data and required packages"},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import neighbors\nfrom sklearn import preprocessing\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.metrics import mean_absolute_error\nfrom sklearn.model_selection import TimeSeriesSplit\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\"))\n\n# Any results you write to the current directory are saved as output.","execution_count":1,"outputs":[{"output_type":"stream","text":"['test', 'sample_submission.csv', 'train.csv']\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"## Read in the data\neq = pd.read_csv(\"../input/train.csv\", dtype={'acoustic_data': np.int16,\n                                     'time_to_failure': np.float64})\n## Print the first five lines\nprint(eq.head(5))","execution_count":3,"outputs":[{"output_type":"stream","text":"   acoustic_data  time_to_failure\n0             12           1.4691\n1              6           1.4691\n2              8           1.4691\n3              5           1.4691\n4              8           1.4691\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"Here we take the raw values of the acoustic data, sort them, and average over every 100 values.  "},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"## Number of rows for each segment\nrows = 150000\n## Get the number of segments\nsegments = int(np.floor(eq.shape[0] / rows))\n## Initialize X values and y values\nX_train = pd.DataFrame(index=range(segments), dtype=np.float64, columns=range(0,1500))\ny_train = pd.DataFrame(index=range(segments), dtype=np.float64, columns=['time_to_failure'])\n## Create features for each segment\nfor seg_id in tqdm(range(segments)):\n    ## Get segment values\n    seg = eq.iloc[range((seg_id*rows),((seg_id+1)*rows))]\n    ## Sort the values\n    x = np.sort(seg['acoustic_data'].values)\n    ## Sum values of the quantile and put in X matrix\n    X_train.loc[seg_id,:] = np.reshape(x, (-1, 100)).sum(axis=-1)\n    ## Get the time to failure of final observation\n    y_train.loc[seg_id, 'time_to_failure'] = seg['time_to_failure'].values[-1];\n\ny_train = np.ravel(y_train);","execution_count":8,"outputs":[{"output_type":"stream","text":"100%|██████████| 4194/4194 [02:31<00:00, 27.73it/s]\n","name":"stderr"}]},{"metadata":{},"cell_type":"markdown","source":"Let's plot some of the quantiles against the time to failure.  Each of the quantiles appears to contain some sort of information."},{"metadata":{"trusted":true},"cell_type":"code","source":"f, axarr = plt.subplots(2, 2)\naxarr[0, 0].scatter(X_train.iloc[:,0], y_train)\naxarr[0, 1].scatter(X_train.iloc[:,50], y_train)\naxarr[1, 0].scatter(X_train.iloc[:,100], y_train)\naxarr[1, 1].scatter(X_train.iloc[:,149], y_train)\nfor ax in axarr.flat:\n    ax.set(xlabel='Quantile Sum', ylabel='Time to failure')\nfor ax in axarr.flat:\n    ax.label_outer()","execution_count":14,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 4 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XuUVNWdL/Dvj6LUgjE2aEu0IrYaBq+ESC97hFzmroiOYsRHB2MM0RUz44q5M0nuGDOdgUgiJmTohKVmHrlJ0Lh0oiGoMR0cnEETfEyYgDZpsOVGgigPywdttBMHWmi6f/ePqmpOF+f9PlXfz1q9uvvUeezq3qd+55z923uLqoKIiBrXmKQLQEREyWIgICJqcAwEREQNjoGAiKjBMRAQETU4BgIiogbHQEBE1OAYCIiIGhwDARFRgxubdAHcOOGEE7SlpSXpYlCd2rRp05uq2pzEsVm3KUpu63YmAkFLSwu6u7uTLgbVKRHZldSxWbcpSm7rdiYCAZEXXT0lLF+7DaX+gZFlOREsmHkKlrZPT7BkRP4s7urF/Rt2ozoy3PijcvjmR6ejvbUYyv7ZRkB1paunhEUP944KAgAwpIr7NuzG4q7ehEpG5M/irl7cZwgCALDv4BBuXLUZrV9/DF09pcDHYCCgurJk9VYMDA5Zvn7/ht0xloYouPts6uzb+wdx46rNgYMBAwHVja6eEvoHBm3X4aDrVI9uWrU50PYMBFQ3lqzemnQRiBIxHHD7yAKBiNwtIntF5HnDsiUiUhKRzZWvS6I6PjUep7sBIjIX5R3BPQAuNll+h6rOqHw9GuHxiYjIhcgCgao+DeCtqPZPZBRG5gRRo0qijeDzIvJc5dHRhASOT3Vo+dptrtdl0KCsiCvdOe5A8D0AZwCYAeA1ALdZrSgiN4hIt4h09/X1xVU+yqhXa/oN2PESNKLAuk1udPWUYkt3jjUQqOobqjqkqsMA7gRwrs26K1S1TVXbmpsTGQaGMuTkpoLrdb0EjSiwbpMby9du85TuHORON9ZAICInGX79KIDnrdYl8qJj7lSIy3WPK+QjLQtRGGp7xztZ9HCv72AQZfroSgC/BjBVRF4RkesBfFtEekXkOQBzAHwxquNTY2lvLeKaWZNdrbvvANNMKf1y4vbSpmxgcMj3Y8/IBp1T1QUmi38Y1fGIlrZPt+2OXzUYtPcNUQyG1Hs/eL+PPdmzmOoGs4GonhQ9tHtVeWkrM2IgoLqwuKsXXww43gpRmnTMnYpCPud6/UI+h465U30di/MRUOZV0+w4oBzVk+pcAze6vMBZNt///AS8I6DM85pmR5QVXj7Yg0xSw0BAmZd0vwCiqMTV7sVAQJnnt4GMKM26ekroeHBLLMdiGwFlXsfcqVj0cK/tzGREaVeda/vV/gGc3FTAW/sOYHA4noeevCOgzGtvLWLZfPeT0o/x1k+HKHLGubYV5V7FAx47vAQZoI6BgOpC9y73I56f0Tw+wpIQebd87bbAd7T3bdjtOxgwEFDmdfWUXPUornqpb3+EpSHyLqyEBy/ngREDAWWe1/FV/HTdJ4pS0gkPDASUeUwfpazz2os4bAwElHlN4zisNGVbNeHB64ijYWH6KGVaV08J//3uoaSLQRSY1yElwsQ7Asq05Wu3xZZrTRS1IMNEBMFAQJnG9gGiw/z2kWEgoExLOtuCKCxdPSXM7lwXaB+fnOlulr5aDASUaUlnWxCFwdiz2K9rZ03G0nb3PeyNGAgo06rZFnnWZMqwMHoWt5060fe2UU5ef7eI7BWR5w3LJorI4yKyvfJ9QlTHp8bR3lrEie/hIyLKriB3AlWLHu71PWy1ZfqoiPQCpvN9CABV1Q867PseAP8C4F8NyxYC+KWqdorIwsrvf++pxEQ4cqTGME4kojgZ63AYBgaHsHztNl+ZR3b9CC71XyRAVZ8WkZaaxVcAOK/y870AngQDAXlUfZ5avZVmEKCsqa3DYfEbVCwDgaruqv4sIqcCmKKqvxCRgt12Diap6muVn18HMMnnfqiBhfE8lShJUdVhv1l0jm0EIvIZAA8B+EFl0fsAdPk6moGqKswfPVWPe4OIdItId19fX9DDUR3Jet8B1m2Kog4X8jl0zJ3qa1s3jcWfAzAbwB8BQFW3AzjR19GAN0TkJACofN9rtaKqrlDVNlVta25u9nk4qkdZ7zvAuk1R1OFl86f77pnsJhAcUNWD1V9EZCxsruQdrAZwXeXn6wD83Od+qIEF7TuQ0LheRCOi6P8SZHgKN8/6nxKRrwAoiMiFAP4GwCNOG4nISpQbhk8QkVcA3AKgE8ADInI9gF0APu634ORPbbZNx9ypiY1v4le1vMvXbvPVUMzpCOpLFut0FAPMdfWUfL9vN4FgIYDrAfQC+CyARwHc5bSRqi6weOkC16WjUJll2yx6uDy1XdpPnFrtrUW0txZx4e1PYvvefUkXhxISV532GmzcrN/eWsSih5/zPDexlZse2DyyX68cHw2p6jDKqZ7fAHArgHsrDb2UMWaZCtXc4yzq6ikxCDS4OOq02cTydp23vKx/4FA4QQAAhhW49ZGtvrZ1kzU0D8AOAP+EcgexF0XkI76ORomyylTIahZOVgMYhSeOOu012HhZP+wR1N/eP+hrOzeNxbcBmKOq56nqhwHMAXCHr6NRoqwyFbKahZPVAEbhiaNOew02Xpb7HTY6bG4CwTuq+qLh95cAvBNReShCZpkKQXKPk5bVAEbhiaNOew02Xpbn0h4IRGS+iMwH0C0ij4rIp0XkOpQzhp6NrYQUmupIncWmAgRAsakQKPc4aRyCmuKo016DjZf1Q2onDswua+gyw89vAPhw5ec+ALwUy6hqtk2Swkr3S3KOV0qPqOu0MV3ZTZ2tTW/OiYxqI0j6/DNjN9bQX8ZZEGoM9ZTCSo3Da7CprpuVuu4ma+gYEfmciPzfyhwDd4vI3XEUjupPmOl+XT0l3MS7AUqpLKVru2ks/hGA9wKYC+AplAedY2Mx+RJmut+S1VuRkkesREdIIl17rM80JDc9i9+vqleJyBWqeq+I/BjAf/o6GjUMq3YAq0lk/GQA9Q/4y5kmCspNO5dVXVcALQvXIBfBoFdDPjsmuLkjqJ5t/SLyAQDHwf/oo9QA7HpW1lsKKzUetz2HnbLahiIYoMHvHt0EghWVuYW/ivLoof8PwLd9Ho8agN2z0XpLYaXG4/bZf21dj4PfuwzHR0OqWh1g7ikAp/s6CmWS3zRPp2ejYaX7jT8qh30HOVNZvcjKKKJpHqplwcxTfG1nN3n9TXYbqurtvo5ImRAkzTPMdgBjeWo/JAaH2FRcL7KUVuy2fkc1L7GVa2dNxtL26b62tXs0dKzDF9WxIKlvZs9GBeWTe3bnOstRG62YPZPteGgLDg5xENx6kaVUS6v63XJ8AbM71+G0hWswu3MdlqzeGuvc2n6DAGDfoexW33ulzAty+1vbs1JwuBHLz5We2YfEIINAXUnz45Za7a1FdO96C/dv2D1SrxXA+h1vjazjZ8KkJLlpLB4hIr+JqiCULlaPccaIuLqib28tYv3C81FsKhyRyeD1Si+NHwYUrrSOjNvVUxp1lV+t+0+80Oc7QyeNPAUCILbGb0qYVerbkKrtpBy1wrjSC/vDgJU4fdKYVmyXJlpvFyduhpj4gog0VX5dE3F5KCWqqW9m6Wheruj9XukZr8T2HTiEfIjj9V4za3Jo+6JwpDGt2K7dwu3FyYRxeUTQbyx0bu4IJqE8FPUDAH4lEvxtichOEekVkc0i0h10fxSN9tYihi06vbi9IvJzpVd7JdY/MAho5aRC+bvXW1mjtlMnBtiaolJ9nPhy5zysX3h+4tlCdnezboZAL+RzuOWyacjCxL5u5ixeDGAKgB8C+DSA7SLyDyJyRsBjz1HVGaraFnA/FKGgz279XOmZNg4PK8YdNRYvd85Dz9cuwnHj8q7fg9n+iZzY1X2zen3trMmm9TyKoSTC5masIaiqisjrAF4HcAjABAAPicjjqvrlKAtI4fLaaadj7tQjcqG9Prv12oHMTbtCv8+5WYHsZXSQf0E6qTnVfbf1OoqhJMLmGAhE5G8BfArAmwDuAtChqoMiMgbAdgB+AoECeExEFMAPVHWFj32QR3467ThNyhFFb1A3HXaOK+R9DzqXhSs0Ci5oJzWvE9JYyYmkPhi4uSOYCGC+qu4yLlTVYRG51Odx/1xVSyJyIoDHReQFVX3auIKI3ADgBgCYPJmNe2FwGgPIitWVT1S9Qa2uxOac2YzZnesCX9EnfVKybsfDb303CmM4lKTrmxtu2ghuqQ0Chtd+6+egqlqqfN8L4GcAzjVZZ4WqtqlqW3Nzs5/DUI2wO+1E1RvU7PnrlecU8dNNpVAe6xQTzk1n3Y5HWjqpZeEO1FUbQZhEZDyAMar6TuXniwB8Pe5yNKKwxwCK8kSrvRKb3bkutO76HPK6MUQx5pUfdXFHEIFJKKehbgHwDIA1qvofCZSj4YTdaSfO3qBhXsUlnZZI8UhLJ7Wk70DdiD0QqOpLqnp25Wuaqn4z7jI0qrA77cR5oiU91ABlT1o6qbnpc5C02B8NUbLCmgugui8geFZFLbNMJLMGZCInYdb3IGUAgC89sCWyx0TXBuwtz0BAgYR1olU//K1GK102fzqWzZ+OWx/ZircD9CEgSkJ1xNL7NuwOdb85ESyYeUqgIagBBgJKgdo0VKvRSjvmTsW7g5yMhrJpzXOvhb7PHcsuCWU/STQWE41iloZa69X+AVfrEaVVmu9keUdAiTE+DnJyclOh7ob+pezx2pPeuH6aMRBkVFYm+q5l1RZgJ58T7DtwqK4mAqF0sjuvzHrSf3HVZty4ajOKJudg3HMWB8FAkEFZmujbyKktwKgaJMYflcO+g0O+xxUicsvpvDJ7NGk3BWuWHmWyjSCDkpro22raPrfcnhjFpgLuuHoGvnP1DOw/mI0TibLP6bxyerxTew6m/XGQEe8IMiiJMVTCuAtxU75iUwHrF54PoDysBB8HUVycziurISus9jGucjcblTDHMOIdQQYlMdF3GHchTuUz9kru6glngDkit5zOKzc9hI37iPpudtbpE0LbFwNBBsU9hordh7KXu5A5Z1qPtGns/l+9+yCKk9N5ZRyywoqxjkd9N7vz9+FdKPHRUAZFNbSDGacPZS93IU+80Ge63Pg4CMhWIxvVDzfnVbUnfVdPCTc9sBnDNZ/2q57Zg7ZTJ8aStBHmHTMDQUbFNYaK3Yey17sQt20bWWpko/ri9rxavnbbEUEAKM+t7WXimyDYRkCxsftQPibvrfq4bdtoCjAxPVEc7M6LUv8Azlj0aORlCHMAOwYCsmX36Oft/YPoeGgLZtz6mKuUUjdtG4u7elPdFZ8IcH4kGsdkNGHOc8BAQLacMiUGhxT9A4NQHE4ptQoG7a1FXHlOceSWNieCK88p30LP7lyHloVrQh+dkSgKHXOnIp9LbgrKsJNDGAjIlptMCSO7lNKunhJWPbtn5GppSBU/3rgbX3pwC1NFKVPaW4tY/rGzMSGhx5hhT7DDQECO2luLWL/wfNfBoNQ/MOquoNoj+cZVmzE4NPqWeViBIbNWN6KUa28toudrF+E7V89IuiiBZTZryGxwKOBw6tdxhTwGh4ZHevblxwBDCtOW/kJ+DI7J59C/fxAnNxUw58xmPPFC3xEpZF09JSxZvXVk3JsJ4/KY98GTjli3Wo5S/wByIhhSNR2UKs2CzhJmTDnNysBbaWBWx265bJpjvenqKeHmn/WO1HcBcM2syWg7deKo/2O1bpvVTeBwvR0jo8+VpkIel55tXdf9pjGHMXiim304rWP193Oa8KWrp4SOh7Z4Km8Ywh5bTDSGRo0jDipyMYB/BJADcJeqdtqt39bWpt3d3SO/m43qlx8jgOCIK84wFPI5XHlOEaue2YNBh6tXu3IU8rlE5kz1yuzvWy07cPjEbxqXx3+/e8jyb1K9g0jbY5+dnfNG/S4im1S1LYmyGOt2V08JHQ9uOeLvmc8Jln/sbMt609VTwpce3GJ6Z1X7gW4lnxNA4Vi/R21jUte91HG7eub2HHGzD6d17P5+1zoEg9avP5aK5IbaOl3ltm7H/mhIRHIAvgvgIwDOArBARM7ysg+z3PbBYY0kCADl594rNzoHAadyxDEwXBjshpOoPiZ6uXMeer52EZZfdbblfl7tH0hln4DTFq5Jugimlq/dZlrHBofUtt4sX7vN8vGa28/1wSH1FAQA87rupY6HMWyJm304rWP391u5cY/t8dMQBACgJWCdTqKN4FwAL6rqS6p6EMBPAFzhZQdJfLiElQ6Wxg/GWl4GtWtvLVq2HZzcVHBMs0uiAqa1RcKubvh9LQluyxPG4Ilu9uG0jt3x4kgDTYMkzsMiAGOYfaWyzLUoB1ezElYvviTK7pXXQe3s+geYvVb9SxabCrj96hm4dtZkJJeIlx52dcPva0lwW54wBk90sw+ndeyO53TeNxXqo/NjarOGROQGEekWke6+vtFj1Jh9uOTHSGR5vYV8DgtmnlJ+JurArhxRDgwXJq+D2hlTTAWjB5Aze+2Oq2dgZ+c8rF94Ptpbi1jaPh13XD1j1DrfqcxHYFw2+4yJoXarT4pV3e6YO9W0juVzYltvOuZORc6ibrqosiPHcFO/R21jUte91PEwBk90sw+ndez+fgtmnmJ7/CWXT/P8d0uj2BuLReRDAJao6tzK74sAQFWXWW1T21gMMGsoammfCrOrp4RbH9nq6xmtAHjZ0LiWlsZigFlDWcsaMu7b+Dct5MfgwKFh1200YTBrMHZbt5MIBGMB/A7ABQBKAJ4F8ElV3Wq1jVkgILLi1HCW1qwhoipjcHFjyonj8fhN5x2x3G3djr0fgaoeEpHPA1iLcvro3XZBgMirnZ3zsLirF/dv2D2qYdgpFZAoLexGQb3w9iexfe++kd+tgoAXifQj8EpE+gDsSrocDk4A8GbShQhRvb0fwPo9naqq1rPmRMihbmf1f8Byx8uu3K7qdiYCQRaISHdSjxeiUG/vB8jee8paeatY7niFUe7UZg0REVE8GAiIiBocA0F4ViRdgJDV2/sBsveeslbeKpY7XoHLzTYCIqIGxzsCIqIGx0BARNTgGAiIiBocAwERUYNjICAianAMBEREDY6BgIiowTEQEBE1OAYCIqIGx0BARNTgGAiIiBocAwERUYNjICAianAMBEREDS72yev9OOGEE7SlpSXpYlCd2rRp05tJzVnMuk1Rclu3MxEIWlpa0N3dnXQxqE6JiNXk8ZFj3aYoua3bmQgERG7M/ObjeOOdgyO/Tzr2KGy8+cIES0RkLy11loGAMmtxVy9WbtyDIYtZ9t545yBmfvNxBgNKpdogACRXZxkIKJMWd/Xivg27HderPdGI0sKqbhqXX3Pnr7F+x1sjv88+YyLu/8yHQi8Ls4Yok1Zu3JN0EYgiVRsEAGD9jrdwzZ2/Dv1YDASUSVaPg4jqRW0QcFoeRGSBQETuFpG9IvK8YdkSESmJyObK1yVRHZ+IKKtaFq6J9XhR3hHcA+Bik+V3qOqMytejER6fiIhciCwQqOrTAMK/hyEiolAl0UbweRF5rvLoaEICxyciIoO4A8H3AJwBYAaA1wDcZrWiiNwgIt0i0t3X1xdX+agOze5ch9MWrsHsznXo6iklXRzWbUqdWAOBqr6hqkOqOgzgTgDn2qy7QlXbVLWtuTmRYWCoTpT6B6CV74se7k08GLBuU9rEGghE5CTDrx8F8LzVukRRGBgcwvK125IuBlGqRJk+uhLArwFMFZFXROR6AN8WkV4ReQ7AHABfjOr4RFZe7R9IughEtnZ2zov1eJENMaGqC0wW/zCq4xG5dXJTIekiEKUKexZTJo3L+6+6c87kc3kiIwYCyqTBoWHf2z7xAjN1iIwYCCiTBv3HAbYRENVgIKCGwzYCotEYCKihFPI5dMydmnQxiFKFE9NQJnT1lLB87Ta82j/g+Yq+2FQY2a5j7lS0txYjKiVRNjEQUOp19ZSw6OFeDAwOASj3ECai8DAQUOotX7ttJAj4UQ0cpf4B3LhqMwDwroAyr/YuOcjdLtsIKPXCzvK5qRIMiLKqq6eEjge3jBpHq+PBLb7H0WIgoNRrGpcPdX8BMk+JYuH0gb5k9VYMDo+ernVwWLFk9VZfx2MgoNTj9MTUaBY93Gv7ev/AoKflThgIKPX+4LNyE2VVkDYxPxgIKPXYAYxotAkWj0utljthIKDUazmegYDI6JbLpiGfk1HL8jnBLZdN87U/po9S6v3XjreSLgKRb4u7erFy4x4MqSInggUzT8HS9umB9llNEw0rfZSBgFKPbcWUVYu7enHfht0jvw+pjvo9iPbWYmj9YfhoiBrOlBPHJ10EahBWH/phBYOwMBBQQ5l07FF4/Kbzki4GUaowEFBD+eO7Q757XxLVq8jaCETkbgCXAtirqh+oLJsIYBWAFgA7AXxcVd+OqgyUTUFGGnUyMDiE5Wu3cawhIgPLOwIR6RWR50y+ekXkORf7vgfAxTXLFgL4papOAfDLyu9EI6ojjRrHUAkbZygjGs3ujuDSIDtW1adFpKVm8RUAzqv8fC+AJwH8fZDjUH0JOtKoG+ygRjSaZSBQ1V3Vn0XkVABTVPUXIlKw287BJFV9rfLz6wAm+dwP1amor9Y5QxnRkRwbi0XkMwAeAvCDyqL3AegKemBVVdikiIvIDSLSLSLdfX19QQ9HGRHl1boAuPKc8HKvfZeDdZtSxk3W0OcAzAbwRwBQ1e0ATvR5vDdE5CQAqHzfa7Wiqq5Q1TZVbWtubvZ5OMqajrlTUcjnItm3Avi3La85rhc11m1KGzeB4ICqHqz+IiJj4b+z52oA11V+vg7Az33uh+pUe2sRy+ZPR7GpAAHQVAh3LoL+gUGmjxLVcPOs/ykR+QqAgohcCOBvADzitJGIrES5YfgEEXkFwC0AOgE8ICLXA9gF4ON+C07RMqZwNo3LQ7U8HHTQMU3cTK9X7TpfzSAK25LVWxN/PETR8TuFo912YU4LmUZuAsFCANcD6AXwWQCPArjLaSNVXWDx0gWuS0eJqJ0s/u39h+cDKPUPjHw4ez0RzCaht9tXVBlEfifvoPTzWsfcbAfA1z6DyIlgKMYZmRwfDanqMMqpnt8AcCuAeysNvVSnnD6Aq52ywtiv3b6Y709eea1jbrbzu88g4gwCgIs7AhGZB+D7AHagnHhxmoh8VlX/PerCUTLcfAD7+ZC22qZ2efU2nFcb5JXbOhbGdvV0oeKmsfg2AHNU9TxV/TCAOQDuiLZYlCQ3KZx+0jyttjEu7+opoePBLZH0KKb656aOed3O7z6zxE0geEdVXzT8/hKAdyIqD6WAUwqn305ZZvut3deS1VsxOMx7AfLHTR3zup3ffWaJ5aMhEZlf+bFbRB4F8ADKaaNXAXg2hrJRQmpnPwora8jNrEpsyKUg/M7c5Wa7Rs0auszw8xsAPlz5uQ9A/dwTkakwZz+y229XTwmzO9dFMtIoNSa/ddduO6d9Zj291G6sob+MsyDUeMxS9oiyxin1NAvcZA0dg3I/gmkAjqkuV9W/irBc1ADiGGmUKGpJpJeGzU1j8Y8AvBfAXABPoTzoHBuLKbB6Sr+jxuU3ZTVN3PQsfr+qXiUiV6jqvSLyYwD/GXXBKPucnpue3FTg4yDKBLu6bFWPs1S/3dwRVNM4+kXkAwCOg//RR6lBmM00tujh3lEDvrUcz8ZhSj+numxVj7NUv93cEawQkQkAvory6KF/AuBrkZaKLGUlO8Hquemtj2wdKX9SvQVyIgkdmYyyXperc19veMl82nWr5W4UY76bcAwEqlodYO4pAKdHWxyy43dArSRYPR99e//gqEHskrBg5imJHp+yVZetPpCry63GBYp7vKAg7DqU3WS3oareHn5xyI7TlUmapOn5aHUkx5wIFsw8BUvbpyddpIaXpbpsNRJo9c4yipFC4z537O4Ijo2tFORKlrITOuZORcdDWzA4lPxV0Y5llyRdBKqRpbrsdMV/evM4bN+7L84ihc6uQ9mtcRaEnNllJySt9nnvnDOb/c9jR3UvjXXZqs2iqZA3HfqkOnvei33ZDgKAu6yhESLym6gKQs7SOviVWVbF/Rt2c/A4spS2umyXGWSVW1BdnqGmAEtusoaMmG6RIL8DakXN7HlvHZwbFKG01WW7Ngur5Iakkx7C5GaIiS8A+JGq9gNYE32RyE5Ug8EF4eW5roBBgsrSVJft2iycGovrgZtHQ5NQHor6AQC/Egn+7kVkp4j0ishmEekOuj9KltVz3dqKUsjncM2sySg2FXhrSaliN/lMPaSHOnEzZ/FiAFMA/BDApwFsF5F/EJEzAh57jqrOUNW2gPuhhFk97zV+6BebClg2fzqWtk/H+oXn4+XOeckUlsiEXZtF0SJIWC3PIldtBKqqIvI6gNcBHAIwAcBDIvK4qn45ygJSdMLq2Zm2573U2PzUa6c6bOz8BqQjSSNMbtoI/hbApwC8CeAuAB2qOigiYwBsB+AnECiAx0REAfxAVVeYHPcGADcAwOTJk30cguyE3bPTz/PeKDriZAHrdnSC1GurOtwIFzpu7ggmApivqruMC1V1WEQu9XncP1fVkoicCOBxEXlBVZ+u2f8KACsAoK2trfE+LSKWhp6ds06fgPU73orlWGnCuh2dqOp1mhq2o+CmjeCW2iBgeO23fg6qqqXK970AfgbgXD/7If/S0LNz5+/T14uUsi0N9TqLPHUoC4OIjBeRY6s/A7gIwPNxl6PR2WVJxCUtYxFR/UhDvc6i2AMByumovxKRLQCeAbBGVf8jgXI0tDT07KynPGxKhzTU6zBUh6+Ii9eexYGp6ksAzo77uDRaGhrAGrGhmKKVhnodhiWXT8ONqzbHdrzYAwGlR9INYHFPvkGNIel6HYb21mKsgSCJR0NEAMq38fkcHw8RmSnkzT+erZYHwUBAyeLTISJT7w4Oe1oeBAMBJWb52m2RD1XN+w3KqjgzoNhGQJFx6uofR/vA/zxjYuTHoPoX1nAsXsw5sxn3bdhtujxsDAQ0SlgV3qqrf/eut/DEC32xdfBhp7XGE/aHdldPCR3OO72DAAAMr0lEQVQPbhm5ey31D6DjwS0A/A3H4tYTL/R5Wh4EHw3RCLtZmryy6up//4bdI/uPA3uUNpYw63DVktVbj3iEOTisWLJ6a8DS2ouzlzQDAY2wG6fFK6vKGnfbMHuUNpYw63CV2XzFdsvDEmcbAQMBjQjzCiQNH8BZ7FFKwdTTWENx9pJmGwGNONmig5ebD/Xa57JzzmzGTzeVRl2dxTVNpQCZ7VFKwTjVYT/tBxPG5U3nJ54wLtphIOLsJc1AQCM65k71NQGHWcPwTzeVcOU5xZGG4ZObCmg5vhDLsNOc/axx2dVhv3MV3HLZNHzpwS0YMrQT5MYIbrlsWkTv4rC4ekkzENAIv1cgVs9ln3ihD+sXnj+ybMatj4VfaCIDuzo8u3Od77kKxgAYqvm9njAQ0Ch+rkDcPpeNunGNCLCuw37bD8w6Pg4Oa6AG6LSpt8BGCeAY8JQFfuupVaAwPlrKOgYCCsxtdgOHe6Ak+c3CsQoUOZEjHjVlFQMBBdbeWsSy+dNRbCpAUB5eetn86UfcnnN8OUqS23pay2pIh3qaT4NtBBSKehgDnuqfn3pqNaRDTqRugkHdBAKn/GCv+cNmefHVVMjjCnmIAP37B0f2BWR3ViQvfxsv6y7u6sXKjXswpMppKUPidxydqAZNs9uv02u3PrJ1JD+/qZDHksunRX7O+Cmv1eCIQ6oo5HN18XhINAMRra2tTbu7u0ctM/7Tjivkse/gIQwOHX4vhXxuJI+91D9wRGemQj43clto9qG/6pk9gYZIttt/EoHDqpLX5lYb5USwYOYpWNo+fWQfZjnay+ZPR/eut0Z96J/ePA7b9+6L7P24tdNFnwIR2aSqbTEU5wi1ddvpg8rq729Vz6rLOx7aMur8yOcEyz92tuWHoPHCp2lcHqrAHwYGj9yvYTA2AMiPESy/qjwTrVVZARxRHgAYI8DtH5/heB44BbXaC5BqHbb7+wEw7Stw21Vn44urNps+1hQAd1w9I5KZxKr19v2L1uCQ4eBjBXhxmft+Mm7rdiKBQEQuBvCPAHIA7lLVTrv1zU4Wqw+vUceB/XPpYqUSudmXH1b7z+cEUIw6gYwndNjsToDla7c5Dgd97azJWNo+HbM715muO/6oHPYdzMZV0ZQTx+Pxm84btSwtgcDpg97q729Vz6rbGq+8jSaMy6Pnaxe5Pp9q97tk9VbTlOCmQh7jjx5rWVbAegjyapmsOP2NFnf1mg7dfO2sySMXhWZl6t9/0LQOO9XtnZ3z0LJwjeXrfn3HJsB4CQZu63bsjcUikgPwXQAfAXAWgAUicpaXfZh1YDLjFOJe7R9wvS8/rPY/OKRH3G0EHRjLjt1AXG7GYFm5cQ8A6zS6rAQBANi+dx8uvP3JpIthymnANLs8eLttzYIAgJHlXs+B6n7tBmOzK6tdnbMqa5XT36haV2ut3LjHtkxWdTipum2Xlnoogmv3JLKGzgXwoqq+pKoHAfwEwBVedhDWAFInNxUiHYzK6/6jKovdCeAm17/aIFYv/QLS8MjKjFOHJ7s8+CCDrfmpd07b2JU1SD1yep9WjbdDqpnq7xJ3u0MSgaAIwBi2X6ksG0VEbhCRbhHp7usb3Wrv5h/n1DRZzR+OqhL42X9UZbE7Acxyq2tVG3qt8rDZDOyNVd12+qCyy4O327apYD44WnW5n3p3clPBctC1CePytmW1y9u3KqvxuHbLrZISciK2ZbKqw41St1Pbj0BVV6hqm6q2NTePzuM1+4fmxwgmjMuP5AdfM2vyEetU/6nG/GGrfeXGeK8CrvefE+Rr9h/lkMl2J4Axt9rKgpmnALDOw75m1mTT7aacOH7kxMyJ4D1H2wecRmFVt506PNnlwdttu+TyaUfUt/wYwZLLp1ke1051v7dcNq3c3mXcb648GJtdWdtbi7jWpM4Yy2TF6W9Urau1Fsw8xbZMVnX4mlmTMeXE8aavVZebvZesSSJ9tATA+N96X2WZa24HR2s7daLjOlb7ql1mzKLwkvnjdv9RZg05/b2MudVWGRfGfVm9R7vtqi68/clRj2YmHXsUxuZyo8r13Se2j1pnyonjQ32cY3ViJ81NvbbKg3ezrd3/v/Z1N1lDbvZrVaeXtk93dX56fZ/VOmdVF63K5LRdbb01Jh3UbltVbcQ3a/R1amSOOy019qwhERkL4HcALkA5ADwL4JOqajnvm1n6KNE1d/7acVjr2iCS5qwhajxmwWBn57yRFFmzLCc3KdFVbut27HcEqnpIRD4PYC3K6aN32wUBIiv3f+ZDSReBKBCrD/W4e+pnokOZiPQB2JV0OTw6AcCbSRcigCyX32vZT1VV8wFlIhZR3U7b/y5t5QHSV6aoyuOqbmciEGSRiHQn9bghDFkuf5bLHoa0vf+0lQdIX5mSLk9qs4aIiCgeDARERA2OgSA6K5IuQEBZLn+Wyx6GtL3/tJUHSF+ZEi0P2wiIiBoc7wiIiBocA4EPIrJcRF4QkedE5Gci0mR4bZGIvCgi20RkrmH5xZVlL4rIQsPy00RkY2X5KhE5KobyXyUiW0VkWETaal5LffntWJWzXlj970SkRUQGRGRz5ev7htfOEZHeyt/kn0TK436IyEQReVxEtle+TwizTJXXEq1PIrJEREqGv8slfssWlVTUWVXll8cvABcBGFv5+VsAvlX5+SwAWwAcDeA0ADtQ7jSXq/x8OoCjKuucVdnmAQCfqPz8fQB/HUP5/weAqQCeBNBmWJ6J8tu8L8ty1suXzf+uBcDzFts8A2AWysNh/TuAj1SWfxvAwsrPC6v1uJ7qE4AlAP7OZLnnstVzneUdgQ+q+piqHqr8ugHl8ZKA8nDaP1HVA6r6MoAXUR5223To7cqV2fkAHqpsfy+A9hjK/1tVNZv8IBPltxF4iPO0s/nfmRKRkwC8R1U3aPmT519x+H90Bcr/MyDA/y6j9clT2SIqAxI4nikGguD+CuWrLMB6iG2r5ccD6DcEFdMhuWNUr+VvFKeJSI+IPCUi/6uyrIjy36HK+DeZpKqvVX5+HcCkkMuTlvr0+cpj3LsNj7+8li0qqaizdTN5fdhE5BcA3mvy0s2q+vPKOjcDOATg/jjL5oab8lM6+fzfvQZgsqr+XkTOAdAlIvZjOhuoqoqIZQphmuuTXdkAfA/AN1CesPAbAG5D+eKNDBgILKjqX9i9LiKfBnApgAsqt9yA/RDbZst/D6BJRMZWroI8D8ltxan8FlJTfp8CD3GeBn7+d6p6AMCBys+bRGQHgD9F+f2/z7Cq8W/yhoicpKqvVR4h7Q2zTIipPrktm4jcCeDffJYtKqmos3w05IOIXAzgywAuV9X9hpdWA/iEiBwtIqcBmIJyQ92zAKZUMiKOAvAJAKsrAeQJAB+rbH8dgCSvrrJeftNyJlie2IhIs5TnA4eInI7y/+6lyqOfP4rIrMoz+E/h8P9oNcr/MyCa/13i9akS4Ko+CuB5P2ULUgYH6aizcbdO18MXyg1LewBsrnx93/DazShnAWxDJTujsvwSlOdh2IHy7XR1+ekoV8AXATwI4OgYyv9RlJ9FHgDwBoC1WSq/w3szLWe9fFn97wBcCWBrpT7+BsBlhm3aUP4A3AHgX3C4I+nxAH4JYDuAXwCYWG/1CcCPAPQCeA7lD9iT/JatnussexYTETU4PhoiImpwDARERA2OgYCIqMExEBARNTgGAiKiBsdAkEGVERX/zmGde0TkY3br1KzfIiLPO69JFB3W7WQwEBARNTgGgpQRkT+rDJB1jIiMr4zz/gGb9T8jIs+KyBYR+amIjDO8/Bci0i0ivxORSyvr56Q8n8KzleN8NvI3RQTW7TTjWEMpo6rPishqAEsBFADcp6p2t7UPq+qdACAiSwFcD+CfK6+1oDzM7RkAnhCR96M8xMAfVPXPRORoAOtF5DGUB+UiigzrdnoxEKTT11Eeg+RdAP/HYd0PVE6SJgB/AmCt4bUHVHUYwHYReQnAmShPqvNBwzPW41AeZ+V3IZafyArrdgoxEKTT8ShX/DyAY0TkKwDmAYCqzqhZ9x4A7aq6pTIi6nmG12qvhBTlWaq+oKrGkwoi0hJO0YlssW6nENsI0ukHAL6K8jwH31LVm1V1hsmJAgDHAnhNRPIArql57SoRGSMiZ6A8mNc2lK+q/rqyPkTkT0VkfGTvhGg01u0U4h1ByojIpwAMquqPK8MK/5eInK+q6yw2+SqAjQD6Kt+PNby2G+WRHN8D4H+r6rsichfKz1d/UxmWuA/JTi9JDYJ1O704+igRUYPjoyEiogbHQEBE1OAYCIiIGhwDARFRg2MgICJqcAwEREQNjoGAiKjBMRAQETW4/w+YDjpQjly++wAAAABJRU5ErkJggg==\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"Here we perform 5-fold cross validation of a KNN model after using a standard scaler."},{"metadata":{"trusted":true},"cell_type":"code","source":"## Create pipline for cross validation using the standard scaler\nknn_pl = make_pipeline(preprocessing.StandardScaler(),\n                       neighbors.KNeighborsRegressor(500, weights='uniform', metric='manhattan'))\n## Perform 5 fold cross validation\nscores = cross_val_score(knn_pl, X_train, y_train, cv=5, scoring='neg_mean_absolute_error')\nnp.mean(scores)","execution_count":17,"outputs":[{"output_type":"execute_result","execution_count":17,"data":{"text/plain":"-2.160673089320833"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"We get a cross validation score of 2.16. Not bad for such a simple model!"},{"metadata":{"trusted":true},"cell_type":"code","source":"knn_final = neighbors.KNeighborsRegressor(500, weights='uniform', metric='manhattan')\nscaler = preprocessing.StandardScaler()\nscaler.fit(X_train)\nknn_final.fit(scaler.transform(X_train), y_train)\n\nsubmission = pd.read_csv('../input/sample_submission.csv', index_col='seg_id')\nX_test = pd.DataFrame(dtype = np.float64, index = submission.index,columns=range(0,1500))\nfor seg_id in tqdm(X_test.index):\n    seg = pd.read_csv('../input/test/' + seg_id + '.csv')\n    xc = np.sort(seg['acoustic_data'].values)\n    X_test.loc[seg_id,:] = np.reshape(xc, (-1, 100)).sum(axis=-1)\n\nsubmission['time_to_failure'] = knn_final.predict(scaler.transform(X_test))\nprint(submission.head(5))\n\nsubmission.to_csv('knn_std.csv')","execution_count":21,"outputs":[{"output_type":"stream","text":"100%|██████████| 2624/2624 [00:56<00:00, 42.58it/s]\n","name":"stderr"},{"output_type":"stream","text":"            time_to_failure\nseg_id                     \nseg_00030f         4.554798\nseg_0012b5         5.317521\nseg_00184e         5.456752\nseg_003339         8.516055\nseg_0042cc         6.379061\n","name":"stdout"}]}],"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}