CH2/templates/02_sklearn.cross_validation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sklearn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sklearn.cross_validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "документация: http://scikit-learn.org/stable/modules/cross_validation.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn import cross_validation, datasets\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Разовое разбиение данных на обучение и тест с помощью train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "cross_validation.train_test_split(данные, метки, test_size = размер тестовой выборки)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "train_data, test_data, train_labels, test_labels = cross_validation.train_test_split(iris.data, iris.target, \n",
    "                                                                                     test_size = 0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#убедимся, что тестовая выборка действительно составляет 0.3 от всех данных\n",
    "float(len(test_labels))/len(iris.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Размер обучающей выборки: 105 объектов \n",
      "Размер тестовой выборки: 45 объектов\n"
     ]
    }
   ],
   "source": [
    "print 'Размер обучающей выборки: {} объектов \\nРазмер тестовой выборки: {} объектов'.format(len(train_data),\n",
    "                                                                                            len(test_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Обучающая выборка:\n",
      "[[ 4.6  3.2  1.4  0.2]\n",
      " [ 5.1  3.5  1.4  0.2]\n",
      " [ 5.3  3.7  1.5  0.2]\n",
      " [ 6.4  3.2  5.3  2.3]\n",
      " [ 6.   3.   4.8  1.8]]\n",
      "\n",
      "\n",
      "Тестовая выборка:\n",
      "[[ 6.3  3.3  4.7  1.6]\n",
      " [ 4.5  2.3  1.3  0.3]\n",
      " [ 6.4  2.7  5.3  1.9]\n",
      " [ 4.3  3.   1.1  0.1]\n",
      " [ 6.6  3.   4.4  1.4]]\n"
     ]
    }
   ],
   "source": [
    "print 'Обучающая выборка:\\n', train_data[:5]\n",
    "print '\\n'\n",
    "print 'Тестовая выборка:\\n', test_data[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Метки классов на обучающей выборке:\n",
      "[0 0 0 2 2 2 0 0 2 0 1 1 2 1 1 1 0 2 1 0 0 2 1 0 1 1 0 0 0 0 2 0 2 0 2 2 1\n",
      " 0 1 1 0 0 0 1 0 2 1 2 2 0 2 1 2 1 0 0 0 2 1 1 2 2 1 0 1 0 1 1 1 0 1 1 0 2\n",
      " 1 2 2 0 2 1 0 1 1 2 0 1 1 1 2 2 1 2 0 0 2 1 1 0 0 2 2 0 1 2 2]\n",
      "\n",
      "\n",
      "Метки классов на тестовой выборке:\n",
      "[1 0 2 0 1 0 1 1 2 2 2 2 2 1 2 2 0 1 1 1 2 2 2 0 1 0 2 2 2 2 1 0 0 1 0 1 0\n",
      " 2 0 1 0 2 1 0 2]\n"
     ]
    }
   ],
   "source": [
    "print 'Метки классов на обучающей выборке:\\n', train_labels\n",
    "print '\\n'\n",
    "print 'Метки классов на тестовой выборке:\\n', test_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Стратегии проведения кросс-валидации"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### KFold\n",
    "Разбиваем выборку на N групп, каждая группа 1 раз участвует в тестировании, и N-1 - в обучении.\n",
    "cross_validation.KFold(количество объектов, n_folds = количество наборов)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5 6 7 8 9] [0 1]\n",
      "[0 1 4 5 6 7 8 9] [2 3]\n",
      "[0 1 2 3 6 7 8 9] [4 5]\n",
      "[0 1 2 3 4 5 8 9] [6 7]\n",
      "[0 1 2 3 4 5 6 7] [8 9]\n"
     ]
    }
   ],
   "source": [
    "for train_indices, test_indices in cross_validation.KFold(10, n_folds = 5):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 6 7 8 9] [0 1 3 4 5]\n",
      "[0 1 3 4 5] [2 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# shuffle = True - перемешиваем индексы\n",
    "for train_indices, test_indices in cross_validation.KFold(10, n_folds = 2, shuffle = True):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7 8] [0 2 4 6 9]\n",
      "[0 2 4 6 9] [1 3 5 7 8]\n"
     ]
    }
   ],
   "source": [
    "# random_state = 1 - фиксация генератора для воспроизводимости \n",
    "for train_indices, test_indices in cross_validation.KFold(10, n_folds = 2, shuffle = True, random_state = 1):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### StratifiedKFold\n",
    "Сохраняет соотношение классов в обучающей и тестовой выборках"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "target: [0 0 0 0 0 1 1 1 1 1]\n",
      "[3 4 8 9] [0 1 2 5 6 7]\n",
      "[0 1 2 5 6 7] [3 4 8 9]\n"
     ]
    }
   ],
   "source": [
    "target = np.array([0] * 5 + [1] * 5)\n",
    "print \"target:\", target\n",
    "for train_indices, test_indices in cross_validation.StratifiedKFold(target, n_folds = 2, shuffle = True, random_state = 0):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 0 1 0 1 0 1 0 1]\n",
      "[4 5 6 9] [0 1 2 3 7 8]\n",
      "[0 1 2 3 7 8] [4 5 6 9]\n"
     ]
    }
   ],
   "source": [
    "target = np.array([0, 1] * 5)\n",
    "print target\n",
    "for train_indices, test_indices in cross_validation.StratifiedKFold(target, n_folds = 2,shuffle = True):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ShuffleSplit\n",
    "Позволяет строить случайные перестановки.\n",
    "нет ограничений на то сколько раз объект должен оказаться массиве выборок"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 8 2 5 6 7 1 4] [9 0]\n",
      "[7 2 3 0 4 6 5 8] [9 1]\n",
      "[8 3 9 7 5 0 2 1] [6 4]\n",
      "[6 4 0 2 3 8 9 5] [1 7]\n",
      "[3 0 1 9 4 8 6 5] [7 2]\n",
      "[0 6 3 4 9 2 1 5] [8 7]\n",
      "[6 2 5 4 1 7 8 0] [3 9]\n",
      "[1 0 5 4 8 2 7 6] [9 3]\n",
      "[0 5 6 2 3 9 4 1] [7 8]\n",
      "[4 7 2 1 5 0 3 8] [6 9]\n"
     ]
    }
   ],
   "source": [
    "for train_indices, test_indices in cross_validation.ShuffleSplit(10, n_iter = 10, test_size = 0.2):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### StratifiedShuffleSplit\n",
    "Позволяет строить случайные перестановки с сохранением баланса классов\n",
    "нет ограничений на то сколько раз объект должен оказаться массиве выборок\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 0 0 1 1 1 1 1]\n",
      "[4 9 5 8 2 1 6 3] [0 7]\n",
      "[1 0 9 7 4 3 5 6] [2 8]\n",
      "[0 7 1 4 9 5 6 2] [8 3]\n",
      "[5 1 0 3 6 7 9 4] [8 2]\n"
     ]
    }
   ],
   "source": [
    "target = np.array([0] * 5 + [1] * 5)\n",
    "print target\n",
    "for train_indices, test_indices in cross_validation.StratifiedShuffleSplit(target, n_iter = 4, test_size = 0.2):\n",
    "    print train_indices, test_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leave-One-Out\n",
    "Позволяет оставить каждый объект в тестовой выборке один раз."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9] [0]\n",
      "[0 2 3 4 5 6 7 8 9] [1]\n",
      "[0 1 3 4 5 6 7 8 9] [2]\n",
      "[0 1 2 4 5 6 7 8 9] [3]\n",
      "[0 1 2 3 5 6 7 8 9] [4]\n",
      "[0 1 2 3 4 6 7 8 9] [5]\n",
      "[0 1 2 3 4 5 7 8 9] [6]\n",
      "[0 1 2 3 4 5 6 8 9] [7]\n",
      "[0 1 2 3 4 5 6 7 9] [8]\n",
      "[0 1 2 3 4 5 6 7 8] [9]\n"
     ]
    }
   ],
   "source": [
    "for train_indices, test_index in cross_validation.LeaveOneOut(10):\n",
    "    print train_indices, test_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Больше стратегий проведения кросс-валидации доступно здесь: http://scikit-learn.org/stable/modules/cross_validation.html#cross-validation-iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}