support-vector-machines-classifier-using-python.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport matplotlib.pyplot as plt # for data visualization\nimport seaborn as sns # for statistical data visualization\n%matplotlib inline\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 all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n","metadata":{"execution":{"iopub.status.busy":"2022-08-05T08:58:31.031188Z","iopub.execute_input":"2022-08-05T08:58:31.031603Z","iopub.status.idle":"2022-08-05T08:58:31.053155Z","shell.execute_reply.started":"2022-08-05T08:58:31.031572Z","shell.execute_reply":"2022-08-05T08:58:31.051569Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"/kaggle/input/predicting-pulsar-starintermediate/pulsar_data_train.csv\n/kaggle/input/predicting-pulsar-starintermediate/pulsar_data_test.csv\n","output_type":"stream"}]},{"cell_type":"code","source":"data_1 = pd.read_csv('/kaggle/input/predicting-pulsar-starintermediate/pulsar_data_train.csv')\ndata_2 = pd.read_csv('/kaggle/input/predicting-pulsar-starintermediate/pulsar_data_test.csv')\ndf = pd.concat([data_1,data_2])","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:02:00.644620Z","iopub.execute_input":"2022-08-05T09:02:00.645039Z","iopub.status.idle":"2022-08-05T09:02:00.704232Z","shell.execute_reply.started":"2022-08-05T09:02:00.645004Z","shell.execute_reply":"2022-08-05T09:02:00.703136Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"df.head()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T08:58:47.489172Z","iopub.execute_input":"2022-08-05T08:58:47.489790Z","iopub.status.idle":"2022-08-05T08:58:47.514095Z","shell.execute_reply.started":"2022-08-05T08:58:47.489736Z","shell.execute_reply":"2022-08-05T08:58:47.512743Z"},"trusted":true},"execution_count":10,"outputs":[{"execution_count":10,"output_type":"execute_result","data":{"text/plain":"    Mean of the integrated profile  \\\n0                       121.156250   \n1                        76.968750   \n2                       130.585938   \n3                       156.398438   \n4                        84.804688   \n\n    Standard deviation of the integrated profile  \\\n0                                      48.372971   \n1                                      36.175557   \n2                                      53.229534   \n3                                      48.865942   \n4                                      36.117659   \n\n    Excess kurtosis of the integrated profile  \\\n0                                    0.375485   \n1                                    0.712898   \n2                                    0.133408   \n3                                   -0.215989   \n4                                    0.825013   \n\n    Skewness of the integrated profile   Mean of the DM-SNR curve  \\\n0                            -0.013165                   3.168896   \n1                             3.388719                   2.399666   \n2                            -0.297242                   2.743311   \n3                            -0.171294                  17.471572   \n4                             3.274125                   2.790134   \n\n    Standard deviation of the DM-SNR curve  \\\n0                                18.399367   \n1                                17.570997   \n2                                22.362553   \n3                                      NaN   \n4                                20.618009   \n\n    Excess kurtosis of the DM-SNR curve   Skewness of the DM-SNR curve  \\\n0                              7.449874                      65.159298   \n1                              9.414652                     102.722975   \n2                              8.508364                      74.031324   \n3                              2.958066                       7.197842   \n4                              8.405008                      76.291128   \n\n   target_class  \n0           0.0  \n1           0.0  \n2           0.0  \n3           0.0  \n4           0.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>Mean of the integrated profile</th>\n      <th>Standard deviation of the integrated profile</th>\n      <th>Excess kurtosis of the integrated profile</th>\n      <th>Skewness of the integrated profile</th>\n      <th>Mean of the DM-SNR curve</th>\n      <th>Standard deviation of the DM-SNR curve</th>\n      <th>Excess kurtosis of the DM-SNR curve</th>\n      <th>Skewness of the DM-SNR curve</th>\n      <th>target_class</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>121.156250</td>\n      <td>48.372971</td>\n      <td>0.375485</td>\n      <td>-0.013165</td>\n      <td>3.168896</td>\n      <td>18.399367</td>\n      <td>7.449874</td>\n      <td>65.159298</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>76.968750</td>\n      <td>36.175557</td>\n      <td>0.712898</td>\n      <td>3.388719</td>\n      <td>2.399666</td>\n      <td>17.570997</td>\n      <td>9.414652</td>\n      <td>102.722975</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>130.585938</td>\n      <td>53.229534</td>\n      <td>0.133408</td>\n      <td>-0.297242</td>\n      <td>2.743311</td>\n      <td>22.362553</td>\n      <td>8.508364</td>\n      <td>74.031324</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>156.398438</td>\n      <td>48.865942</td>\n      <td>-0.215989</td>\n      <td>-0.171294</td>\n      <td>17.471572</td>\n      <td>NaN</td>\n      <td>2.958066</td>\n      <td>7.197842</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>84.804688</td>\n      <td>36.117659</td>\n      <td>0.825013</td>\n      <td>3.274125</td>\n      <td>2.790134</td>\n      <td>20.618009</td>\n      <td>8.405008</td>\n      <td>76.291128</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"cell_type":"code","source":"df.columns","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:02:06.780966Z","iopub.execute_input":"2022-08-05T09:02:06.781455Z","iopub.status.idle":"2022-08-05T09:02:06.789430Z","shell.execute_reply.started":"2022-08-05T09:02:06.781416Z","shell.execute_reply":"2022-08-05T09:02:06.788325Z"},"trusted":true},"execution_count":12,"outputs":[{"execution_count":12,"output_type":"execute_result","data":{"text/plain":"Index([' Mean of the integrated profile',\n       ' Standard deviation of the integrated profile',\n       ' Excess kurtosis of the integrated profile',\n       ' Skewness of the integrated profile', ' Mean of the DM-SNR curve',\n       ' Standard deviation of the DM-SNR curve',\n       ' Excess kurtosis of the DM-SNR curve', ' Skewness of the DM-SNR curve',\n       'target_class'],\n      dtype='object')"},"metadata":{}}]},{"cell_type":"code","source":"df.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:02:15.385660Z","iopub.execute_input":"2022-08-05T09:02:15.386059Z","iopub.status.idle":"2022-08-05T09:02:15.394446Z","shell.execute_reply.started":"2022-08-05T09:02:15.386027Z","shell.execute_reply":"2022-08-05T09:02:15.393206Z"},"trusted":true},"execution_count":14,"outputs":[{"execution_count":14,"output_type":"execute_result","data":{"text/plain":"(17898, 9)"},"metadata":{}}]},{"cell_type":"code","source":"# remove leading spaces from column names\n\ndf.columns = df.columns.str.strip()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:02:29.905144Z","iopub.execute_input":"2022-08-05T09:02:29.905534Z","iopub.status.idle":"2022-08-05T09:02:29.910903Z","shell.execute_reply.started":"2022-08-05T09:02:29.905503Z","shell.execute_reply":"2022-08-05T09:02:29.909820Z"},"trusted":true},"execution_count":16,"outputs":[]},{"cell_type":"code","source":"# check distribution of target_class column\n\ndf['target_class'].value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.columns = ['IP Mean', 'IP Sd', 'IP Kurtosis', 'IP Skewness', \n              'DM-SNR Mean', 'DM-SNR Sd', 'DM-SNR Kurtosis', 'DM-SNR Skewness', 'target_class']","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:03:07.889229Z","iopub.execute_input":"2022-08-05T09:03:07.889700Z","iopub.status.idle":"2022-08-05T09:03:07.896017Z","shell.execute_reply.started":"2022-08-05T09:03:07.889663Z","shell.execute_reply":"2022-08-05T09:03:07.894666Z"},"trusted":true},"execution_count":18,"outputs":[]},{"cell_type":"code","source":"df.columns","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:03:16.495289Z","iopub.execute_input":"2022-08-05T09:03:16.495719Z","iopub.status.idle":"2022-08-05T09:03:16.504479Z","shell.execute_reply.started":"2022-08-05T09:03:16.495687Z","shell.execute_reply":"2022-08-05T09:03:16.503158Z"},"trusted":true},"execution_count":19,"outputs":[{"execution_count":19,"output_type":"execute_result","data":{"text/plain":"Index(['IP Mean', 'IP Sd', 'IP Kurtosis', 'IP Skewness', 'DM-SNR Mean',\n       'DM-SNR Sd', 'DM-SNR Kurtosis', 'DM-SNR Skewness', 'target_class'],\n      dtype='object')"},"metadata":{}}]},{"cell_type":"code","source":"# check distribution of target_class column\n\ndf['target_class'].value_counts()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:03:37.408663Z","iopub.execute_input":"2022-08-05T09:03:37.409079Z","iopub.status.idle":"2022-08-05T09:03:37.423448Z","shell.execute_reply.started":"2022-08-05T09:03:37.409045Z","shell.execute_reply":"2022-08-05T09:03:37.422511Z"},"trusted":true},"execution_count":20,"outputs":[{"execution_count":20,"output_type":"execute_result","data":{"text/plain":"0.0    11375\n1.0     1153\nName: target_class, dtype: int64"},"metadata":{}}]},{"cell_type":"code","source":"# view the percentage distribution of target_class column\n\ndf['target_class'].value_counts()/np.float(len(df))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:03:55.311741Z","iopub.execute_input":"2022-08-05T09:03:55.312211Z","iopub.status.idle":"2022-08-05T09:03:55.323073Z","shell.execute_reply.started":"2022-08-05T09:03:55.312175Z","shell.execute_reply":"2022-08-05T09:03:55.322097Z"},"trusted":true},"execution_count":21,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:3: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\nDeprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n  This is separate from the ipykernel package so we can avoid doing imports until\n","output_type":"stream"},{"execution_count":21,"output_type":"execute_result","data":{"text/plain":"0.0    0.635546\n1.0    0.064421\nName: target_class, dtype: float64"},"metadata":{}}]},{"cell_type":"code","source":"df.info()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:04:07.415564Z","iopub.execute_input":"2022-08-05T09:04:07.416025Z","iopub.status.idle":"2022-08-05T09:04:07.440846Z","shell.execute_reply.started":"2022-08-05T09:04:07.415987Z","shell.execute_reply":"2022-08-05T09:04:07.439682Z"},"trusted":true},"execution_count":22,"outputs":[{"name":"stdout","text":"<class 'pandas.core.frame.DataFrame'>\nInt64Index: 17898 entries, 0 to 5369\nData columns (total 9 columns):\n #   Column           Non-Null Count  Dtype  \n---  ------           --------------  -----  \n 0   IP Mean          17898 non-null  float64\n 1   IP Sd            17898 non-null  float64\n 2   IP Kurtosis      15396 non-null  float64\n 3   IP Skewness      17898 non-null  float64\n 4   DM-SNR Mean      17898 non-null  float64\n 5   DM-SNR Sd        16196 non-null  float64\n 6   DM-SNR Kurtosis  17898 non-null  float64\n 7   DM-SNR Skewness  17029 non-null  float64\n 8   target_class     12528 non-null  float64\ndtypes: float64(9)\nmemory usage: 1.4 MB\n","output_type":"stream"}]},{"cell_type":"code","source":"# check for missing values in variables\n\ndf.isnull().sum()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:04:25.774975Z","iopub.execute_input":"2022-08-05T09:04:25.775402Z","iopub.status.idle":"2022-08-05T09:04:25.789053Z","shell.execute_reply.started":"2022-08-05T09:04:25.775368Z","shell.execute_reply":"2022-08-05T09:04:25.787584Z"},"trusted":true},"execution_count":23,"outputs":[{"execution_count":23,"output_type":"execute_result","data":{"text/plain":"IP Mean               0\nIP Sd                 0\nIP Kurtosis        2502\nIP Skewness           0\nDM-SNR Mean           0\nDM-SNR Sd          1702\nDM-SNR Kurtosis       0\nDM-SNR Skewness     869\ntarget_class       5370\ndtype: int64"},"metadata":{}}]},{"cell_type":"code","source":"#Mean - missed value\ndf[\"IP Kurtosis\"] = df[\"IP Kurtosis\"].replace(np.NaN, df[\"IP Kurtosis\"].mean())\ndf[\"DM-SNR Sd\"] = df[\"DM-SNR Sd\"].replace(np.NaN, df[\"DM-SNR Sd\"].mean())\ndf[\"DM-SNR Skewness\"] = df[\"DM-SNR Skewness\"].replace(np.NaN, df[\"DM-SNR Skewness\"].mean())","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:18:41.171016Z","iopub.execute_input":"2022-08-05T09:18:41.171583Z","iopub.status.idle":"2022-08-05T09:18:41.183038Z","shell.execute_reply.started":"2022-08-05T09:18:41.171546Z","shell.execute_reply":"2022-08-05T09:18:41.181666Z"},"trusted":true},"execution_count":27,"outputs":[]},{"cell_type":"code","source":"df.dropna(inplace=True)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:19:26.431527Z","iopub.execute_input":"2022-08-05T09:19:26.431972Z","iopub.status.idle":"2022-08-05T09:19:26.441379Z","shell.execute_reply.started":"2022-08-05T09:19:26.431935Z","shell.execute_reply":"2022-08-05T09:19:26.439974Z"},"trusted":true},"execution_count":29,"outputs":[]},{"cell_type":"code","source":"df.isnull().sum()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:19:39.480056Z","iopub.execute_input":"2022-08-05T09:19:39.480493Z","iopub.status.idle":"2022-08-05T09:19:39.491673Z","shell.execute_reply.started":"2022-08-05T09:19:39.480459Z","shell.execute_reply":"2022-08-05T09:19:39.490739Z"},"trusted":true},"execution_count":30,"outputs":[{"execution_count":30,"output_type":"execute_result","data":{"text/plain":"IP Mean            0\nIP Sd              0\nIP Kurtosis        0\nIP Skewness        0\nDM-SNR Mean        0\nDM-SNR Sd          0\nDM-SNR Kurtosis    0\nDM-SNR Skewness    0\ntarget_class       0\ndtype: int64"},"metadata":{}}]},{"cell_type":"markdown","source":"**Outliers in numerical variables**","metadata":{}},{"cell_type":"code","source":"\nround(df.describe(),2)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:19:42.981989Z","iopub.execute_input":"2022-08-05T09:19:42.984528Z","iopub.status.idle":"2022-08-05T09:19:43.039447Z","shell.execute_reply.started":"2022-08-05T09:19:42.984481Z","shell.execute_reply":"2022-08-05T09:19:43.038214Z"},"trusted":true},"execution_count":31,"outputs":[{"execution_count":31,"output_type":"execute_result","data":{"text/plain":"        IP Mean     IP Sd  IP Kurtosis  IP Skewness  DM-SNR Mean  DM-SNR Sd  \\\ncount  12528.00  12528.00     12528.00     12528.00     12528.00   12528.00   \nmean     111.04     46.52         0.48         1.78        12.67      26.35   \nstd       25.67      6.80         0.99         6.21        29.61      18.67   \nmin        5.81     24.77        -1.74        -1.79         0.21       7.37   \n25%      100.87     42.36         0.06        -0.19         1.91      14.76   \n50%      115.18     46.93         0.29         0.20         2.79      19.62   \n75%      127.11     50.98         0.48         0.93         5.41      26.47   \nmax      189.73     91.81         8.07        68.10       222.42     110.64   \n\n       DM-SNR Kurtosis  DM-SNR Skewness  target_class  \ncount         12528.00         12528.00      12528.00  \nmean              8.33           105.49          0.09  \nstd               4.54           104.69          0.29  \nmin              -3.14            -1.98          0.00  \n25%               5.80            38.13          0.00  \n50%               8.45            87.80          0.00  \n75%              10.73           135.77          0.00  \nmax              34.54          1191.00          1.00  ","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>IP Mean</th>\n      <th>IP Sd</th>\n      <th>IP Kurtosis</th>\n      <th>IP Skewness</th>\n      <th>DM-SNR Mean</th>\n      <th>DM-SNR Sd</th>\n      <th>DM-SNR Kurtosis</th>\n      <th>DM-SNR Skewness</th>\n      <th>target_class</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n      <td>12528.00</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>111.04</td>\n      <td>46.52</td>\n      <td>0.48</td>\n      <td>1.78</td>\n      <td>12.67</td>\n      <td>26.35</td>\n      <td>8.33</td>\n      <td>105.49</td>\n      <td>0.09</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>25.67</td>\n      <td>6.80</td>\n      <td>0.99</td>\n      <td>6.21</td>\n      <td>29.61</td>\n      <td>18.67</td>\n      <td>4.54</td>\n      <td>104.69</td>\n      <td>0.29</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>5.81</td>\n      <td>24.77</td>\n      <td>-1.74</td>\n      <td>-1.79</td>\n      <td>0.21</td>\n      <td>7.37</td>\n      <td>-3.14</td>\n      <td>-1.98</td>\n      <td>0.00</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>100.87</td>\n      <td>42.36</td>\n      <td>0.06</td>\n      <td>-0.19</td>\n      <td>1.91</td>\n      <td>14.76</td>\n      <td>5.80</td>\n      <td>38.13</td>\n      <td>0.00</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>115.18</td>\n      <td>46.93</td>\n      <td>0.29</td>\n      <td>0.20</td>\n      <td>2.79</td>\n      <td>19.62</td>\n      <td>8.45</td>\n      <td>87.80</td>\n      <td>0.00</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>127.11</td>\n      <td>50.98</td>\n      <td>0.48</td>\n      <td>0.93</td>\n      <td>5.41</td>\n      <td>26.47</td>\n      <td>10.73</td>\n      <td>135.77</td>\n      <td>0.00</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>189.73</td>\n      <td>91.81</td>\n      <td>8.07</td>\n      <td>68.10</td>\n      <td>222.42</td>\n      <td>110.64</td>\n      <td>34.54</td>\n      <td>1191.00</td>\n      <td>1.00</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"cell_type":"code","source":"# draw boxplots to visualize outliers\n\nplt.figure(figsize=(24,20))\n\n\nplt.subplot(4, 2, 1)\nfig = df.boxplot(column='IP Mean')\nfig.set_title('')\nfig.set_ylabel('IP Mean')\n\n\nplt.subplot(4, 2, 2)\nfig = df.boxplot(column='IP Sd')\nfig.set_title('')\nfig.set_ylabel('IP Sd')\n\n\nplt.subplot(4, 2, 3)\nfig = df.boxplot(column='IP Kurtosis')\nfig.set_title('')\nfig.set_ylabel('IP Kurtosis')\n\n\nplt.subplot(4, 2, 4)\nfig = df.boxplot(column='IP Skewness')\nfig.set_title('')\nfig.set_ylabel('IP Skewness')\n\n\nplt.subplot(4, 2, 5)\nfig = df.boxplot(column='DM-SNR Mean')\nfig.set_title('')\nfig.set_ylabel('DM-SNR Mean')\n\n\nplt.subplot(4, 2, 6)\nfig = df.boxplot(column='DM-SNR Sd')\nfig.set_title('')\nfig.set_ylabel('DM-SNR Sd')\n\n\nplt.subplot(4, 2, 7)\nfig = df.boxplot(column='DM-SNR Kurtosis')\nfig.set_title('')\nfig.set_ylabel('DM-SNR Kurtosis')\n\n\nplt.subplot(4, 2, 8)\nfig = df.boxplot(column='DM-SNR Skewness')\nfig.set_title('')\nfig.set_ylabel('DM-SNR Skewness')","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:19:46.546697Z","iopub.execute_input":"2022-08-05T09:19:46.547191Z","iopub.status.idle":"2022-08-05T09:19:47.576139Z","shell.execute_reply.started":"2022-08-05T09:19:46.547149Z","shell.execute_reply":"2022-08-05T09:19:47.575215Z"},"trusted":true},"execution_count":32,"outputs":[{"execution_count":32,"output_type":"execute_result","data":{"text/plain":"Text(0, 0.5, 'DM-SNR Skewness')"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1728x1440 with 8 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"**Check the distribution of variables**\nNow, I will plot the histograms to check distributions to find out if they are normal or skewed.","metadata":{}},{"cell_type":"code","source":"# plot histogram to check distribution\n\n\nplt.figure(figsize=(24,20))\n\n\nplt.subplot(4, 2, 1)\nfig = df['IP Mean'].hist(bins=20)\nfig.set_xlabel('IP Mean')\nfig.set_ylabel('Number of pulsar stars')\n\n\nplt.subplot(4, 2, 2)\nfig = df['IP Sd'].hist(bins=20)\nfig.set_xlabel('IP Sd')\nfig.set_ylabel('Number of pulsar stars')\n\n\nplt.subplot(4, 2, 3)\nfig = df['IP Kurtosis'].hist(bins=20)\nfig.set_xlabel('IP Kurtosis')\nfig.set_ylabel('Number of pulsar stars')\n\n\n\nplt.subplot(4, 2, 4)\nfig = df['IP Skewness'].hist(bins=20)\nfig.set_xlabel('IP Skewness')\nfig.set_ylabel('Number of pulsar stars')\n\n\n\nplt.subplot(4, 2, 5)\nfig = df['DM-SNR Mean'].hist(bins=20)\nfig.set_xlabel('DM-SNR Mean')\nfig.set_ylabel('Number of pulsar stars')\n\n\n\nplt.subplot(4, 2, 6)\nfig = df['DM-SNR Sd'].hist(bins=20)\nfig.set_xlabel('DM-SNR Sd')\nfig.set_ylabel('Number of pulsar stars')\n\n\n\nplt.subplot(4, 2, 7)\nfig = df['DM-SNR Kurtosis'].hist(bins=20)\nfig.set_xlabel('DM-SNR Kurtosis')\nfig.set_ylabel('Number of pulsar stars')\n\n\nplt.subplot(4, 2, 8)\nfig = df['DM-SNR Skewness'].hist(bins=20)\nfig.set_xlabel('DM-SNR Skewness')\nfig.set_ylabel('Number of pulsar stars')","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:19:51.547472Z","iopub.execute_input":"2022-08-05T09:19:51.548463Z","iopub.status.idle":"2022-08-05T09:19:53.458898Z","shell.execute_reply.started":"2022-08-05T09:19:51.548413Z","shell.execute_reply":"2022-08-05T09:19:53.457335Z"},"trusted":true},"execution_count":33,"outputs":[{"execution_count":33,"output_type":"execute_result","data":{"text/plain":"Text(0, 0.5, 'Number of pulsar stars')"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1728x1440 with 8 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"****Declare feature vector and target variable****","metadata":{}},{"cell_type":"code","source":"X = df.drop(['target_class'], axis=1)\n\ny = df['target_class']","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:20:34.127330Z","iopub.execute_input":"2022-08-05T09:20:34.127730Z","iopub.status.idle":"2022-08-05T09:20:34.135196Z","shell.execute_reply.started":"2022-08-05T09:20:34.127700Z","shell.execute_reply":"2022-08-05T09:20:34.134313Z"},"trusted":true},"execution_count":34,"outputs":[]},{"cell_type":"markdown","source":"**Split data into separate training and test set**","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:21:43.957673Z","iopub.execute_input":"2022-08-05T09:21:43.958100Z","iopub.status.idle":"2022-08-05T09:21:44.110217Z","shell.execute_reply.started":"2022-08-05T09:21:43.958067Z","shell.execute_reply":"2022-08-05T09:21:44.108712Z"},"trusted":true},"execution_count":36,"outputs":[]},{"cell_type":"code","source":"X_train.shape, X_test.shape","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:21:48.214684Z","iopub.execute_input":"2022-08-05T09:21:48.215154Z","iopub.status.idle":"2022-08-05T09:21:48.223431Z","shell.execute_reply.started":"2022-08-05T09:21:48.215103Z","shell.execute_reply":"2022-08-05T09:21:48.221682Z"},"trusted":true},"execution_count":37,"outputs":[{"execution_count":37,"output_type":"execute_result","data":{"text/plain":"((10022, 8), (2506, 8))"},"metadata":{}}]},{"cell_type":"markdown","source":"**Feature Scaling**","metadata":{}},{"cell_type":"code","source":"cols = X_train.columns","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:22:16.331919Z","iopub.execute_input":"2022-08-05T09:22:16.332341Z","iopub.status.idle":"2022-08-05T09:22:16.337743Z","shell.execute_reply.started":"2022-08-05T09:22:16.332309Z","shell.execute_reply":"2022-08-05T09:22:16.336367Z"},"trusted":true},"execution_count":38,"outputs":[]},{"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\nscaler = StandardScaler()\n\nX_train = scaler.fit_transform(X_train)\n\nX_test = scaler.transform(X_test)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:23:32.197313Z","iopub.execute_input":"2022-08-05T09:23:32.197711Z","iopub.status.idle":"2022-08-05T09:23:32.214806Z","shell.execute_reply.started":"2022-08-05T09:23:32.197669Z","shell.execute_reply":"2022-08-05T09:23:32.213456Z"},"trusted":true},"execution_count":40,"outputs":[]},{"cell_type":"code","source":"X_train = pd.DataFrame(X_train, columns=[cols])","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:23:34.793039Z","iopub.execute_input":"2022-08-05T09:23:34.793497Z","iopub.status.idle":"2022-08-05T09:23:34.800783Z","shell.execute_reply.started":"2022-08-05T09:23:34.793462Z","shell.execute_reply":"2022-08-05T09:23:34.799509Z"},"trusted":true},"execution_count":41,"outputs":[]},{"cell_type":"code","source":"X_test = pd.DataFrame(X_test, columns=[cols])","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:23:37.304799Z","iopub.execute_input":"2022-08-05T09:23:37.305234Z","iopub.status.idle":"2022-08-05T09:23:37.313075Z","shell.execute_reply.started":"2022-08-05T09:23:37.305200Z","shell.execute_reply":"2022-08-05T09:23:37.311554Z"},"trusted":true},"execution_count":42,"outputs":[]},{"cell_type":"code","source":"X_train.describe()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:23:47.480539Z","iopub.execute_input":"2022-08-05T09:23:47.480995Z","iopub.status.idle":"2022-08-05T09:23:47.543256Z","shell.execute_reply.started":"2022-08-05T09:23:47.480957Z","shell.execute_reply":"2022-08-05T09:23:47.541029Z"},"trusted":true},"execution_count":43,"outputs":[{"execution_count":43,"output_type":"execute_result","data":{"text/plain":"            IP Mean         IP Sd   IP Kurtosis   IP Skewness   DM-SNR Mean  \\\ncount  1.002200e+04  1.002200e+04  1.002200e+04  1.002200e+04  1.002200e+04   \nmean  -2.580698e-16 -7.770453e-16  1.985152e-17 -1.595212e-17 -3.030902e-17   \nstd    1.000050e+00  1.000050e+00  1.000050e+00  1.000050e+00  1.000050e+00   \nmin   -4.059253e+00 -3.121855e+00 -2.221290e+00 -5.703669e-01 -4.225211e-01   \n25%   -3.943394e-01 -6.101706e-01 -4.263520e-01 -3.175801e-01 -3.653436e-01   \n50%    1.619199e-01  5.986146e-02 -1.918724e-01 -2.549120e-01 -3.355278e-01   \n75%    6.265131e-01  6.579129e-01 -4.944095e-03 -1.397269e-01 -2.459675e-01   \nmax    3.045294e+00  6.647182e+00  7.578489e+00  1.045442e+01  7.074053e+00   \n\n          DM-SNR Sd DM-SNR Kurtosis DM-SNR Skewness  \ncount  1.002200e+04    1.002200e+04    1.002200e+04  \nmean   2.334326e-16   -1.318708e-16    1.985152e-17  \nstd    1.000050e+00    1.000050e+00    1.000050e+00  \nmin   -1.014837e+00   -2.526379e+00   -1.026447e+00  \n25%   -6.206802e-01   -5.589324e-01   -6.452750e-01  \n50%   -3.626338e-01    2.442155e-02   -1.676041e-01  \n75%    1.642291e-02    5.276848e-01    2.886981e-01  \nmax    4.496131e+00    5.769814e+00    1.036494e+01  ","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 tr th {\n        text-align: left;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr>\n      <th></th>\n      <th>IP Mean</th>\n      <th>IP Sd</th>\n      <th>IP Kurtosis</th>\n      <th>IP Skewness</th>\n      <th>DM-SNR Mean</th>\n      <th>DM-SNR Sd</th>\n      <th>DM-SNR Kurtosis</th>\n      <th>DM-SNR Skewness</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n      <td>1.002200e+04</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>-2.580698e-16</td>\n      <td>-7.770453e-16</td>\n      <td>1.985152e-17</td>\n      <td>-1.595212e-17</td>\n      <td>-3.030902e-17</td>\n      <td>2.334326e-16</td>\n      <td>-1.318708e-16</td>\n      <td>1.985152e-17</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n      <td>1.000050e+00</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>-4.059253e+00</td>\n      <td>-3.121855e+00</td>\n      <td>-2.221290e+00</td>\n      <td>-5.703669e-01</td>\n      <td>-4.225211e-01</td>\n      <td>-1.014837e+00</td>\n      <td>-2.526379e+00</td>\n      <td>-1.026447e+00</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>-3.943394e-01</td>\n      <td>-6.101706e-01</td>\n      <td>-4.263520e-01</td>\n      <td>-3.175801e-01</td>\n      <td>-3.653436e-01</td>\n      <td>-6.206802e-01</td>\n      <td>-5.589324e-01</td>\n      <td>-6.452750e-01</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>1.619199e-01</td>\n      <td>5.986146e-02</td>\n      <td>-1.918724e-01</td>\n      <td>-2.549120e-01</td>\n      <td>-3.355278e-01</td>\n      <td>-3.626338e-01</td>\n      <td>2.442155e-02</td>\n      <td>-1.676041e-01</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>6.265131e-01</td>\n      <td>6.579129e-01</td>\n      <td>-4.944095e-03</td>\n      <td>-1.397269e-01</td>\n      <td>-2.459675e-01</td>\n      <td>1.642291e-02</td>\n      <td>5.276848e-01</td>\n      <td>2.886981e-01</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>3.045294e+00</td>\n      <td>6.647182e+00</td>\n      <td>7.578489e+00</td>\n      <td>1.045442e+01</td>\n      <td>7.074053e+00</td>\n      <td>4.496131e+00</td>\n      <td>5.769814e+00</td>\n      <td>1.036494e+01</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"cell_type":"markdown","source":"**Run SVM with default hyperparameters**","metadata":{}},{"cell_type":"code","source":"# import SVC classifier\nfrom sklearn.svm import SVC\n# import metrics to compute accuracy\nfrom sklearn.metrics import accuracy_score\n\n\n# instantiate classifier with default hyperparameters\nsvc=SVC() \n# fit classifier to training set\nsvc.fit(X_train,y_train)\n# make predictions on test set\ny_pred=svc.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with default hyperparameters: {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:24:59.034786Z","iopub.execute_input":"2022-08-05T09:24:59.035222Z","iopub.status.idle":"2022-08-05T09:24:59.653812Z","shell.execute_reply.started":"2022-08-05T09:24:59.035186Z","shell.execute_reply":"2022-08-05T09:24:59.652617Z"},"trusted":true},"execution_count":44,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with default hyperparameters: 0.9796\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with rbf kernel and C=100\nsvc=SVC(C=100.0) \n# fit classifier to training set\nsvc.fit(X_train,y_train)\n# make predictions on test set\ny_pred=svc.predict(X_test)\n# compute and print accuracy score\nprint('Model accuracy score with rbf kernel and C=100.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:51:42.843337Z","iopub.execute_input":"2022-08-05T09:51:42.844144Z","iopub.status.idle":"2022-08-05T09:51:44.077784Z","shell.execute_reply.started":"2022-08-05T09:51:42.844072Z","shell.execute_reply":"2022-08-05T09:51:44.076180Z"},"trusted":true},"execution_count":46,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with rbf kernel and C=100.0 : 0.9804\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with rbf kernel and C=1000\nsvc=SVC(C=1000.0) \n\n\n# fit classifier to training set\nsvc.fit(X_train,y_train)\n\n\n# make predictions on test set\ny_pred=svc.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with rbf kernel and C=1000.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:52:02.252141Z","iopub.execute_input":"2022-08-05T09:52:02.252772Z","iopub.status.idle":"2022-08-05T09:52:06.271477Z","shell.execute_reply.started":"2022-08-05T09:52:02.252736Z","shell.execute_reply":"2022-08-05T09:52:06.270325Z"},"trusted":true},"execution_count":48,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with rbf kernel and C=1000.0 : 0.9808\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with linear kernel and C=1.0\nlinear_svc=SVC(kernel='linear', C=1.0) \n\n\n# fit classifier to training set\nlinear_svc.fit(X_train,y_train)\n\n\n# make predictions on test set\ny_pred_test=linear_svc.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with linear kernel and C=1.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred_test)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:52:10.874493Z","iopub.execute_input":"2022-08-05T09:52:10.875012Z","iopub.status.idle":"2022-08-05T09:52:11.319352Z","shell.execute_reply.started":"2022-08-05T09:52:10.874965Z","shell.execute_reply":"2022-08-05T09:52:11.318000Z"},"trusted":true},"execution_count":49,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with linear kernel and C=1.0 : 0.9777\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with linear kernel and C=100.0\nlinear_svc100=SVC(kernel='linear', C=100.0) \n\n\n# fit classifier to training set\nlinear_svc100.fit(X_train, y_train)\n\n\n# make predictions on test set\ny_pred=linear_svc100.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with linear kernel and C=100.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:52:30.763886Z","iopub.execute_input":"2022-08-05T09:52:30.764414Z","iopub.status.idle":"2022-08-05T09:52:36.640937Z","shell.execute_reply.started":"2022-08-05T09:52:30.764372Z","shell.execute_reply":"2022-08-05T09:52:36.639330Z"},"trusted":true},"execution_count":50,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with linear kernel and C=100.0 : 0.9773\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with linear kernel and C=1000.0\nlinear_svc1000=SVC(kernel='linear', C=1000.0) \n\n\n# fit classifier to training set\nlinear_svc1000.fit(X_train, y_train)\n\n\n# make predictions on test set\ny_pred=linear_svc1000.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with linear kernel and C=1000.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:52:44.098567Z","iopub.execute_input":"2022-08-05T09:52:44.098995Z","iopub.status.idle":"2022-08-05T09:53:26.334877Z","shell.execute_reply.started":"2022-08-05T09:52:44.098961Z","shell.execute_reply":"2022-08-05T09:53:26.333689Z"},"trusted":true},"execution_count":51,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with linear kernel and C=1000.0 : 0.9773\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"y_pred_train = linear_svc.predict(X_train)\n\ny_pred_train","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:53:26.337190Z","iopub.execute_input":"2022-08-05T09:53:26.338153Z","iopub.status.idle":"2022-08-05T09:53:26.518472Z","shell.execute_reply.started":"2022-08-05T09:53:26.338082Z","shell.execute_reply":"2022-08-05T09:53:26.517349Z"},"trusted":true},"execution_count":52,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"execution_count":52,"output_type":"execute_result","data":{"text/plain":"array([0., 0., 0., ..., 1., 0., 0.])"},"metadata":{}}]},{"cell_type":"code","source":"print('Training-set accuracy score: {0:0.4f}'. format(accuracy_score(y_train, y_pred_train)))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# print the scores on training and test set\n\nprint('Training set score: {:.4f}'.format(linear_svc.score(X_train, y_train)))\n\nprint('Test set score: {:.4f}'.format(linear_svc.score(X_test, y_test)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:53:36.773590Z","iopub.execute_input":"2022-08-05T09:53:36.773977Z","iopub.status.idle":"2022-08-05T09:53:36.997480Z","shell.execute_reply.started":"2022-08-05T09:53:36.773943Z","shell.execute_reply":"2022-08-05T09:53:36.996032Z"},"trusted":true},"execution_count":54,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Training set score: 0.9756\nTest set score: 0.9777\n","output_type":"stream"}]},{"cell_type":"code","source":"# check class distribution in test set\n\ny_test.value_counts()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:53:55.134362Z","iopub.execute_input":"2022-08-05T09:53:55.134765Z","iopub.status.idle":"2022-08-05T09:53:55.144774Z","shell.execute_reply.started":"2022-08-05T09:53:55.134732Z","shell.execute_reply":"2022-08-05T09:53:55.143582Z"},"trusted":true},"execution_count":55,"outputs":[{"execution_count":55,"output_type":"execute_result","data":{"text/plain":"0.0    2285\n1.0     221\nName: target_class, dtype: int64"},"metadata":{}}]},{"cell_type":"code","source":"\nnull_accuracy = (3306/(3306+274))\n\nprint('Null accuracy score: {0:0.4f}'. format(null_accuracy))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:54:11.028953Z","iopub.execute_input":"2022-08-05T09:54:11.029397Z","iopub.status.idle":"2022-08-05T09:54:11.036261Z","shell.execute_reply.started":"2022-08-05T09:54:11.029361Z","shell.execute_reply":"2022-08-05T09:54:11.034601Z"},"trusted":true},"execution_count":56,"outputs":[{"name":"stdout","text":"Null accuracy score: 0.9235\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with sigmoid kernel and C=1.0\nsigmoid_svc=SVC(kernel='sigmoid', C=1.0) \n\n\n# fit classifier to training set\nsigmoid_svc.fit(X_train,y_train)\n\n\n# make predictions on test set\ny_pred=sigmoid_svc.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with sigmoid kernel and C=1.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:54:44.789758Z","iopub.execute_input":"2022-08-05T09:54:44.790224Z","iopub.status.idle":"2022-08-05T09:54:46.193349Z","shell.execute_reply.started":"2022-08-05T09:54:44.790169Z","shell.execute_reply":"2022-08-05T09:54:46.191991Z"},"trusted":true},"execution_count":57,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with sigmoid kernel and C=1.0 : 0.8767\n","output_type":"stream"}]},{"cell_type":"code","source":"# instantiate classifier with sigmoid kernel and C=100.0\nsigmoid_svc100=SVC(kernel='sigmoid', C=100.0) \n\n\n# fit classifier to training set\nsigmoid_svc100.fit(X_train,y_train)\n\n\n# make predictions on test set\ny_pred=sigmoid_svc100.predict(X_test)\n\n\n# compute and print accuracy score\nprint('Model accuracy score with sigmoid kernel and C=100.0 : {0:0.4f}'. format(accuracy_score(y_test, y_pred)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:54:58.252065Z","iopub.execute_input":"2022-08-05T09:54:58.253238Z","iopub.status.idle":"2022-08-05T09:54:59.632386Z","shell.execute_reply.started":"2022-08-05T09:54:58.253083Z","shell.execute_reply":"2022-08-05T09:54:59.630960Z"},"trusted":true},"execution_count":58,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Model accuracy score with sigmoid kernel and C=100.0 : 0.8767\n","output_type":"stream"}]},{"cell_type":"code","source":"from sklearn.metrics import confusion_matrix\n\ncm = confusion_matrix(y_test, y_pred_test)\n\nprint('Confusion matrix\\n\\n', cm)\n\nprint('\\nTrue Positives(TP) = ', cm[0,0])\n\nprint('\\nTrue Negatives(TN) = ', cm[1,1])\n\nprint('\\nFalse Positives(FP) = ', cm[0,1])\n\nprint('\\nFalse Negatives(FN) = ', cm[1,0])","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:55:12.899544Z","iopub.execute_input":"2022-08-05T09:55:12.899946Z","iopub.status.idle":"2022-08-05T09:55:12.915215Z","shell.execute_reply.started":"2022-08-05T09:55:12.899915Z","shell.execute_reply":"2022-08-05T09:55:12.914071Z"},"trusted":true},"execution_count":59,"outputs":[{"name":"stdout","text":"Confusion matrix\n\n [[2276    9]\n [  47  174]]\n\nTrue Positives(TP) =  2276\n\nTrue Negatives(TN) =  174\n\nFalse Positives(FP) =  9\n\nFalse Negatives(FN) =  47\n","output_type":"stream"}]},{"cell_type":"code","source":"# visualize confusion matrix with seaborn heatmap\n\ncm_matrix = pd.DataFrame(data=cm, columns=['Actual Positive:1', 'Actual Negative:0'], \n                                 index=['Predict Positive:1', 'Predict Negative:0'])\n\nsns.heatmap(cm_matrix, annot=True, fmt='d', cmap='YlGnBu')","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:55:42.835200Z","iopub.execute_input":"2022-08-05T09:55:42.835605Z","iopub.status.idle":"2022-08-05T09:55:43.089278Z","shell.execute_reply.started":"2022-08-05T09:55:42.835572Z","shell.execute_reply":"2022-08-05T09:55:43.087009Z"},"trusted":true},"execution_count":60,"outputs":[{"execution_count":60,"output_type":"execute_result","data":{"text/plain":"<AxesSubplot:>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 2 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","source":"from sklearn.metrics import classification_report\n\nprint(classification_report(y_test, y_pred_test))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:56:03.286143Z","iopub.execute_input":"2022-08-05T09:56:03.286598Z","iopub.status.idle":"2022-08-05T09:56:03.305404Z","shell.execute_reply.started":"2022-08-05T09:56:03.286541Z","shell.execute_reply":"2022-08-05T09:56:03.304317Z"},"trusted":true},"execution_count":62,"outputs":[{"name":"stdout","text":"              precision    recall  f1-score   support\n\n         0.0       0.98      1.00      0.99      2285\n         1.0       0.95      0.79      0.86       221\n\n    accuracy                           0.98      2506\n   macro avg       0.97      0.89      0.92      2506\nweighted avg       0.98      0.98      0.98      2506\n\n","output_type":"stream"}]},{"cell_type":"code","source":"TP = cm[0,0]\nTN = cm[1,1]\nFP = cm[0,1]\nFN = cm[1,0]","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:56:17.249342Z","iopub.execute_input":"2022-08-05T09:56:17.249742Z","iopub.status.idle":"2022-08-05T09:56:17.256859Z","shell.execute_reply.started":"2022-08-05T09:56:17.249708Z","shell.execute_reply":"2022-08-05T09:56:17.255239Z"},"trusted":true},"execution_count":63,"outputs":[]},{"cell_type":"code","source":"classification_accuracy = (TP + TN) / float(TP + TN + FP + FN)\n\nprint('Classification accuracy : {0:0.4f}'.format(classification_accuracy))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:56:31.475650Z","iopub.execute_input":"2022-08-05T09:56:31.476061Z","iopub.status.idle":"2022-08-05T09:56:31.483628Z","shell.execute_reply.started":"2022-08-05T09:56:31.476028Z","shell.execute_reply":"2022-08-05T09:56:31.482045Z"},"trusted":true},"execution_count":64,"outputs":[{"name":"stdout","text":"Classification accuracy : 0.9777\n","output_type":"stream"}]},{"cell_type":"code","source":"# print classification error\n\nclassification_error = (FP + FN) / float(TP + TN + FP + FN)\n\nprint('Classification error : {0:0.4f}'.format(classification_error))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:56:47.793152Z","iopub.execute_input":"2022-08-05T09:56:47.793608Z","iopub.status.idle":"2022-08-05T09:56:47.801609Z","shell.execute_reply.started":"2022-08-05T09:56:47.793561Z","shell.execute_reply":"2022-08-05T09:56:47.800346Z"},"trusted":true},"execution_count":65,"outputs":[{"name":"stdout","text":"Classification error : 0.0223\n","output_type":"stream"}]},{"cell_type":"code","source":"# print precision score\n\nprecision = TP / float(TP + FP)\n\n\nprint('Precision : {0:0.4f}'.format(precision))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:57:01.138371Z","iopub.execute_input":"2022-08-05T09:57:01.138823Z","iopub.status.idle":"2022-08-05T09:57:01.147415Z","shell.execute_reply.started":"2022-08-05T09:57:01.138786Z","shell.execute_reply":"2022-08-05T09:57:01.145883Z"},"trusted":true},"execution_count":66,"outputs":[{"name":"stdout","text":"Precision : 0.9961\n","output_type":"stream"}]},{"cell_type":"code","source":"recall = TP / float(TP + FN)\n\nprint('Recall or Sensitivity : {0:0.4f}'.format(recall))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:57:22.417667Z","iopub.execute_input":"2022-08-05T09:57:22.418094Z","iopub.status.idle":"2022-08-05T09:57:22.425916Z","shell.execute_reply.started":"2022-08-05T09:57:22.418061Z","shell.execute_reply":"2022-08-05T09:57:22.424284Z"},"trusted":true},"execution_count":67,"outputs":[{"name":"stdout","text":"Recall or Sensitivity : 0.9798\n","output_type":"stream"}]},{"cell_type":"code","source":"true_positive_rate = TP / float(TP + FN)\n\n\nprint('True Positive Rate : {0:0.4f}'.format(true_positive_rate))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:58:28.992955Z","iopub.execute_input":"2022-08-05T09:58:28.993404Z","iopub.status.idle":"2022-08-05T09:58:29.000635Z","shell.execute_reply.started":"2022-08-05T09:58:28.993357Z","shell.execute_reply":"2022-08-05T09:58:28.999177Z"},"trusted":true},"execution_count":68,"outputs":[{"name":"stdout","text":"True Positive Rate : 0.9798\n","output_type":"stream"}]},{"cell_type":"code","source":"false_positive_rate = FP / float(FP + TN)\n\n\nprint('False Positive Rate : {0:0.4f}'.format(false_positive_rate))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:58:31.487142Z","iopub.execute_input":"2022-08-05T09:58:31.487531Z","iopub.status.idle":"2022-08-05T09:58:31.493959Z","shell.execute_reply.started":"2022-08-05T09:58:31.487498Z","shell.execute_reply":"2022-08-05T09:58:31.492925Z"},"trusted":true},"execution_count":69,"outputs":[{"name":"stdout","text":"False Positive Rate : 0.0492\n","output_type":"stream"}]},{"cell_type":"code","source":"specificity = TN / (TN + FP)\n\nprint('Specificity : {0:0.4f}'.format(specificity))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:58:33.367203Z","iopub.execute_input":"2022-08-05T09:58:33.367608Z","iopub.status.idle":"2022-08-05T09:58:33.374732Z","shell.execute_reply.started":"2022-08-05T09:58:33.367577Z","shell.execute_reply":"2022-08-05T09:58:33.373013Z"},"trusted":true},"execution_count":70,"outputs":[{"name":"stdout","text":"Specificity : 0.9508\n","output_type":"stream"}]},{"cell_type":"markdown","source":"**ROC - AUC**","metadata":{}},{"cell_type":"code","source":"\nfrom sklearn.metrics import roc_curve\n\nfpr, tpr, thresholds = roc_curve(y_test, y_pred_test)\n\nplt.figure(figsize=(6,4))\n\nplt.plot(fpr, tpr, linewidth=2)\n\nplt.plot([0,1], [0,1], 'k--' )\n\nplt.rcParams['font.size'] = 12\n\nplt.title('ROC curve for Predicting a Pulsar Star classifier')\n\nplt.xlabel('False Positive Rate (1 - Specificity)')\n\nplt.ylabel('True Positive Rate (Sensitivity)')\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:58:49.991726Z","iopub.execute_input":"2022-08-05T09:58:49.992181Z","iopub.status.idle":"2022-08-05T09:58:50.225598Z","shell.execute_reply.started":"2022-08-05T09:58:49.992145Z","shell.execute_reply":"2022-08-05T09:58:50.224174Z"},"trusted":true},"execution_count":71,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","source":"# compute ROC AUC\n\nfrom sklearn.metrics import roc_auc_score\n\nROC_AUC = roc_auc_score(y_test, y_pred_test)\n\nprint('ROC AUC : {:.4f}'.format(ROC_AUC))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:59:01.200800Z","iopub.execute_input":"2022-08-05T09:59:01.201366Z","iopub.status.idle":"2022-08-05T09:59:01.213629Z","shell.execute_reply.started":"2022-08-05T09:59:01.201316Z","shell.execute_reply":"2022-08-05T09:59:01.212280Z"},"trusted":true},"execution_count":72,"outputs":[{"name":"stdout","text":"ROC AUC : 0.8917\n","output_type":"stream"}]},{"cell_type":"code","source":"# calculate cross-validated ROC AUC \n\nfrom sklearn.model_selection import cross_val_score\n\nCross_validated_ROC_AUC = cross_val_score(linear_svc, X_train, y_train, cv=10, scoring='roc_auc').mean()\n\nprint('Cross validated ROC AUC : {:.4f}'.format(Cross_validated_ROC_AUC))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T09:59:10.641206Z","iopub.execute_input":"2022-08-05T09:59:10.641700Z","iopub.status.idle":"2022-08-05T09:59:13.947445Z","shell.execute_reply.started":"2022-08-05T09:59:10.641658Z","shell.execute_reply":"2022-08-05T09:59:13.945768Z"},"trusted":true},"execution_count":73,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"name":"stdout","text":"Cross validated ROC AUC : 0.9686\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"markdown","source":"** k-fold Cross Validation with shuffle split**","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import KFold\n\n\nkfold=KFold(n_splits=5, shuffle=True, random_state=0)\n\n\nlinear_svc=SVC(kernel='linear')\n\n\nlinear_scores = cross_val_score(linear_svc, X, y, cv=kfold)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:00:03.024373Z","iopub.execute_input":"2022-08-05T10:00:03.024784Z","iopub.status.idle":"2022-08-05T10:02:34.601164Z","shell.execute_reply.started":"2022-08-05T10:00:03.024751Z","shell.execute_reply":"2022-08-05T10:02:34.599878Z"},"trusted":true},"execution_count":74,"outputs":[]},{"cell_type":"code","source":"\nprint('Stratified cross-validation scores with linear kernel:\\n\\n{}'.format(linear_scores))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:02:34.603564Z","iopub.execute_input":"2022-08-05T10:02:34.604032Z","iopub.status.idle":"2022-08-05T10:02:34.612176Z","shell.execute_reply.started":"2022-08-05T10:02:34.603994Z","shell.execute_reply":"2022-08-05T10:02:34.610784Z"},"trusted":true},"execution_count":75,"outputs":[{"name":"stdout","text":"Stratified cross-validation scores with linear kernel:\n\n[0.97765363 0.97805267 0.97605746 0.9744511  0.97644711]\n","output_type":"stream"}]},{"cell_type":"code","source":"# print average cross-validation score with linear kernel\n\nprint('Average stratified cross-validation score with linear kernel:{:.4f}'.format(linear_scores.mean()))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:03:41.140074Z","iopub.execute_input":"2022-08-05T10:03:41.141017Z","iopub.status.idle":"2022-08-05T10:03:41.147284Z","shell.execute_reply.started":"2022-08-05T10:03:41.140971Z","shell.execute_reply":"2022-08-05T10:03:41.146158Z"},"trusted":true},"execution_count":76,"outputs":[{"name":"stdout","text":"Average stratified cross-validation score with linear kernel:0.9765\n","output_type":"stream"}]},{"cell_type":"code","source":"rbf_svc=SVC(kernel='rbf')\n\n\nrbf_scores = cross_val_score(rbf_svc, X, y, cv=kfold)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:03:43.489265Z","iopub.execute_input":"2022-08-05T10:03:43.489687Z","iopub.status.idle":"2022-08-05T10:03:46.408066Z","shell.execute_reply.started":"2022-08-05T10:03:43.489633Z","shell.execute_reply":"2022-08-05T10:03:46.406471Z"},"trusted":true},"execution_count":77,"outputs":[]},{"cell_type":"code","source":"# print cross-validation scores with rbf kernel\n\nprint('Stratified Cross-validation scores with rbf kernel:\\n\\n{}'.format(rbf_scores))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:03:46.411148Z","iopub.execute_input":"2022-08-05T10:03:46.411652Z","iopub.status.idle":"2022-08-05T10:03:46.419570Z","shell.execute_reply.started":"2022-08-05T10:03:46.411605Z","shell.execute_reply":"2022-08-05T10:03:46.418183Z"},"trusted":true},"execution_count":78,"outputs":[{"name":"stdout","text":"Stratified Cross-validation scores with rbf kernel:\n\n[0.97326417 0.97286512 0.9688747  0.97205589 0.96886228]\n","output_type":"stream"}]},{"cell_type":"code","source":"print('Average stratified cross-validation score with rbf kernel:{:.4f}'.format(rbf_scores.mean()))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:03:49.609714Z","iopub.execute_input":"2022-08-05T10:03:49.610149Z","iopub.status.idle":"2022-08-05T10:03:49.616609Z","shell.execute_reply.started":"2022-08-05T10:03:49.610102Z","shell.execute_reply":"2022-08-05T10:03:49.615401Z"},"trusted":true},"execution_count":79,"outputs":[{"name":"stdout","text":"Average stratified cross-validation score with rbf kernel:0.9712\n","output_type":"stream"}]},{"cell_type":"markdown","source":"**Hyperparameter Optimization using GridSearch CV**","metadata":{}},{"cell_type":"code","source":"# import GridSearchCV\nfrom sklearn.model_selection import GridSearchCV\n\n\n# import SVC classifier\nfrom sklearn.svm import SVC\n\n\n# instantiate classifier with default hyperparameters with kernel=rbf, C=1.0 and gamma=auto\nsvc=SVC() \n\n\n\n# declare parameters for hyperparameter tuning\nparameters = [ {'C':[1, 10, 100, 1000], 'kernel':['linear']},\n               {'C':[1, 10, 100, 1000], 'kernel':['rbf'], 'gamma':[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]},\n               {'C':[1, 10, 100, 1000], 'kernel':['poly'], 'degree': [2,3,4] ,'gamma':[0.01,0.02,0.03,0.04,0.05]} \n              ]\n\n\n\n\ngrid_search = GridSearchCV(estimator = svc,  \n                           param_grid = parameters,\n                           scoring = 'accuracy',\n                           cv = 5,\n                           verbose=0)\n\n\ngrid_search.fit(X_train, y_train)","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:03:51.977459Z","iopub.execute_input":"2022-08-05T10:03:51.977864Z","iopub.status.idle":"2022-08-05T10:13:26.148387Z","shell.execute_reply.started":"2022-08-05T10:03:51.977832Z","shell.execute_reply":"2022-08-05T10:13:26.146925Z"},"trusted":true},"execution_count":80,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"},{"execution_count":80,"output_type":"execute_result","data":{"text/plain":"GridSearchCV(cv=5, estimator=SVC(),\n             param_grid=[{'C': [1, 10, 100, 1000], 'kernel': ['linear']},\n                         {'C': [1, 10, 100, 1000],\n                          'gamma': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8,\n                                    0.9],\n                          'kernel': ['rbf']},\n                         {'C': [1, 10, 100, 1000], 'degree': [2, 3, 4],\n                          'gamma': [0.01, 0.02, 0.03, 0.04, 0.05],\n                          'kernel': ['poly']}],\n             scoring='accuracy')"},"metadata":{}}]},{"cell_type":"code","source":"# examine the best model\n\n\n# best score achieved during the GridSearchCV\nprint('GridSearch CV best score : {:.4f}\\n\\n'.format(grid_search.best_score_))\n\n\n# print parameters that give the best results\nprint('Parameters that give the best results :','\\n\\n', (grid_search.best_params_))\n\n\n# print estimator that was chosen by the GridSearch\nprint('\\n\\nEstimator that was chosen by the search :','\\n\\n', (grid_search.best_estimator_))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:13:26.151798Z","iopub.execute_input":"2022-08-05T10:13:26.152954Z","iopub.status.idle":"2022-08-05T10:13:26.162003Z","shell.execute_reply.started":"2022-08-05T10:13:26.152900Z","shell.execute_reply":"2022-08-05T10:13:26.160664Z"},"trusted":true},"execution_count":81,"outputs":[{"name":"stdout","text":"GridSearch CV best score : 0.9786\n\n\nParameters that give the best results : \n\n {'C': 10, 'gamma': 0.2, 'kernel': 'rbf'}\n\n\nEstimator that was chosen by the search : \n\n SVC(C=10, gamma=0.2)\n","output_type":"stream"}]},{"cell_type":"code","source":"\nprint('GridSearch CV score on test set: {0:0.4f}'.format(grid_search.score(X_test, y_test)))","metadata":{"execution":{"iopub.status.busy":"2022-08-05T10:13:26.163909Z","iopub.execute_input":"2022-08-05T10:13:26.164812Z","iopub.status.idle":"2022-08-05T10:13:26.273129Z","shell.execute_reply.started":"2022-08-05T10:13:26.164761Z","shell.execute_reply":"2022-08-05T10:13:26.271923Z"},"trusted":true},"execution_count":82,"outputs":[{"name":"stdout","text":"GridSearch CV score on test set: 0.9804\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/sklearn/utils/validation.py:1692: FutureWarning: Feature names only support names that are all strings. Got feature names with dtypes: ['tuple']. An error will be raised in 1.2.\n  FutureWarning,\n","output_type":"stream"}]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}