학습노트(전처리, 평가방법, 평가지표).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 기본\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# 경고 뜨지 않게 설정\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# 그래프 설정\n",
    "plt.rcParams['font.family'] = 'Malgun Gothic'\n",
    "# plt.rcParams['font.family'] = 'AppleGothic'\n",
    "plt.rcParams['font.size'] = 16\n",
    "plt.rcParams['figure.figsize'] = 20, 10\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "# 데이터 전처리 알고리즘\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# 학습용과 검증용으로 나누는 함수\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 교차 검증\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.model_selection import StratifiedKFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>sepal length (cm)</th>\n",
       "      <th>sepal width (cm)</th>\n",
       "      <th>petal length (cm)</th>\n",
       "      <th>petal width (cm)</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  \\\n",
       "0                5.1               3.5                1.4               0.2   \n",
       "1                4.9               3.0                1.4               0.2   \n",
       "2                4.7               3.2                1.3               0.2   \n",
       "3                4.6               3.1                1.5               0.2   \n",
       "4                5.0               3.6                1.4               0.2   \n",
       "\n",
       "   target  \n",
       "0  setosa  \n",
       "1  setosa  \n",
       "2  setosa  \n",
       "3  setosa  \n",
       "4  setosa  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris_df = pd.read_csv('data/iris.csv')\n",
    "iris_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>sepal length (cm)</th>\n",
       "      <th>sepal width (cm)</th>\n",
       "      <th>petal length (cm)</th>\n",
       "      <th>petal width (cm)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
       "0                  5.1               3.5                1.4               0.2\n",
       "1                  4.9               3.0                1.4               0.2\n",
       "2                  4.7               3.2                1.3               0.2\n",
       "3                  4.6               3.1                1.5               0.2\n",
       "4                  5.0               3.6                1.4               0.2\n",
       "..                 ...               ...                ...               ...\n",
       "145                6.7               3.0                5.2               2.3\n",
       "146                6.3               2.5                5.0               1.9\n",
       "147                6.5               3.0                5.2               2.0\n",
       "148                6.2               3.4                5.4               2.3\n",
       "149                5.9               3.0                5.1               1.8\n",
       "\n",
       "[150 rows x 4 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0         setosa\n",
       "1         setosa\n",
       "2         setosa\n",
       "3         setosa\n",
       "4         setosa\n",
       "         ...    \n",
       "145    virginica\n",
       "146    virginica\n",
       "147    virginica\n",
       "148    virginica\n",
       "149    virginica\n",
       "Name: target, Length: 150, dtype: object"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 입력과 결과로 나눈다.\n",
    "X = iris_df.drop('target', axis=1)\n",
    "y = iris_df['target']\n",
    "\n",
    "display(X)\n",
    "display(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 문자열 -> 숫자\n",
    "enc1 = LabelEncoder()\n",
    "enc1.fit(y)\n",
    "y = enc1.transform(y)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Label Encoder\n",
    "- 문자 데이터가 저장되어 있는 컬럼의 데이터를 숫자로 변환하는 작업을 한다.\n",
    "- 지정된 컬럼에 저장되어 있는 값들을 확인하고 각 값들에 숫자를 부여해 변환해준다.\n",
    "- 복원도 가능하다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 저장된 값을 이용해 딕셔너리를 생성한다.\n",
    "dict1 = {\n",
    "    'virginica' : 0,\n",
    "    'setosa' : 1,\n",
    "    'versicolor' : 2\n",
    "}\n",
    "\n",
    "# map 함수를 이용해 변환한다.\n",
    "df_map = iris_df['target'].map(dict1)\n",
    "print(df_map)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 문자열 -> 숫자\n",
    "- LableEncoder함수를 사용해서 변환한다.\n",
    "- 먼저 학습을 시킨다.(fit) => encoder1.fit(df[column])\n",
    "- 학습을 토대로 변환(transform) = > encoder1.transform(df[column])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LableEncoder\n",
    "encoder1 = LabelEncoder()\n",
    "# 데이터를 학습한다.\n",
    "encoder1.fit(iris_df['target'])\n",
    "# 학습한 것을 토대로 변환한다.\n",
    "df_enc1 = encoder1.transform(iris_df['target'])\n",
    "\n",
    "df_enc1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  표준화 작업\n",
    "- 학습 데이터의 각 컬럼의 데이터를 비슷한 수준의 범위로 맞추는 작업\n",
    "- 성능을 약간 상승시킬 수 있는 효과를 얻을 수도 있다.\n",
    "- 시각화할 때도 도움이 될 수 있다.\n",
    "- target값을 제외한 모든 컬럼\n",
    "- 먼저 학습을 시킨다.(fit) \n",
    "- 학습을 토대로 변환(transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 입력 데이터에 대한 표준화\n",
    "scaler1 = StandardScaler()\n",
    "scaler1.fit(X)\n",
    "X = scaler1.transform(X)\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 평가 원리\n",
    "- 검증은 학습하지 않은 패턴의 데이터를 통해 예측 결과를 추출하고 진짜 결과와 비교하는 과정\n",
    "- 결과데이터를 가지고 있는 전체 데이터를 학습용과 검증용으로 나눠 학습과 평가를 진행한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 데이터를 나눈다.\n",
    "# 입력데이터와 결과 데이터를 넣어주면 8:2로 분할해서 반환을 해준다.\n",
    "# 전체 데이터의 행을 랜덤하게 섞은 후 테스트와 검증으로 나눈다.\n",
    "# test_size : 검증용 데이터의 비율 (0 ~ 1), 기본 0.2\n",
    "# random_state : 랜덤시드 설정. 시드를 설정하면 계속 같은 패턴으로 \n",
    "# 섞이게 된다.\n",
    "train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=1)\n",
    "\n",
    "print(len(train_X))\n",
    "print(len(test_X))\n",
    "\n",
    "train_X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 학습과 평가를 진행한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# 학습한다.\n",
    "model1 = LogisticRegression()\n",
    "model1.fit(train_X, train_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 학습한 데이터를 통한 검증\n",
    "- train_test_split 나눈 결과중 train_X 로 위에서 학습한 로지스틱 회귀결과를 가져온다.\n",
    "- 예측결과 train_pred와 train_y를 비교해서 accuracy_score를 확인.\n",
    "- train_y로 학습 했기때문에 무조건 성능이 잘 나와야한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# 학습 데이터를 통해 예측 결과를 가져온다.\n",
    "train_pred = model1.predict(train_X)\n",
    "\n",
    "# 평가한다.\n",
    "r1 = accuracy_score(train_y, train_pred)\n",
    "r1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 검증용 데이터(학습 하지 않은 데이터)=test_X,test_y 를 통한 평가\n",
    "- 학습하지 않은 데이터를 통해 예측 결과를 가져온다.\n",
    "- 위에서 학습된 모델을 가지고 새로운 데이터 test_X,test_y 를 사용해 다시 예측을 시도"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_pred = model1.predict(test_X)\n",
    "\n",
    "# 평가한다.\n",
    "r2 = accuracy_score(test_y, test_pred)\n",
    "r2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 교차 검증\n",
    "- 평가의 원리는 학습하지 않은 패턴의 데이터를 통해 결과를 예측하고 진짜 결과와 비교하여 얼마나 유사한지를 알아보는 것이다.\n",
    "- 허나 학습데이터와 검증데이터의 패턴이 바뀌면 성능 평가 결과가 달라질 수 있다.\n",
    "- 대부분의 데이터와 모델은 성능 평가 수치가 크게 달라지지 않는다.\n",
    "- 허나 크게 달라지는 경우도 있을 수 있기 때문에 이러한 평가를 수 차례 해야한다.\n",
    "- 즉 학습과 평과 데이터의 패턴을 바꿔가며 다수의 테스트를 거쳐 그 결과들을 통해 80% 이상의 정확도를 보이면서 정확도 패턴이 일정한 모델을 찾아야 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### cross_val_score(학습모델, X, y, scoring='accuracy', cv=10)\n",
    "- 교차 검증을 실시 한다.\n",
    "- 첫 번째 : 평가해볼 학습 모델\n",
    "- 두 번째 : 입력데이터\n",
    "- 세 번째 : 결과데이터\n",
    "- scoring : 평가 지표.\n",
    "- cv : 교차검증 횟수\n",
    "- 만약 cv를 3으로 줬다면... 데이터가 총 3개의 꾸러미로 나뉜다.\n",
    "- 1회차 : 1+2 - 학습, 3 - 검증\n",
    "- 2회차 : 1+3 - 학습, 2 - 검증\n",
    "- 3회차 : 2+3 - 학습, 1 - 검증"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = iris_df.drop('target', axis=1)\n",
    "y = iris_df['target']\n",
    "\n",
    "# 문자열 -> 숫자\n",
    "enc1 = LabelEncoder()\n",
    "enc1.fit(y)\n",
    "y = enc1.transform(y)\n",
    "\n",
    "# 사용할 학습 모델을 생성한다.\n",
    "model2 = LogisticRegression()\n",
    "\n",
    "#교차검증\n",
    "r1 = cross_val_score(model2, X, y, scoring='accuracy', cv=10)\n",
    "r1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KFold 교차 검증\n",
    "- Fold : 데이터의 꾸러미\n",
    "- K Fold : Fold가 K개 인것\n",
    "- 전체 데이터를 K 개의 묶음으로 나눠서 K 번 교차검을 한다.\n",
    "- 전체 데이터를 랜덤으로 섞을 것인지 아닌지를 결정할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### KFold(n_splits= , shuffle=True, random_state=1)\n",
    "- Fold 생성\n",
    "- n_splits : 폴드의 수. 데이터 꾸러미 개수\n",
    "- shuffle : True를 넣어주면 전체를 랜덤하게 섞고 폴드를 생성한다.\n",
    "- shuffle이 False(기본)라면 처음부터 순서대로 폴드를 생성한다.\n",
    "- random_state : 랜덤 시드 설정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kfold = KFold(n_splits=3, shuffle=True, random_state=1)\n",
    "\n",
    "list(kfold.split(X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### KFold 교차검증으로 cross_val_score의 교차검증 횟수 정한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 교차 검증을 수행한다.\n",
    "model3 = LogisticRegression()\n",
    "\n",
    "r2 = cross_val_score(model3, X, y, scoring='accuracy', cv=kfold)\n",
    "r2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stractified K Fold 교차 검증\n",
    "- KFold 교차 검증은 원본 데이터의 상태에 따라 학습과 검증데이터가 편향될 가능이 있다.\n",
    "- Stractified K Fold 교차 검증은 결과 데이터를 보고 모든 Fold의 결과 데이터 비율이 균등하게 될 수 있도록 보장해준다.\n",
    "- KFold보다 폴드 구성에 시간이 걸릴 수 있어 데이터량이 많으면 KFold를 먼저 해보는 것도 괜찮은 방법"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### KFold, shuffle : False, KFold, shuffle : True, Stractified K Fold 비교"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "kfold1 = KFold(n_splits=3)\n",
    "kfold2 = KFold(n_splits=3, shuffle=True)\n",
    "kfold3 = StratifiedKFold(n_splits=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kfold1 = KFold(n_splits=3)\n",
    "- KFold, shuffle = False : 모든 데이터를 일정하게 나눈다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    50\n",
       "1    50\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0    50\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    50\n",
       "0    50\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1    50\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1    50\n",
       "0    50\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    50\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# KFold, shuffle = False\n",
    "for train_idx, test_idx in kfold1.split(X) :\n",
    "    # 학습용 데이터의 결과 데이터를 추출한다.\n",
    "    y1 = y[train_idx]\n",
    "    # 검증용 데이터의 결과 데이터를 추출한다.\n",
    "    y2 = y[test_idx]\n",
    "    \n",
    "    # Series로 생성한다.\n",
    "    s1 = pd.Series(y1)\n",
    "    s2 = pd.Series(y2)\n",
    "    \n",
    "    display(s1.value_counts())\n",
    "    display(s2.value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kfold2 = KFold(n_splits=3, shuffle=True)\n",
    "- KFold, shuffle= True : 폴드의 데이터를 일정하게 나눈다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    34\n",
       "2    33\n",
       "0    33\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    17\n",
       "0    17\n",
       "1    16\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    39\n",
       "1    32\n",
       "0    29\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0    21\n",
       "1    18\n",
       "2    11\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0    38\n",
       "1    34\n",
       "2    28\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    22\n",
       "1    16\n",
       "0    12\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# KFold, shuffle = True\n",
    "for train_idx, test_idx in kfold2.split(X) :\n",
    "    # 학습용 데이터의 결과 데이터를 추출한다.\n",
    "    y1 = y[train_idx]\n",
    "    # 검증용 데이터의 결과 데이터를 추출한다.\n",
    "    y2 = y[test_idx]\n",
    "    \n",
    "    # Series로 생성한다.\n",
    "    s1 = pd.Series(y1)\n",
    "    s2 = pd.Series(y2)\n",
    "    \n",
    "    display(s1.value_counts())\n",
    "    display(s2.value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kfold3 = StratifiedKFold(n_splits=3)\n",
    "- Stractified K Fold = shuffle=True 와 비슷함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    34\n",
       "1    33\n",
       "0    33\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1    17\n",
       "0    17\n",
       "2    16\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1    34\n",
       "2    33\n",
       "0    33\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    17\n",
       "0    17\n",
       "1    16\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0    34\n",
       "2    33\n",
       "1    33\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2    17\n",
       "1    17\n",
       "0    16\n",
       "dtype: int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Stractified K Fold\n",
    "for train_idx, test_idx in kfold3.split(X, y) :\n",
    "    # 학습용 데이터의 결과 데이터를 추출한다.\n",
    "    y1 = y[train_idx]\n",
    "    # 검증용 데이터의 결과 데이터를 추출한다.\n",
    "    y2 = y[test_idx]\n",
    "    \n",
    "    # Series로 생성한다.\n",
    "    s1 = pd.Series(y1)\n",
    "    s2 = pd.Series(y2)\n",
    "    \n",
    "    display(s1.value_counts())\n",
    "    display(s2.value_counts())"
   ]
  },
  {
   "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": []
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}