Kaggle digit-recognizer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv('train.csv', sep=',', encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 42000 entries, 0 to 41999\n",
      "Columns: 785 entries, label to pixel783\n",
      "dtypes: int64(785)\n",
      "memory usage: 251.5 MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df['label']\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = \\\n",
    "train_test_split(df, y, test_size=0.33, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Удаляем таргет\n",
    "X_train = X_train.drop(['label'], axis=1)\n",
    "X_test = X_test.drop(['label'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Инициализируем модели:\n",
    "\n",
    "# КНН\n",
    "model = Pipeline([\n",
    "    ('scaler', StandardScaler()),\n",
    "    ('knn', KNeighborsClassifier(n_neighbors=7))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "     steps=[('scaler', StandardScaler(copy=True, with_mean=True, with_std=True)), ('knn', KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=7, p=2,\n",
       "           weights='uniform'))])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#обучение КНН\n",
    "model.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_knn = model.predict_proba(X_test, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_csv('test.csv', sep=',', encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Делаем предсказание для выборки test\n",
    "X_predict = model.predict(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Запишем массив с предсказание в датафрейм\n",
    "df_predict = pd.DataFrame(X_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 28000 entries, 0 to 27999\n",
      "Data columns (total 1 columns):\n",
      "0    28000 non-null int64\n",
      "dtypes: int64(1)\n",
      "memory usage: 218.8 KB\n"
     ]
    }
   ],
   "source": [
    "df_predict.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вызываем из датафрейма столбец типа Series\n",
    "df_pr=df_predict[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_numbers = np.arange(1, len(X_predict)+1) #Сделаем первый столбец с нумерацией по порядку начиная с 1 для ImageId"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num_series = pd.Series(df_numbers) #переводим numpy array в series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num = pd.DataFrame(df_num_series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 28000 entries, 0 to 27999\n",
      "Data columns (total 1 columns):\n",
      "0    28000 non-null int32\n",
      "dtypes: int32(1)\n",
      "memory usage: 109.5 KB\n"
     ]
    }
   ],
   "source": [
    "df_num.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Объединяем таргет и ID в датафрейм\n",
    "df_result=pd.concat([df_num, df_pr], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Правильно называем колонки\n",
    "df_result.columns = ['ImageId', 'Label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Записываем в файл\n",
    "df_result.to_csv('test_predictions.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ЛОГИЧЕСКАЯ РЕГРЕССИЯ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression, LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Логическая регрессия\n",
    "logreg = LogisticRegression(C=100, class_weight=None, dual=False, fit_intercept=True,\n",
    "          intercept_scaling=500, max_iter=100, multi_class='ovr', n_jobs=1,\n",
    "          penalty='l2', random_state=None, solver='liblinear', tol=1e-10,\n",
    "          verbose=0, warm_start=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=100, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=500, max_iter=100, multi_class='ovr', n_jobs=1,\n",
       "          penalty='l2', random_state=None, solver='liblinear', tol=1e-10,\n",
       "          verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#обучение логической регрессии\n",
    "logreg.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_logreg = logreg.predict_proba(X_test, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Делаем предсказание для выборки test\n",
    "X_predict_logreg = logreg.predict(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Запишем массив с предсказание в датафрейм\n",
    "df_predict_logreg = pd.DataFrame(X_predict_logreg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pr_logreg=df_predict_logreg[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Объединяем таргет и ID в датафрейм\n",
    "df_result_logreg=pd.concat([df_num, df_pr_logreg], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Правильно называем колонки\n",
    "df_result_logreg.columns = ['ImageId', 'Label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Записываем в файл\n",
    "df_result_logreg.to_csv('test_predictions_logreg.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Метод дерева принятия решений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Дерево принятия решений\n",
    "tree = DecisionTreeClassifier(max_depth=4, max_features=44)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=4,\n",
       "            max_features=44, max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best')"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#обучение дерева принятия решений\n",
    "tree.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 30 folds for each of 2254 candidates, totalling 67620 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done  34 tasks      | elapsed:   15.5s\n",
      "[Parallel(n_jobs=-1)]: Done 184 tasks      | elapsed:  1.3min\n",
      "[Parallel(n_jobs=-1)]: Done 434 tasks      | elapsed:  2.8min\n",
      "[Parallel(n_jobs=-1)]: Done 784 tasks      | elapsed:  5.3min\n",
      "[Parallel(n_jobs=-1)]: Done 1234 tasks      | elapsed:  8.3min\n",
      "[Parallel(n_jobs=-1)]: Done 1784 tasks      | elapsed: 12.1min\n",
      "[Parallel(n_jobs=-1)]: Done 2434 tasks      | elapsed: 16.6min\n",
      "[Parallel(n_jobs=-1)]: Done 3184 tasks      | elapsed: 21.7min\n",
      "[Parallel(n_jobs=-1)]: Done 4034 tasks      | elapsed: 27.3min\n",
      "[Parallel(n_jobs=-1)]: Done 4984 tasks      | elapsed: 33.9min\n",
      "[Parallel(n_jobs=-1)]: Done 6034 tasks      | elapsed: 41.1min\n",
      "[Parallel(n_jobs=-1)]: Done 7184 tasks      | elapsed: 49.0min\n",
      "[Parallel(n_jobs=-1)]: Done 8434 tasks      | elapsed: 56.6min\n",
      "[Parallel(n_jobs=-1)]: Done 9784 tasks      | elapsed: 64.9min\n",
      "[Parallel(n_jobs=-1)]: Done 11234 tasks      | elapsed: 74.3min\n",
      "[Parallel(n_jobs=-1)]: Done 12784 tasks      | elapsed: 85.0min\n",
      "[Parallel(n_jobs=-1)]: Done 14434 tasks      | elapsed: 96.4min\n",
      "[Parallel(n_jobs=-1)]: Done 16184 tasks      | elapsed: 108.3min\n",
      "[Parallel(n_jobs=-1)]: Done 18034 tasks      | elapsed: 121.1min\n",
      "[Parallel(n_jobs=-1)]: Done 19984 tasks      | elapsed: 133.2min\n",
      "[Parallel(n_jobs=-1)]: Done 22034 tasks      | elapsed: 147.1min\n",
      "[Parallel(n_jobs=-1)]: Done 24184 tasks      | elapsed: 161.7min\n",
      "[Parallel(n_jobs=-1)]: Done 26434 tasks      | elapsed: 177.0min\n",
      "[Parallel(n_jobs=-1)]: Done 28784 tasks      | elapsed: 192.7min\n",
      "[Parallel(n_jobs=-1)]: Done 31234 tasks      | elapsed: 209.2min\n"
     ]
    }
   ],
   "source": [
    "#Расчёт лучших параметров для дерева принятия решений\n",
    "from sklearn.model_selection import GridSearchCV, cross_val_score\n",
    "tree_params = {'max_depth': range(1,50),\n",
    "'max_features': range(4,50)}\n",
    "tree_grid = GridSearchCV(tree, tree_params,cv=30, n_jobs=-1,verbose=True)\n",
    "tree_grid.fit(X_train, y_train)\n",
    "tree_grid.best_params_, tree_grid.best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_tree = tree.predict_proba(X_test, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}