data_analysis/reddit_analysis_task.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task for Data Scientist - Analyze reddit group\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collect and analyze data.\n",
    "\n",
    "Create the necessary aggregations and data representations. \n",
    "\n",
    "Create a visualization of the collected data.\n",
    "\n",
    "Provide an analysis of the work done and the results of the test task.\n",
    "\n",
    "* About the data source\n",
    "https://www.reddit.com/r/SnapLenses/\n",
    "\n",
    "This is a community lens subreddit. \n",
    "\n",
    "Community lenses - lenses developed by designers in an open studio. \n",
    "\n",
    "Users can create a lens on their own and send it for review. \n",
    "\n",
    "If the lens passes the review, it will be released for general use.\n",
    "FAQ - https://lensstudio.snapchat.com/support/.\n",
    "\n",
    " ***Task description***\n",
    " \n",
    "It is necessary in any convenient way to collect information on publications in this subreddit (subreddit), and to analyze the data.\n",
    "\n",
    "Questions and tasks that must be completed as part of the test task:\n",
    "* Collect data.\n",
    "* Build a graph of the number of publications by day. Is there a tendency to increase / decrease the number of publications?\n",
    "\n",
    "* Identify the most active users who publish most often.\n",
    "* Identify the most popular publications by the number of comments and “vote”\n",
    "* Is there a correlation between the number of likes and comments of publications?\n",
    "* Is it possible to identify the main features on the basis of which it can be assumed whether the publication will be popular (the number of Vote) or not?\n",
    "* What insights can be gleaned from existing data? How can they be useful for business?\n",
    "\n",
    "*** The result of the work performed will be considered:\n",
    "documentation with comments on the progress of the work;\n",
    "clear visualization of the collected data;\n",
    "presentation of the code (if it was) that was used as part of the work;\n",
    "analysis and conclusions that were made on the basis of the implementation of these tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libs\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import requests\n",
    "import praw\n",
    "from tqdm import tqdm\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the constants\n",
    "# pls use your credentials\n",
    "\n",
    "client_id=\n",
    "client_secret=\n",
    "password=\n",
    "username="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Find_myway_today\n"
     ]
    }
   ],
   "source": [
    "# create connection with credentials \n",
    "reddit = praw.Reddit(client_id=client_id,\n",
    "                     client_secret=client_secret,\n",
    "                     password=password,\n",
    "                     user_agent='android:com.example.myredditapp:v1.2.3 (by /u/kemitche)',\n",
    "                     username=username)\n",
    "\n",
    "print(reddit.user.me()) # check connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the last 2000 records \n",
    "data_get = reddit.subreddit('SnapLenses').new(limit=2000) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in data_:\n",
    "#     print(dir(i))\n",
    "\n",
    "# # we can check the data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create empty lists for selected fields\n",
    "\n",
    "topic = {'title':[], 'id':[], 'author':[], 'author_flair_text':[], 'created':[], 'score':[], \n",
    "         'num_comments':[], 'is_video':[], 'distinguished':[], 'is_original_content':[], 'over_18':[],\\\n",
    "        'stickied':[], 'upvote_ratio':[], }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "999it [16:26,  1.18s/it]\n"
     ]
    }
   ],
   "source": [
    "for i in tqdm(data_get): # Fill the lists with data from subreddit object \n",
    "    \n",
    "    topic['title'].append(i.title)\n",
    "    topic['id'].append(i.id)\n",
    "    topic['author'].append(i.author)\n",
    "    topic['author_flair_text'].append(i.author_flair_text)\n",
    "    topic['created'].append(i.created)\n",
    "    topic['score'].append(i.score)\n",
    "    topic['num_comments'].append(i.num_comments)\n",
    "    topic['is_video'].append(i.is_video)\n",
    "    topic['distinguished'].append(i.distinguished)\n",
    "    topic['is_original_content'].append(i.is_original_content)\n",
    "    topic['over_18'].append(i.over_18)\n",
    "    topic['stickied'].append(i.stickied)\n",
    "    topic['upvote_ratio'].append(i.upvote_ratio)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['title', 'id', 'author', 'author_flair_text', 'created', 'score', 'num_comments', 'is_video', 'distinguished', 'is_original_content', 'over_18', 'stickied', 'upvote_ratio'])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "topic.keys() # check if all needed keys are obtained "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.DataFrame(topic) # convert into DF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 999 entries, 0 to 998\n",
      "Data columns (total 13 columns):\n",
      "title                  999 non-null object\n",
      "id                     999 non-null object\n",
      "author                 989 non-null object\n",
      "author_flair_text      159 non-null object\n",
      "created                999 non-null float64\n",
      "score                  999 non-null int64\n",
      "num_comments           999 non-null int64\n",
      "is_video               999 non-null bool\n",
      "distinguished          33 non-null object\n",
      "is_original_content    999 non-null bool\n",
      "over_18                999 non-null bool\n",
      "stickied               999 non-null bool\n",
      "upvote_ratio           999 non-null float64\n",
      "dtypes: bool(4), float64(2), int64(2), object(5)\n",
      "memory usage: 74.2+ KB\n"
     ]
    }
   ],
   "source": [
    "data.info() # check the data columns type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.fillna(0, inplace=True) # replace None\n",
    "data['created'] = data['created'].apply(datetime.fromtimestamp) #convert into readble date type\n",
    "data['author'] = data['author'].astype(str) # convert autor columns into str type for aggregation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>title</th>\n",
       "      <th>id</th>\n",
       "      <th>author</th>\n",
       "      <th>author_flair_text</th>\n",
       "      <th>created</th>\n",
       "      <th>score</th>\n",
       "      <th>num_comments</th>\n",
       "      <th>is_video</th>\n",
       "      <th>distinguished</th>\n",
       "      <th>is_original_content</th>\n",
       "      <th>over_18</th>\n",
       "      <th>stickied</th>\n",
       "      <th>upvote_ratio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>✨💦Fresh out of the Chromatic Water 💦✨</td>\n",
       "      <td>e9o5u2</td>\n",
       "      <td>Bonnet_noir</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-13 00:21:34</td>\n",
       "      <td>12</td>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Baby yoda</td>\n",
       "      <td>e9ir7d</td>\n",
       "      <td>veggietalepizzaangel</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 14:32:07</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>0.56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[Request] Anyone have this swirl effect lens?</td>\n",
       "      <td>e9cg3p</td>\n",
       "      <td>Gekko_Guy</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 06:15:02</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Alien Power!! (Enjoy)</td>\n",
       "      <td>e9bc40</td>\n",
       "      <td>emiliusvgs</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 04:57:21</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Snapchat lens for Salman Khan (A Bollywood Sta...</td>\n",
       "      <td>e99e0s</td>\n",
       "      <td>timetraveller2090</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 02:37:32</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>0.75</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               title      id  \\\n",
       "0              ✨💦Fresh out of the Chromatic Water 💦✨  e9o5u2   \n",
       "1                                          Baby yoda  e9ir7d   \n",
       "2      [Request] Anyone have this swirl effect lens?  e9cg3p   \n",
       "3                              Alien Power!! (Enjoy)  e9bc40   \n",
       "4  Snapchat lens for Salman Khan (A Bollywood Sta...  e99e0s   \n",
       "\n",
       "                 author author_flair_text             created  score  \\\n",
       "0           Bonnet_noir                 0 2019-12-13 00:21:34     12   \n",
       "1  veggietalepizzaangel                 0 2019-12-12 14:32:07      1   \n",
       "2             Gekko_Guy                 0 2019-12-12 06:15:02      1   \n",
       "3            emiliusvgs                 0 2019-12-12 04:57:21      4   \n",
       "4     timetraveller2090                 0 2019-12-12 02:37:32      2   \n",
       "\n",
       "   num_comments  is_video distinguished  is_original_content  over_18  \\\n",
       "0             1      True             0                False    False   \n",
       "1             1     False             0                False    False   \n",
       "2             0     False             0                False    False   \n",
       "3             1      True             0                False    False   \n",
       "4             0     False             0                False    False   \n",
       "\n",
       "   stickied  upvote_ratio  \n",
       "0     False          1.00  \n",
       "1     False          0.56  \n",
       "2     False          1.00  \n",
       "3     False          1.00  \n",
       "4     False          0.75  "
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head() # see the content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build a graph of the number of publications by day. Is there a tendency to increase / decrease the number of publications?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f2a019250b8>"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the simple graph\n",
    "\n",
    "plt.plot(data.groupby(data.created.dt.day)['id'].count())\n",
    "plt.axhline(data.groupby(data.created.dt.day)['id'].count().sum() / 30, color='red')\n",
    "plt.title('Dinamic of posts per day')\n",
    "plt.xlabel('days')\n",
    "plt.ylabel('number of post per day')\n",
    "plt.legend('mean')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There are several peaks and falls in post publication during month with mean of 34 per day. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We can check it for weekday period?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>title</th>\n",
       "      <th>id</th>\n",
       "      <th>author</th>\n",
       "      <th>author_flair_text</th>\n",
       "      <th>created</th>\n",
       "      <th>score</th>\n",
       "      <th>num_comments</th>\n",
       "      <th>is_video</th>\n",
       "      <th>distinguished</th>\n",
       "      <th>is_original_content</th>\n",
       "      <th>over_18</th>\n",
       "      <th>stickied</th>\n",
       "      <th>upvote_ratio</th>\n",
       "      <th>week_day</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>✨💦Fresh out of the Chromatic Water 💦✨</td>\n",
       "      <td>e9o5u2</td>\n",
       "      <td>Bonnet_noir</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-13 00:21:34</td>\n",
       "      <td>12</td>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1.00</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Baby yoda</td>\n",
       "      <td>e9ir7d</td>\n",
       "      <td>veggietalepizzaangel</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 14:32:07</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>0.56</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[Request] Anyone have this swirl effect lens?</td>\n",
       "      <td>e9cg3p</td>\n",
       "      <td>Gekko_Guy</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 06:15:02</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1.00</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Alien Power!! (Enjoy)</td>\n",
       "      <td>e9bc40</td>\n",
       "      <td>emiliusvgs</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 04:57:21</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>1.00</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Snapchat lens for Salman Khan (A Bollywood Sta...</td>\n",
       "      <td>e99e0s</td>\n",
       "      <td>timetraveller2090</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-12-12 02:37:32</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>0.75</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               title      id  \\\n",
       "0              ✨💦Fresh out of the Chromatic Water 💦✨  e9o5u2   \n",
       "1                                          Baby yoda  e9ir7d   \n",
       "2      [Request] Anyone have this swirl effect lens?  e9cg3p   \n",
       "3                              Alien Power!! (Enjoy)  e9bc40   \n",
       "4  Snapchat lens for Salman Khan (A Bollywood Sta...  e99e0s   \n",
       "\n",
       "                 author author_flair_text             created  score  \\\n",
       "0           Bonnet_noir                 0 2019-12-13 00:21:34     12   \n",
       "1  veggietalepizzaangel                 0 2019-12-12 14:32:07      1   \n",
       "2             Gekko_Guy                 0 2019-12-12 06:15:02      1   \n",
       "3            emiliusvgs                 0 2019-12-12 04:57:21      4   \n",
       "4     timetraveller2090                 0 2019-12-12 02:37:32      2   \n",
       "\n",
       "   num_comments  is_video distinguished  is_original_content  over_18  \\\n",
       "0             1      True             0                False    False   \n",
       "1             1     False             0                False    False   \n",
       "2             0     False             0                False    False   \n",
       "3             1      True             0                False    False   \n",
       "4             0     False             0                False    False   \n",
       "\n",
       "   stickied  upvote_ratio  week_day  \n",
       "0     False          1.00         4  \n",
       "1     False          0.56         3  \n",
       "2     False          1.00         3  \n",
       "3     False          1.00         3  \n",
       "4     False          0.75         3  "
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# iterate over date column to get the week day\n",
    "\n",
    "for i in range(0, len(data)):\n",
    "    data['week_day'][i] = data.created[i].weekday()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'number of post')"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the graph to see week day dynamics  \n",
    "\n",
    "plt.plot(data.groupby('week_day')['id'].count())\n",
    "plt.title('Posts by weekday')\n",
    "plt.xlabel('Week day')\n",
    "plt.ylabel('number of post')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  we see that most active day is friday with more than 170 post a day"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identify the most active users who publish most often."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "author\n",
       "pinkpirate82      32\n",
       "AutoModerator     30\n",
       "modelsbymike3d    23\n",
       "belzenwa          16\n",
       "Vodkool           16\n",
       "Klipko69          15\n",
       "LinkdudeGamer     15\n",
       "ApocTheLegend     14\n",
       "vsnake12          14\n",
       "mypinkyhurts      13\n",
       "Name: id, dtype: int64"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Group data by most popular authors\n",
    "\n",
    "data.groupby(['author'])['id'].count().sort_values(ascending=False)[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### let us the distribution of most popular authors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'number of authors')"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot dist of popular authors\n",
    "\n",
    "sns.distplot(data.groupby(['author'])['id'].count().sort_values(ascending=False)[:100])\n",
    "plt.xlabel('number of authors')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Most of the post were done by limited number of authors (skewed dist to left)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identify the most popular publications by the number of comments and “vote”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>score</th>\n",
       "      <th>num_comments</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>title</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>What filter is this?</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Green Eyes</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anyone know what this filter is?</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fanging Out</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Snap to Unlock!</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  score  num_comments\n",
       "title                                                \n",
       "What filter is this?                  3             3\n",
       "Green Eyes                            3             3\n",
       "Anyone know what this filter is?      2             2\n",
       "Fanging Out                           2             2\n",
       "Snap to Unlock!                       2             2"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Group the score and # comments \n",
    "\n",
    "data.groupby(['title'])[['score', 'num_comments']].count().sort_values(by='score', ascending=False)[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f2a0158e4a8>"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let see the distribution of score \n",
    "\n",
    "\n",
    "sns.distplot(data['score'], norm_hist=True, axlabel='Number of posts')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Limited number of post gets any votes and score. less than 100 is reated at all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Is there a correlation between the number of likes and comments of publications?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Correlation between comments and score of the post')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "corr_ = np.corrcoef(data['num_comments'], data['score'])\n",
    "sns.heatmap(corr_, annot=(corr_), cmap=\"YlGnBu\", xticklabels=2, yticklabels=False)\n",
    "plt.title('Correlation between comments and score of the post')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There is strong correlation beween there variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let us compare one more variable - upvote ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 540x540 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%config InlineBackend.figure_format = 'png'  # to seed the code \n",
    "sns.pairplot(data[['score', 'num_comments', 'upvote_ratio']]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There is not direct relation between score and num_comments.\n",
    "#### It might some other factors that make it more popular in general "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Is it possible to identify the main features on the basis of which it can be assumed whether the publication will be popular (number of votes) or not?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us explore the dist of upvote_ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, '% of post')"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(data.upvote_ratio, vertical=False)\n",
    "plt.title('Distribution of upvote ratio')\n",
    "plt.xlabel('Ratio of post')\n",
    "plt.ylabel('% of post')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We see that just about 12 % of the post are become popular\n",
    "#### So let us find what is most important factors that make post popular among others.\n",
    "#### We assume that 1 is post popular, and 0 than it is not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create new binary column \n",
    "\n",
    "data['popular_post'] = [1 if i == 1 else 0 for i in data['upvote_ratio']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = data.copy() # new copy of the data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv('data_reddit_analysis.csv') # save the data in .csv file "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.drop(['title', 'id'], axis=1, inplace=True)\n",
    "# drop features that can not be transformed into numercal or category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the columns into binary format\n",
    "\n",
    "df['is_video'] = [1 if x == True else 0 for x in df['is_video']]\n",
    "df['is_original_content'] = [1 if x == True else 0 for x in df['is_original_content']]\n",
    "df['over_18'] = [1 if x == True else 0 for x in df['over_18']]\n",
    "df['stickied'] = [1 if x == True else 0 for x in df['stickied']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.drop(['created'], axis=1, inplace=True)\n",
    "df.drop(['author_flair_text', 'distinguished'], axis=1, inplace=True)\n",
    "df.drop(['author'], axis=1, inplace=True)\n",
    "df.drop(['upvote_ratio'], axis=1, inplace=True) # drop the ration (we use it as Target Variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>score</th>\n",
       "      <th>num_comments</th>\n",
       "      <th>is_video</th>\n",
       "      <th>is_original_content</th>\n",
       "      <th>over_18</th>\n",
       "      <th>stickied</th>\n",
       "      <th>week_day</th>\n",
       "      <th>popular_post</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   score  num_comments  is_video  is_original_content  over_18  stickied  \\\n",
       "0     12             1         1                    0        0         0   \n",
       "1      1             1         0                    0        0         0   \n",
       "2      1             0         0                    0        0         0   \n",
       "3      4             1         1                    0        0         0   \n",
       "4      2             0         0                    0        0         0   \n",
       "\n",
       "   week_day  popular_post  \n",
       "0         4             1  \n",
       "1         3             0  \n",
       "2         3             1  \n",
       "3         3             1  \n",
       "4         3             0  "
      ]
     },
     "execution_count": 370,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head() # final look of the data, where Tagret values is 'popular_post'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libs\n",
    "\n",
    "from sklearn.metrics import mean_squared_error, roc_auc_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression, Lasso\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier\n",
    "from sklearn.model_selection import validation_curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:645: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.partial_fit(X, y)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/base.py:467: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  return self.fit(X, y, **fit_params).transform(X)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/stochastic_gradient.py:166: FutureWarning: max_iter and tol parameters have been added in SGDClassifier in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  FutureWarning)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n",
      "/home/volodymyr/anaconda3/lib/python3.7/site-packages/sklearn/pipeline.py:401: DataConversionWarning: Data with input dtype int64 were all converted to float64 by StandardScaler.\n",
      "  Xt = transform.transform(Xt)\n"
     ]
    }
   ],
   "source": [
    "alphas = np.logspace(-2, 0, 20) # range \n",
    "\n",
    "sgd_logit = SGDClassifier(loss='log', n_jobs=-1, random_state=17) #SVD classfier\n",
    "\n",
    "logit_pipe = Pipeline([('scaler', StandardScaler()), ('poly', PolynomialFeatures(degree=2)), \n",
    "                       ('sgd_logit', sgd_logit)]) # Pipline\n",
    "\n",
    "val_train, val_test = validation_curve(logit_pipe, df.drop('popular_post', axis=1), df.popular_post,\n",
    "                                       'sgd_logit__alpha', alphas, cv=5,\n",
    "                                        scoring='roc_auc') # get the data for graph\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_with_err(x, data, **kwargs): # function to draw plot \n",
    "    mu, std = data.mean(1), data.std(1)\n",
    "    \n",
    "    lines = plt.plot(x, mu, '-', **kwargs)\n",
    "    \n",
    "    plt.fill_between(x, mu - std, mu + std, edgecolor='none',\n",
    "                     facecolor=lines[0].get_color(), alpha=0.2)\n",
    "\n",
    "# plots \n",
    "\n",
    "plot_with_err(alphas, val_train, label='training scores')\n",
    "plot_with_err(alphas, val_test, label='validation scores')\n",
    "plt.title('Validation and training curves with diff alphas')\n",
    "plt.xlabel('alphas');\n",
    "plt.ylabel('ROC AUC');\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and validation curves are converged - so we need more data (or more features) to get anything valueable fro business"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Later we can use Logistic regression to get fist insites"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Split data\n",
    "# X_train, X_test, y_train, y_test = train_test_split(df.drop('popular_post', axis=1), df.popular_post, \\\n",
    "#                                                    random_state=11, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lt = LogisticRegression(random_state=11, solver='lbfgs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='warn',\n",
       "          n_jobs=None, penalty='l2', random_state=11, solver='lbfgs',\n",
       "          tol=0.0001, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 361,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lt.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pred = lt.predict_proba(X_test)[:,1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6725802951388888"
      ]
     },
     "execution_count": 368,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# roc_auc_score(y_test, pred)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}