{"cells":[{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","collapsed":true,"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":false},"cell_type":"markdown","source":"I am a newbie and this is the code that was created by the user: inversion.\nWould love comments and if anything looks improperly explained, please let me know in the comments.\nthanks!"},{"metadata":{},"cell_type":"markdown","source":"In this competition, you will address when the earthquake will take place. Specifically, you’ll predict the time remaining before laboratory earthquakes occur from real-time seismic data.\n\nHow is the data generated?\n- The data are from an experiment conducted on rock in a double direct shear geometry subjected to bi-axial loading, a classic laboratory earthquake model. (fig. a)\n- Two fault gouge layers are sheared simultaneously while subjected to a constant normal load and a prescribed shear velocity. The laboratory faults fail in repetitive cycles of stick and slip that is meant to mimic the cycle of loading and failure on tectonic faults. While the experiment is considerably simpler than a fault in Earth, it shares many physical characteristics. (fig. b)\n- Los Alamos' initial work showed that the prediction of laboratory earthquakes from continuous seismic data is possible in the case of quasi-periodic laboratory seismic cycles. In this competition, the team has provided a much more challenging dataset with considerably more aperiodic earthquake failures.\n- The seismic data is recorded using a piezoceramic sensor, which outputs a voltage upon deformation by incoming seismic waves. The seismic data of the input is this recorded voltage, in integers.\n- The acoustic data shows the movement of the ground up (positive) and ground down (negative).\n\nPublished work on the topic is in the following papers:\n- https://doi.org/10.1002/2017GL074677\n- https://doi.org/10.1002/2017GL076708\n- https://rdcu.be/bdG8Y\n- https://rdcu.be/bdG9r\n\nThese predictions are based solely on the instantaneous physical characteristics of the acoustical signal and do not make use of its history."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Load package to display pictures and videos\nfrom IPython.display import Audio, Image, YouTubeVideo","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Display a video using the id which is the string between the = and & (if there is an &)\nYouTubeVideo(id='m_dBwwDJ4uo', width=600, height=400)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Display a video using the id which is the string between the = and & (if there is an &)\nYouTubeVideo(id='P7h0JfQ-oHg', width=600, height=400)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Import specific packages and modules\nimport numpy as np\nimport pandas as pd\nimport os\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.svm import NuSVR\nfrom sklearn.metrics import mean_absolute_error\n\nimport os\nprint(os.listdir(\"../input\"))","execution_count":12,"outputs":[{"output_type":"stream","text":"['test', 'train.csv', 'sample_submission.csv']\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Gives number of rows without loading the file first\n! wc -l \"../input/train.csv\"","execution_count":10,"outputs":[{"output_type":"stream","text":"629145481 ../input/train.csv\r\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Load training data\n# I used float32 and not float64 (like the example) since I did not have the memory for float64.\ntrain = pd.read_csv(\"../input/train.csv\", dtype={'acoustic_data': np.int16, 'time_to_failure': np.float32})","execution_count":14,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Display time_to_failure with more units of precision\npd.options.display.precision = 15","execution_count":15,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train.head()","execution_count":16,"outputs":[{"output_type":"execute_result","execution_count":16,"data":{"text/plain":"   acoustic_data    time_to_failure\n0             12  1.469099998474121\n1              6  1.469099998474121\n2              8  1.469099998474121\n3              5  1.469099998474121\n4              8  1.469099998474121","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>acoustic_data</th>\n      <th>time_to_failure</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>12</td>\n      <td>1.469099998474121</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>6</td>\n      <td>1.469099998474121</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>8</td>\n      <td>1.469099998474121</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>5</td>\n      <td>1.469099998474121</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>8</td>\n      <td>1.469099998474121</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Break approximately 600 million rows up into 150K segments.\nrows = 150_000\n\n# Determine how many EQUAL segments to divide total dataset into.\n# Following code takes the first [0] (or zero) column of the train data. Then divides by rows (or 150,000).\n# Then rounds the value down (or floor). Then sets the value as an integer. \nsegments = int(np.floor(train.shape[0] / rows))\nprint(segments)","execution_count":17,"outputs":[{"output_type":"stream","text":"4194\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Create an empty dataframe (X_train) which is the size of the dataset/ 150000 or 4194 with ave, std, max, min columns.\n# Create another empty dataframe (y_train) with just the time to failure.\n# For both dataframes, index is set as range of the segments.\n# range() function returns a sequence of numbers with format range(start, stop, step) with start=1 and step=1 if not given\nX_train = pd.DataFrame(index=range(segments), dtype=np.float64,\n                       columns=['ave', 'std', 'max', 'min'])\ny_train = pd.DataFrame(index=range(segments), dtype=np.float64,\n                       columns=['time_to_failure'])","execution_count":19,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Empty dataframe for X_train\nX_train.head()","execution_count":20,"outputs":[{"output_type":"execute_result","execution_count":20,"data":{"text/plain":"   ave  std  max  min\n0  NaN  NaN  NaN  NaN\n1  NaN  NaN  NaN  NaN\n2  NaN  NaN  NaN  NaN\n3  NaN  NaN  NaN  NaN\n4  NaN  NaN  NaN  NaN","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>ave</th>\n      <th>std</th>\n      <th>max</th>\n      <th>min</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Empty dataframe for y_train\ny_train.head()","execution_count":21,"outputs":[{"output_type":"execute_result","execution_count":21,"data":{"text/plain":"   time_to_failure\n0              NaN\n1              NaN\n2              NaN\n3              NaN\n4              NaN","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  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Calculate all the values for each of the 4194 segments in the X_train dataframe (mean, std, max, min).\n\n# tqdm make your loops show a smart progress meter\n\n# iloc is integer-location based indexing for selection by position\n# [segment*rows:segment*rows+rows] points to which data to apply calculation to\n# loops through all segments starting at 0 to 150k then 150k to 300k, etc.\n# For each segment, the mean, standard deviation, maximum and min are computed.\n\n# Fill in the time values for the y_train dataframe. .values[-1] will point to the last time value in the 150,000 segment\n\nfor segment in tqdm(range(segments)):\n    seg = train.iloc[segment*rows:segment*rows+rows]\n    x = seg['acoustic_data'].values\n    y = seg['time_to_failure'].values[-1]\n    \n    y_train.loc[segment, 'time_to_failure'] = y\n    \n    X_train.loc[segment, 'ave'] = x.mean()\n    X_train.loc[segment, 'std'] = x.std()\n    X_train.loc[segment, 'max'] = x.max()\n    X_train.loc[segment, 'min'] = x.min()","execution_count":22,"outputs":[{"output_type":"stream","text":"100%|██████████| 4194/4194 [00:10<00:00, 384.69it/s]\n","name":"stderr"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# View the X_train dataframe after the engineered features added\nX_train.head()","execution_count":23,"outputs":[{"output_type":"execute_result","execution_count":23,"data":{"text/plain":"                 ave                std    max    min\n0  4.884113333333334  5.101089126891323  104.0  -98.0\n1  4.725766666666667  6.588801819164257  181.0 -154.0\n2  4.906393333333333  6.967373808828945  140.0 -106.0\n3  4.902240000000000  6.922282112791032  197.0 -199.0\n4  4.908720000000000  7.301085852684289  145.0 -126.0","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>ave</th>\n      <th>std</th>\n      <th>max</th>\n      <th>min</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>4.884113333333334</td>\n      <td>5.101089126891323</td>\n      <td>104.0</td>\n      <td>-98.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>4.725766666666667</td>\n      <td>6.588801819164257</td>\n      <td>181.0</td>\n      <td>-154.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>4.906393333333333</td>\n      <td>6.967373808828945</td>\n      <td>140.0</td>\n      <td>-106.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4.902240000000000</td>\n      <td>6.922282112791032</td>\n      <td>197.0</td>\n      <td>-199.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>4.908720000000000</td>\n      <td>7.301085852684289</td>\n      <td>145.0</td>\n      <td>-126.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# View the y_train dataframe after calculation applied to it.\ny_train.head()","execution_count":24,"outputs":[{"output_type":"execute_result","execution_count":24,"data":{"text/plain":"     time_to_failure\n0  1.430797219276428\n1  1.391498923301697\n2  1.353196144104004\n3  1.313797831535339\n4  1.274399518966675","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  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1.430797219276428</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1.391498923301697</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1.353196144104004</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.313797831535339</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.274399518966675</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Create a StandardScaler model called scaler.\n# Normalize/standardize (mean = 0 and standard deviation = 1) features before applying machine learning techniques.\nscaler = StandardScaler()\n\n# fit will apply the scaler model to the dataframe (X_train in this case)\nscaler.fit(X_train)\n\n# transform will look at the dataframe columns one by one and return back a series (or group of series) 'made' of scalars\nX_train_scaled = scaler.transform(X_train)\nprint(X_train_scaled)","execution_count":25,"outputs":[{"output_type":"stream","text":"[[ 1.4241405  -0.17021358 -0.21819351  0.19321819]\n [ 0.80571603  0.00473402  0.06393601 -0.01803727]\n [ 1.51115526  0.0492522  -0.0862888   0.16303883]\n ...\n [ 0.34265275 -0.39124963 -0.36841832  0.4157909 ]\n [-0.21161721 -0.28084016 -0.25483371  0.1969906 ]\n [-0.00415653 -0.37312925 -0.3647543   0.31393559]]\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Create a model Nu Support Vector Regression\n# In simple regression we try to minimise the error rate. While in SVR we try to fit the error within a certain threshold.\n# NuSVR allows you to limit the number of support vectors used.\n# Create svm model and fit to the data\n# .flatten will return a copy of the array collapsed into one dimension\nsvm = NuSVR()\nsvm.fit(X_train_scaled, y_train.values.flatten())\n\n# Predict y (acoustic data) with the model\ny_pred = svm.predict(X_train_scaled)\nprint(y_pred)# Create a model Nu Support Vector Regression\n# In simple regression we try to minimise the error rate. While in SVR we try to fit the error within a certain threshold.\n# NuSVR allows you to limit the number of support vectors used.\n# Create svm model and fit to the data\n# .flatten will return a copy of the array collapsed into one dimension\nsvm = NuSVR()\nsvm.fit(X_train_scaled, y_train.values.flatten())\n\n# Predict y (acoustic data) with the model\ny_pred = svm.predict(X_train_scaled)\nprint(y_pred)","execution_count":26,"outputs":[{"output_type":"stream","text":"[6.54201231 4.69066738 4.42778471 ... 8.82072262 7.64065766 8.67662095]\n[6.54201231 4.69066738 4.42778471 ... 8.82072262 7.64065766 8.67662095]\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Plot y actual vs y predicted\n# Orange diagonal line is point of reference to compare acutal (on x-axis) vs predicted (on y-axis)\nplt.figure(figsize=(6, 6))\nplt.scatter(y_train.values.flatten(), y_pred)\nplt.xlim(0, 20)\nplt.ylim(0, 20)\nplt.xlabel('actual', fontsize=12)\nplt.ylabel('predicted', fontsize=12)\nplt.plot([(0, 0), (20, 20)], [(0, 0), (20, 20)])\nplt.show()","execution_count":27,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x432 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Determine the score of the model\nscore = mean_absolute_error(y_train.values.flatten(), y_pred)\nprint(f'Score: {score:0.3f}')","execution_count":28,"outputs":[{"output_type":"stream","text":"Score: 2.314\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Read in the blank sample submission file\nsubmission = pd.read_csv('../input/sample_submission.csv', index_col='seg_id')\nsubmission.head()","execution_count":31,"outputs":[{"output_type":"execute_result","execution_count":31,"data":{"text/plain":"            time_to_failure\nseg_id                     \nseg_00030f                0\nseg_0012b5                0\nseg_00184e                0\nseg_003339                0\nseg_0042cc                0","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>0</td>\n    </tr>\n    <tr>\n      <th>seg_0012b5</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>seg_00184e</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>seg_003339</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>seg_0042cc</th>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Prepare the dataframe for the test segments so can apply svm model\nX_test = pd.DataFrame(columns=X_train.columns, dtype=np.float64, index=submission.index)\nX_test.head()","execution_count":32,"outputs":[{"output_type":"execute_result","execution_count":32,"data":{"text/plain":"            ave  std  max  min\nseg_id                        \nseg_00030f  NaN  NaN  NaN  NaN\nseg_0012b5  NaN  NaN  NaN  NaN\nseg_00184e  NaN  NaN  NaN  NaN\nseg_003339  NaN  NaN  NaN  NaN\nseg_0042cc  NaN  NaN  NaN  NaN","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>ave</th>\n      <th>std</th>\n      <th>max</th>\n      <th>min</th>\n    </tr>\n    <tr>\n      <th>seg_id</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>seg_00030f</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>seg_0012b5</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>seg_00184e</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>seg_003339</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>seg_0042cc</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Read in each test segment, apply engineered features and put in dataframe.\nfor 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\nX_test.head()","execution_count":34,"outputs":[{"output_type":"execute_result","execution_count":34,"data":{"text/plain":"                          ave                std    max    min\nseg_id                                                        \nseg_00030f  4.491780000000000  4.893673374701939  115.0  -75.0\nseg_0012b5  4.171153333333334  5.922819700375451  152.0 -140.0\nseg_00184e  4.610260000000000  6.946966920827151  248.0 -193.0\nseg_003339  4.531473333333333  4.114132889113924   85.0  -93.0\nseg_0042cc  4.128340000000000  5.797144312308719  177.0 -147.0","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>ave</th>\n      <th>std</th>\n      <th>max</th>\n      <th>min</th>\n    </tr>\n    <tr>\n      <th>seg_id</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>seg_00030f</th>\n      <td>4.491780000000000</td>\n      <td>4.893673374701939</td>\n      <td>115.0</td>\n      <td>-75.0</td>\n    </tr>\n    <tr>\n      <th>seg_0012b5</th>\n      <td>4.171153333333334</td>\n      <td>5.922819700375451</td>\n      <td>152.0</td>\n      <td>-140.0</td>\n    </tr>\n    <tr>\n      <th>seg_00184e</th>\n      <td>4.610260000000000</td>\n      <td>6.946966920827151</td>\n      <td>248.0</td>\n      <td>-193.0</td>\n    </tr>\n    <tr>\n      <th>seg_003339</th>\n      <td>4.531473333333333</td>\n      <td>4.114132889113924</td>\n      <td>85.0</td>\n      <td>-93.0</td>\n    </tr>\n    <tr>\n      <th>seg_0042cc</th>\n      <td>4.128340000000000</td>\n      <td>5.797144312308719</td>\n      <td>177.0</td>\n      <td>-147.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Apply the model to the X_test dataframe by scaling then transforming it.\nX_test_scaled = scaler.transform(X_test)\nsubmission['time_to_failure'] = svm.predict(X_test_scaled)\n\n# Prepare submission for Kaggle\n# Best to use date and submssion\nsubmission.to_csv('submission_one_04_15.csv')","execution_count":39,"outputs":[]}],"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}