실습파일-6/week7_practice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     survived  pclass     sex   age  sibsp  parch     fare embarked   class  \\\n",
      "0           0       3    male  22.0      1      0   7.2500        S   Third   \n",
      "1           1       1  female  38.0      1      0  71.2833        C   First   \n",
      "2           1       3  female  26.0      0      0   7.9250        S   Third   \n",
      "3           1       1  female  35.0      1      0  53.1000        S   First   \n",
      "4           0       3    male  35.0      0      0   8.0500        S   Third   \n",
      "..        ...     ...     ...   ...    ...    ...      ...      ...     ...   \n",
      "886         0       2    male  27.0      0      0  13.0000        S  Second   \n",
      "887         1       1  female  19.0      0      0  30.0000        S   First   \n",
      "888         0       3  female   NaN      1      2  23.4500        S   Third   \n",
      "889         1       1    male  26.0      0      0  30.0000        C   First   \n",
      "890         0       3    male  32.0      0      0   7.7500        Q   Third   \n",
      "\n",
      "       who  adult_male deck  embark_town alive  alone  \n",
      "0      man        True  NaN  Southampton    no  False  \n",
      "1    woman       False    C    Cherbourg   yes  False  \n",
      "2    woman       False  NaN  Southampton   yes   True  \n",
      "3    woman       False    C  Southampton   yes  False  \n",
      "4      man        True  NaN  Southampton    no   True  \n",
      "..     ...         ...  ...          ...   ...    ...  \n",
      "886    man        True  NaN  Southampton    no   True  \n",
      "887  woman       False    B  Southampton   yes   True  \n",
      "888  woman       False  NaN  Southampton    no  False  \n",
      "889    man        True    C    Cherbourg   yes   True  \n",
      "890    man        True  NaN   Queenstown    no   True  \n",
      "\n",
      "[891 rows x 15 columns]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Data Preprocessing (데이터 전처리)\n",
    "import pandas as pd\n",
    "df = pd.read_excel(\"titanic.xlsx\")\n",
    "print(df)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deck\n",
      "NaN    688\n",
      "C       59\n",
      "B       47\n",
      "D       33\n",
      "E       32\n",
      "A       15\n",
      "F       13\n",
      "G        4\n",
      "Name: count, dtype: int64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 결측값 처리하기\n",
    "\n",
    "# value_counts(dropna=False) : 결측값(NaN)을 제외하지 않고, 결측값도 빈도에 포함\n",
    "nan_deck = df['deck'].value_counts(dropna=False) \n",
    "print(nan_deck)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   survived  pclass    sex    age  sibsp  parch   fare  embarked  class  \\\n",
      "0     False   False  False  False  False  False  False     False  False   \n",
      "1     False   False  False  False  False  False  False     False  False   \n",
      "2     False   False  False  False  False  False  False     False  False   \n",
      "3     False   False  False  False  False  False  False     False  False   \n",
      "4     False   False  False  False  False  False  False     False  False   \n",
      "\n",
      "     who  adult_male   deck  embark_town  alive  alone  \n",
      "0  False       False   True        False  False  False  \n",
      "1  False       False  False        False  False  False  \n",
      "2  False       False   True        False  False  False  \n",
      "3  False       False  False        False  False  False  \n",
      "4  False       False   True        False  False  False  \n"
     ]
    }
   ],
   "source": [
    "# df.head()는 데이터프레임의 상위 5개 행을 반환\n",
    "# isnull()은 각 셀에 결측값(NaN)이 있는지 여부를 확인하는 함수로, 결측값이 있는 셀은 True, 없는 셀은 False를 반환\n",
    "print(df.head().isnull())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   survived  pclass   sex   age  sibsp  parch  fare  embarked  class   who  \\\n",
      "0      True    True  True  True   True   True  True      True   True  True   \n",
      "1      True    True  True  True   True   True  True      True   True  True   \n",
      "2      True    True  True  True   True   True  True      True   True  True   \n",
      "3      True    True  True  True   True   True  True      True   True  True   \n",
      "4      True    True  True  True   True   True  True      True   True  True   \n",
      "\n",
      "   adult_male   deck  embark_town  alive  alone  \n",
      "0        True  False         True   True   True  \n",
      "1        True   True         True   True   True  \n",
      "2        True  False         True   True   True  \n",
      "3        True   True         True   True   True  \n",
      "4        True  False         True   True   True  \n"
     ]
    }
   ],
   "source": [
    "# 각 셀이 결측값이 아니라면 True, 결측값이라면 False를 반환\n",
    "print(df.head().notnull())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "survived       0\n",
      "pclass         0\n",
      "sex            0\n",
      "age            0\n",
      "sibsp          0\n",
      "parch          0\n",
      "fare           0\n",
      "embarked       0\n",
      "class          0\n",
      "who            0\n",
      "adult_male     0\n",
      "deck           3\n",
      "embark_town    0\n",
      "alive          0\n",
      "alone          0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# sum(axis=0)은 열 단위로 True의 개수를 셈\n",
    "print(df.head().isnull().sum(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    22.0\n",
      "1    38.0\n",
      "2    26.0\n",
      "3    35.0\n",
      "4    35.0\n",
      "5     NaN\n",
      "6    54.0\n",
      "7     2.0\n",
      "8    27.0\n",
      "9    14.0\n",
      "Name: age, dtype: float64\n",
      "\n",
      "0    22.000000\n",
      "1    38.000000\n",
      "2    26.000000\n",
      "3    35.000000\n",
      "4    35.000000\n",
      "5    29.699118\n",
      "6    54.000000\n",
      "7     2.000000\n",
      "8    27.000000\n",
      "9    14.000000\n",
      "Name: age, dtype: float64\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/jg/4s9vwdvj78b4mywd_ds9z14r0000gn/T/ipykernel_58549/2712848575.py:13: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['age'].fillna(mean_age, inplace=True)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "# titanic.xlsx 파일에서 데이터를 읽어와서 df라는 데이터프레임에 저장\n",
    "df = pd.read_excel(\"titanic.xlsx\")\n",
    "\n",
    "# \"age\" 열에서 상위 10개의 값을 출력\n",
    "print(df['age'].head(10))\n",
    "print()\n",
    "\n",
    "# \"age\" 열의 평균값을 계산, 결측값(NaN)은 제외하고 평균을 계산\n",
    "mean_age = df['age'].mean(axis=0)\n",
    "\n",
    "# fillna(mean_age)는 \"age\" 열에서 결측값(NaN)을 mean_age(평균값)으로 채운다.\n",
    "df['age'].fillna(mean_age, inplace=True)\n",
    "print(df['age'].head(10))\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "825     Queenstown\n",
      "826    Southampton\n",
      "827      Cherbourg\n",
      "828     Queenstown\n",
      "829            NaN\n",
      "Name: embark_town, dtype: object\n",
      "\n",
      "Southampton\n",
      "\n",
      "825     Queenstown\n",
      "826    Southampton\n",
      "827      Cherbourg\n",
      "828     Queenstown\n",
      "829    Southampton\n",
      "Name: embark_town, dtype: object\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/jg/4s9vwdvj78b4mywd_ds9z14r0000gn/T/ipykernel_58549/770258244.py:14: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['embark_town'].fillna(most_freq, inplace=True)\n"
     ]
    }
   ],
   "source": [
    "# \"titanic.xlsx\"라는 새 컬럼을 불러옴\n",
    "df = pd.read_excel(\"titanic.xlsx\")\n",
    "# \"embark_town\" 열에서 825번에서 829번까지의 값을 출력\n",
    "print(df['embark_town'][825:830])\n",
    "print()\n",
    "\n",
    "# \"embark_town\" 열에서 결측값을 제외하고 값의 빈도를 세는 함수\n",
    "# idxmax()는 가장 빈도수가 높은 값(즉, \"embark_town\" 열에서 가장 자주 등장하는 값)을 반환\n",
    "most_freq = df['embark_town'].value_counts(dropna=True).idxmax()   \n",
    "print(most_freq)\n",
    "print()\n",
    "\n",
    "# \"embark_town\" 열의 결측값을 most_freq (가장 자주 등장하는 값)으로 채운다.\n",
    "df['embark_town'].fillna(most_freq, inplace=True)\n",
    "print(df['embark_town'][825:830])\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "825     Queenstown\n",
      "826    Southampton\n",
      "827      Cherbourg\n",
      "828     Queenstown\n",
      "829            NaN\n",
      "Name: embark_town, dtype: object\n",
      "\n",
      "825     Queenstown\n",
      "826    Southampton\n",
      "827      Cherbourg\n",
      "828     Queenstown\n",
      "829     Queenstown\n",
      "Name: embark_town, dtype: object\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/jg/4s9vwdvj78b4mywd_ds9z14r0000gn/T/ipykernel_58549/2003814731.py:7: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['embark_town'].fillna(method='ffill', inplace=True)\n",
      "/var/folders/jg/4s9vwdvj78b4mywd_ds9z14r0000gn/T/ipykernel_58549/2003814731.py:7: FutureWarning: Series.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n",
      "  df['embark_town'].fillna(method='ffill', inplace=True)\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_excel(\"titanic.xlsx\")\n",
    "print(df['embark_town'][825:830])\n",
    "print()\n",
    "\n",
    "# fillna(method='ffill')는 결측값을 직전의 값으로 채우는 방법\n",
    "# 이 방식을 forward fill(전방 채움)이라고 하며, 결측값을 그 앞에 있는 값으로 대체하는 것\n",
    "df['embark_town'].fillna(method='ffill', inplace=True)\n",
    "print(df['embark_town'][825:830])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       HeartDisease    BMI Smoking AlcoholDrinking Stroke  PhysicalHealth  \\\n",
      "0                No  16.60     Yes              No     No             3.0   \n",
      "1                No  20.34      No              No    Yes             0.0   \n",
      "2                No  26.58     Yes              No     No            20.0   \n",
      "3                No  24.21      No              No     No             0.0   \n",
      "4                No  23.71      No              No     No            28.0   \n",
      "...             ...    ...     ...             ...    ...             ...   \n",
      "319790          Yes  27.41     Yes              No     No             7.0   \n",
      "319791           No  29.84     Yes              No     No             0.0   \n",
      "319792           No  24.24      No              No     No             0.0   \n",
      "319793           No  32.81      No              No     No             0.0   \n",
      "319794           No  46.56      No              No     No             0.0   \n",
      "\n",
      "        MentalHealth DiffWalking     Sex  AgeCategory      Race Diabetic  \\\n",
      "0               30.0          No  Female        55-59     White      Yes   \n",
      "1                0.0          No  Female  80 or older     White       No   \n",
      "2               30.0          No    Male        65-69     White      Yes   \n",
      "3                0.0          No  Female        75-79     White       No   \n",
      "4                0.0         Yes  Female        40-44     White       No   \n",
      "...              ...         ...     ...          ...       ...      ...   \n",
      "319790           0.0         Yes    Male        60-64  Hispanic      Yes   \n",
      "319791           0.0          No    Male        35-39  Hispanic       No   \n",
      "319792           0.0          No  Female        45-49  Hispanic       No   \n",
      "319793           0.0          No  Female        25-29  Hispanic       No   \n",
      "319794           0.0          No  Female  80 or older  Hispanic       No   \n",
      "\n",
      "       PhysicalActivity  GenHealth  SleepTime Asthma KidneyDisease SkinCancer  \n",
      "0                   Yes  Very good        5.0    Yes            No        Yes  \n",
      "1                   Yes  Very good        7.0     No            No         No  \n",
      "2                   Yes       Fair        8.0    Yes            No         No  \n",
      "3                    No       Good        6.0     No            No        Yes  \n",
      "4                   Yes  Very good        8.0     No            No         No  \n",
      "...                 ...        ...        ...    ...           ...        ...  \n",
      "319790               No       Fair        6.0    Yes            No         No  \n",
      "319791              Yes  Very good        5.0    Yes            No         No  \n",
      "319792              Yes       Good        6.0     No            No         No  \n",
      "319793               No       Good       12.0     No            No         No  \n",
      "319794              Yes       Good        8.0     No            No         No  \n",
      "\n",
      "[319795 rows x 18 columns]\n",
      "\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 319795 entries, 0 to 319794\n",
      "Data columns (total 18 columns):\n",
      " #   Column            Non-Null Count   Dtype  \n",
      "---  ------            --------------   -----  \n",
      " 0   HeartDisease      319795 non-null  object \n",
      " 1   BMI               319795 non-null  float64\n",
      " 2   Smoking           319795 non-null  object \n",
      " 3   AlcoholDrinking   319795 non-null  object \n",
      " 4   Stroke            319795 non-null  object \n",
      " 5   PhysicalHealth    319795 non-null  float64\n",
      " 6   MentalHealth      319795 non-null  float64\n",
      " 7   DiffWalking       319795 non-null  object \n",
      " 8   Sex               319795 non-null  object \n",
      " 9   AgeCategory       319795 non-null  object \n",
      " 10  Race              319795 non-null  object \n",
      " 11  Diabetic          319795 non-null  object \n",
      " 12  PhysicalActivity  319795 non-null  object \n",
      " 13  GenHealth         319795 non-null  object \n",
      " 14  SleepTime         319795 non-null  float64\n",
      " 15  Asthma            319795 non-null  object \n",
      " 16  KidneyDisease     319795 non-null  object \n",
      " 17  SkinCancer        319795 non-null  object \n",
      "dtypes: float64(4), object(14)\n",
      "memory usage: 43.9+ MB\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "#데이터 불러오기\n",
    "df = pd.read_csv(\"heart_2020_cleaned.csv\")\n",
    "print(df)\n",
    "print()\n",
    "\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq4AAAHmCAYAAACyHAyaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAk00lEQVR4nO3dfXBV9Z348U8SSIJAroASZEwsbmVoI6z4hCi6rMuUcWsVZbTO0F11bWlX1EWLrqwrzlop2tnV1h2U4rpoHxxHx6lVV9FWV1kt4CPi2lnpVkdYkWiFJBQlMcn9/cGPO8RH0CTnfC+v10zGe+/5ED46THxz5txzK4rFYjEAACDnKrNeAAAAdodwBQAgCcIVAIAkCFcAAJIgXAEASIJwBQAgCcIVAIAkDMh6gb7W3d0dGzdujKFDh0ZFRUXW6wAA8AHFYjG2bt0ao0ePjsrKjz+vWvbhunHjxmhoaMh6DQAAPsWGDRviwAMP/NjjZR+uQ4cOjYgd/yHq6uoy3gYAgA9qa2uLhoaGUrd9nLIP152XB9TV1QlXAIAc+7TLOr05CwCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAzIegEAdl9XV1esXbs2Nm/eHMOHD48JEyZEVVVV1msB9AvhCpCIFStWxOLFi6O5ubn0Wn19fcyZMydOOOGEDDcD6B8uFQBIwIoVK2LBggXR0tLS4/WWlpZYsGBBrFixIpvFAPqRcAXIua6urrj++usjIuLwww+PxYsXx4MPPhiLFy+Oww8/PCIirr/++ujq6spyTYA+J1wBcm7NmjXR0tIS48ePj4ULF0ZTU1Pss88+0dTUFAsXLozx48dHS0tLrFmzJutVAfqUcAXIuZ1Beu6550ZnZ2fcfffd8aMf/Sjuvvvu6OzsjHPOOafHHEC58uYsgETcf//9cemll/a4JGDJkiUxZcqUDLcC6D/OuALk3GGHHRYREf/5n/8ZdXV1MW/evLjnnnti3rx5UVdXF0888USPOYByJVwBcu7LX/5y6fHYsWNjzJgxMWjQoBgzZkyMHTv2I+cAypFLBQBy7oEHHig9XrNmTaxevbr0vKampsfcGWec0a+7AfQnZ1wBcm7jxo0REXHppZfGsGHDehwbPnx4zJs3r8ccQLlyxhUg50aPHh0REcViMX7+859/6CNfH3zwwR5zAOXKGVeAnDv11FOjqqoqbr311ujs7OxxrLOzM/793/89qqqq4tRTT81oQ4D+4YwrQM5VV1fHGWecEXfeeWecdNJJ0d3dXTpWWVkZ3d3dcdZZZ0V1dXWGWwL0PWdcARKw844Bu0brrs/dUQDYGwhXgJzr6uqKm266KY499thYvnx5zJkzJ0477bSYM2dOLF++PI499ti4+eabe3wwAUA5Eq4AObd27drYtGlTzJo1KwYOHBhf/OIX49BDD40vfvGLMXDgwJg1a1a8+eabsXbt2qxXBehTrnEFyLnNmzdHxI7bXV199dXR3NxcOlZfXx/f/OY3e8wBlCvhCpBzw4cPj4iIhQsXfuhYc3Nz6fWdcwDlyqUCADnX1NQUFRUVERFRKBRi3rx5cc8998S8efOiUChERERFRUU0NTVluSZAnxOuADn34osvRrFYjIgddw8YM2ZMDBo0KMaMGVO6m0CxWIwXX3wxyzUB+pxLBQBy7pFHHomIiL/8y7+M559/PubMmVM6dsABB8RJJ50UDz30UDzyyCNx1FFHZbUmQJ8TrgA5995770VExPHHHx/f/e53P/SRr6tWrYqHHnqoNAdQroQrQM6NHz8+nnzyyfi3f/u3mDRpUkycOLF0rLu7O2699dbSHEA5c40rQM6ddtppUVlZGb///e/jiiuuiJdffjnefffdePnll+OKK66IV199NSorK+O0007LelWAPuWMK0DOVVdXx5lnnhl33nlnrF69OlauXFk6Vlm54/zDmWeeGdXV1VmtCNAvhCtAAr7zne9ERMRdd931oWNnnXVW6ThAOaso7rzHSplqa2uLQqEQra2tUVdXl/U6AJ9LR0dH/PKXv4yNGzfG6NGj49RTT3WmFUje7vaaM64ACamuro4zzjgj6zUAMuHNWQAAJEG4AgCQBOEKAEASXOMKkJCurq4PfXJWVVVV1msB9AvhCpCIFStWxE033RSbNm0qvTZq1Kg4//zz44QTTshwM4D+IVwBErBixYq46qqr4phjjomvf/3rUVNTE+3t7fH000/HVVddFf/0T/8kXoGy5z6uADnX1dUVs2bNKv0s++AZ10KhEG1tbfGzn/3MZQNAkna317w5CyDn1q5dG5s2bYp169bFwQcfHIsXL44HH3wwFi9eHAcffHCsW7cu3nzzzVi7dm3WqwL0KeEKkHN/+MMfIiLi6KOPjmuuuSaamppin332iaamprjmmmvi6KOP7jEHUK6EK0DOtbS0RETE8ccfH5WVPX9sV1ZWxpQpU3rMAZQr4QqQc/vuu29ERPzXf/1XdHd39zjW3d0dTz75ZI85gHLlrgIAObfffvtFRMTq1avjiiuuiKOPPrrHXQVWr17dYw6gXAlXgJybMGFCjBo1KiorK2PVqlWxcuXK0rGKiooYPXp0FIvFmDBhQoZbAvQ9lwoA5FxVVVVMnTo1Nm7c+JHHN27cGH/2Z3/mVlhA2ROuADnX1dUVy5cvj4iID956e+fz5cuXR1dXV7/vBtCfhCtAzq1Zs6Z0x4CBAwf2OLbzeUtLS6xZs6afNwPoX65xBci5559/vvT4iCOOiEmTJkVtbW1s3749Vq9eHatWrSrNHXHEEVmtCdDnhCtAzjU3N0dExP777x+vvfZaKVQjIurr62P//fePt99+uzQHUK5cKgCQiLfffvsjP/L17bffzno1gH4hXAFybuTIkaXHH/fmrA/OAZQjlwoA5FyhUCg9fu6553pcKlBdXf2RcwDlyBlXgJwbPnx46fH777/f41hHR8dHzgGUI+EKkHO7fpRrZWXPH9u7PveRr0C5E64AOdfU1BRVVVUxePDg2H///Xsc23///WPw4MFRVVUVTU1NGW0I0D9c4wqQcy+//HJ0dXXFu+++G+PHj48pU6ZEe3t71NTUxBtvvBGrV6+OYrEYL7/8ckycODHrdQH6jHAFyLnNmzdHRMTpp58e9957b483Z1VVVcXpp58e99xzT2kOoFwJV4Cc2/mmq3vuuScmTZoUNTU1sXXr1hg6dGi0t7fHPffc02MOoFwJV4Cc23mN64ABA+KZZ56J7u7u0rHKysqoqamJzs5O17gCZc+bswBybuc1ru3t7T2iNSKiu7s72tvbo6urK15++eWMNgToH8IVIOfeeuutXp0DSJVLBQBybtczqZMmTYoDDzwwOjo6orq6Ov7v//4vVq9eXZqbPn16VmsC9DnhCpBzf/jDHyIioqamJl577bVSqEZEjBw5MmpqaqK9vb00B1CuhCtAzrW3t5f++cHLAXZ9vnMOoFy5xhUg58aOHdurcwCpcsYVIOeGDh3a4/l+++0X1dXV0dHR0ePygA/OAZQb4QqQc//7v//b4/nHXcv6wTmAcuNSAYCce/XVV3t1DiBVwhUg5wYNGlR6XF9f3+PYrs93nQMoRy4VAMi5ioqK0uODDjoopkyZEu3t7VFTUxMbNmyI5ubmD80BlCPhCpBzu55Jffrpp+Ppp5/+1DmAcuRSAYCca2ho6NU5gFQJV4Cc++Y3v9mrcwCpEq4AOffKK6+UHg8YMCAmTpwY06ZNi4kTJ8aAAQM+cg6gHAlXgJxbs2ZNREQ0NTVFZ2dnvPDCC/HrX/86Xnjhhejs7IympqYecwDlSrgCJOK8886Lhx56KGbMmBFHHnlkzJgxIx566KH4m7/5m6xXA+gX7ioAkHOHHXZY/PSnP41ly5bFj370o5g7d27pWHd3d9x2222lOYByJlwBcu6www6LfffdN1566aW4/PLLo7a2NrZu3RpDhw6N7du3x0svvRT77ruvcAXKnnAFyLmqqqq45JJLYsGCBR97D9dLLrkkqqqq+nkzgP6V6TWuXV1dceWVV8aYMWNi0KBB8Sd/8ifxve99L4rFYmmmWCzGggUL4oADDohBgwbFtGnT4ne/+12GWwP0v4cffvhzHQcoB5mecb3uuuvi5ptvjttvvz2ampri2WefjXPPPTcKhUJcdNFFERHxgx/8IG688ca4/fbbY8yYMXHllVfG9OnT47e//W3U1tZmuT5Av3jvvffiqaeeioiIo446KhobG6OjoyOqq6tj/fr18cwzz8RTTz0V7733nk/PAspaRXHX05v97OSTT476+vq49dZbS6/NnDkzBg0aFD/72c+iWCzG6NGj47vf/W7MmzcvIiJaW1ujvr4+brvttjjrrLM+9D3b29ujvb299LytrS0aGhqitbU16urq+v5fCqCXXX/99XHffffFsGHDoqamJjZt2lQ6NmrUqGhvb48tW7bEKaecEpdcckmGmwJ8Nm1tbVEoFD611zK9VODYY4+NRx99NNatWxcRES+++GI8+eSTcdJJJ0VExGuvvRabNm2KadOmlX5NoVCISZMmxcqVKz/yey5atCgKhULpy0cgAqnb+cECW7Zsic2bN/c4tnnz5tiyZUuPOYBylemlApdffnm0tbXFuHHjoqqqKrq6umLhwoUxa9asiIjSWYX6+voev66+vr7HGYddzZ8/v8cZh51nXAFSNXjw4NLjjo6OHsd2fb7rHEA5yjRc77rrrvj5z38ed9xxRzQ1NcWaNWti7ty5MXr06Dj77LM/0/esqamJmpqaXt4UIDuHH354PP/887s1B1DOMg3XSy+9NC6//PLStarjx4+P119/PRYtWhRnn312jBo1KiIimpub44ADDij9uubmZvcrBPYa27Zt69U5gFRleo3ru+++G5WVPVeoqqqK7u7uiIgYM2ZMjBo1Kh599NHS8ba2tli9enVMnjy5X3cFyMruXrvqGleg3GV6xvVrX/taLFy4MBobG6OpqSleeOGFuP7660ufu11RURFz586Na665Jg455JDS7bBGjx4dM2bMyHJ1gH7zzjvvRETEgAEDoq6urscbtEaMGBGtra3R2dlZmgMoV5mG67/+67/GlVdeGeeff3689dZbMXr06Pj2t78dCxYsKM1cdtllsW3btpg9e3a0tLTElClTYvny5e7hCuw1KioqIiKis7PzQ3cV2DVWd84BlKtM7+PaH3b3vmAAeXX11VfHY4899qlzJ554Yo+/+AOkIon7uALw6aZOndqrcwCpEq4AOffwww/36hxAqoQrQM698cYbvToHkCrhCpBzQ4YM6dU5gFQJV4Ccmz59eq/OAaRKuALk3NatW3t1DiBVwhUg55555plenQNIVaYfQADAp2tubi49rquri/333z86Ojqiuro63n777Whra/vQHEA5Eq4AOdfR0VF6PGjQoPj9739fel5fX18K113nAMqRSwUAcq6mpqb0eMuWLT2O7fp81zmAciRcAXKuvr6+9PiDZ1V3fb7rHEA5Eq4AOXfGGWf06hxAqoQrQM4Vi8VenQNIlXAFyLm77767V+cAUiVcAXJu/fr1vToHkCq3wwLIuZaWltLjI488Mo477riora2N7du3x1NPPRXPPvvsh+YAypFwBci57u7u0uOKiop44YUXYuvWrTF06NCoqKj4yDmAciRcAXKuoqKi9MarT/pY110jFqAcucYVIOd29/6s7uMKlDvhCpBz3/rWt3p1DiBVwhUg51588cVenQNIlXAFyDm3wwLYQbgC5NzGjRt7dQ4gVcIVIOc6Ojp6dQ4gVcIVIOeqq6t7dQ4gVcIVIOfGjx/fq3MAqRKuADn3/PPP9+ocQKqEK0DObdu2rVfnAFIlXAFybp999unVOYBUCVeAnBs8eHCvzgGkSrgC5Nzbb7/dq3MAqRKuADnX3d3dq3MAqRKuADknXAF2EK4AOdfV1dWrcwCpEq4AACRBuALknNthAewgXAFy7uCDD+7VOYBUCVeAnFu/fn2vzgGkSrgC5FxnZ2evzgGkSrgC5JxrXAF2EK4AOed2WAA7CFeAnNu2bVuvzgGkSrgC5FyxWOzVOYBUCVeAnKus3L0f1bs7B5AqP+UAcs6bswB2EK4AOdfd3d2rcwCpEq4AOec+rgA7CFeAnBOuADsIV4CcGzJkSK/OAaRKuALk3DvvvNOrcwCpEq4AACRBuAIAkAThCpBzVVVVvToHkCrhCpBzXV1dvToHkCrhCgBAEoQrAABJEK4AOVdZuXs/qnd3DiBVfsoB5NzAgQN7dQ4gVcIVIOcqKip6dQ4gVcIVIOfcDgtgB+EKkHPbtm3r1TmAVAlXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBcs7tsAB2EK4AOecjXwF28FMOIOc6Ozt7dQ4gVcIVIOeKxWKvzgGkSrgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkIfNwfeONN+Ib3/hGjBgxIgYNGhTjx4+PZ599tnS8WCzGggUL4oADDohBgwbFtGnT4ne/+12GGwMAkIVMw3XLli1x3HHHxcCBA+Ohhx6K3/72t/Ev//IvMWzYsNLMD37wg7jxxhtjyZIlsXr16hg8eHBMnz49tm/fnuHmAAD0twFZ/ubXXXddNDQ0xLJly0qvjRkzpvS4WCzGD3/4w/jHf/zHOPXUUyMi4ic/+UnU19fHvffeG2eddVa/7wwAQDYyPeN63333xZFHHhlnnHFGjBw5MiZOnBi33HJL6fhrr70WmzZtimnTppVeKxQKMWnSpFi5cuVHfs/29vZoa2vr8QUAQPoyDddXX301br755jjkkEPi4Ycfjr/927+Niy66KG6//faIiNi0aVNERNTX1/f4dfX19aVjH7Ro0aIoFAqlr4aGhr79lwAAoF9kGq7d3d1x+OGHx/e///2YOHFizJ49O771rW/FkiVLPvP3nD9/frS2tpa+NmzY0IsbAwCQlUzD9YADDogvf/nLPV770pe+FOvXr4+IiFGjRkVERHNzc4+Z5ubm0rEPqqmpibq6uh5fAACkL9NwPe644+KVV17p8dq6devioIMOiogdb9QaNWpUPProo6XjbW1tsXr16pg8eXK/7goAQLYyvavAxRdfHMcee2x8//vfjzPPPDOefvrpWLp0aSxdujQiIioqKmLu3LlxzTXXxCGHHBJjxoyJK6+8MkaPHh0zZszIcnUAAPpZpuF61FFHxS9+8YuYP39+XH311TFmzJj44Q9/GLNmzSrNXHbZZbFt27aYPXt2tLS0xJQpU2L58uVRW1ub4eYAAPS3imKxWMx6ib7U1tYWhUIhWltbXe8KJGnq1Km7Pfv444/32R4AfWV3ey3zj3wFAIDdIVwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEjCgD0Zvu+++3Zr7pRTTvlMywAAwMfZo3CdMWPGp85UVFREV1fXZ90HAAA+0h6Fa3d3d1/tAQAAn8g1rgAAJGGPzriuWLFit+ZOOOGEz7QMAAB8nD0K16lTp0ZFRUVERBSLxY+ccY0rAAB9YY/CddiwYTF06NA455xz4q/+6q9iv/3266u9AACghz26xvXNN9+M6667LlauXBnjx4+P8847L37zm99EXV1dFAqF0hcAAPS2PQrX6urq+PrXvx4PP/xw/M///E9MmDAhLrjggmhoaIgrrrgiOjs7+2pPAAD2cp/5rgKNjY2xYMGC+PWvfx1jx46Na6+9Ntra2npzNwAAKPlM4dre3h533HFHTJs2LQ499NDYb7/94j/+4z9i+PDhvb0fAABExB6+Oevpp5+OZcuWxZ133hlf+MIX4txzz4277rpLsAIA0Of2KFyPOeaYaGxsjIsuuiiOOOKIiIh48sknPzR3yimn9M52AADw/+1RuEZErF+/Pr73ve997HH3cQUAoC/sUbh2d3f31R4AAPCJ9viMa0TEO++8EyNGjIiIiA0bNsQtt9wS27dvj6997Wtx/PHH9+qCAAAQsYd3FXjppZfiC1/4QowcOTLGjRsXa9asiaOOOipuuOGG+PGPfxx//ud/Hvfee28frQoAwN5sj8L1sssui/Hjx8eKFSti6tSpcfLJJ8dXv/rVaG1tjS1btsS3v/3tuPbaa/tqVwAA9mJ7dKnAM888E4899lhMmDAh/vRP/zSWLl0a559/flRW7ujfCy+8MI455pg+WRQAgL3bHp1x3bx5c4waNSoiIoYMGRKDBw+OYcOGlY4PGzYstm7d2rsbAgBAfIZPzqqoqPjE5wAA0Bf2+K4C55xzTtTU1ERExPbt2+M73/lODB48OCJ2fBQsAAD0hT0K17PPPrvH82984xsfmvnrv/7rz7cRAAB8hD0K12XLlvXVHgAA8In2+BpXAADIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQIVwAAkiBcAQBIgnAFACAJwhUAgCQMyHoB4PPbvn17rF+/Pus1yIF169ZlvQJ9pLGxMWpra7NeAzIlXKEMrF+/PmbPnp31GuSAPwfla+nSpTF27Nis14BMCVcoA42NjbF06dKs16CP7EmM+nNQvhobG7NeATInXKEM1NbWOhNDRIQ/B0BZ8+YsgJx7/PHHe3UOIFXCFSABnxalohXYGwhXgER8XJyKVmBvIVwBEvL444+X3oC1dOlS0QrsVYQrAABJEK4AACQhN+F67bXXRkVFRcydO7f02vbt22POnDkxYsSIGDJkSMycOTOam5uzWxIAgMzkIlyfeeaZ+PGPfxwTJkzo8frFF18c999/f9x9993xxBNPxMaNG+P000/PaEsAALKUebj+8Y9/jFmzZsUtt9wSw4YNK73e2toat956a1x//fVx4oknxhFHHBHLli2L3/zmN7Fq1aqP/X7t7e3R1tbW4wsAgPRlHq5z5syJr371qzFt2rQerz/33HPx/vvv93h93Lhx0djYGCtXrvzY77do0aIoFAqlr4aGhj7bHQCA/pNpuN55553x/PPPx6JFiz50bNOmTVFdXR377rtvj9fr6+tj06ZNH/s958+fH62traWvDRs29PbaAABkYEBWv/GGDRvi7/7u7+JXv/pV1NbW9tr3rampiZqaml77fgAA5ENmZ1yfe+65eOutt+Lwww+PAQMGxIABA+KJJ56IG2+8MQYMGBD19fXR0dERLS0tPX5dc3NzjBo1KpulAQDITGZnXP/iL/4iXnrppR6vnXvuuTFu3Lj4+7//+2hoaIiBAwfGo48+GjNnzoyIiFdeeSXWr18fkydPzmJlAAAylFm4Dh06NA499NAerw0ePDhGjBhRev28886LSy65JIYPHx51dXVx4YUXxuTJk+OYY47JYmUAADKUWbjujhtuuCEqKytj5syZ0d7eHtOnT4+bbrop67UAAMhArsL18ccf7/G8trY2Fi9eHIsXL85mIQAAciPz+7gCAMDuEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkAThCgBAEoQrAABJEK4AACRBuAIAkIQBWS9A32lubo7W1tas1wB62euvv97jn0B5KRQKUV9fn/UauVRRLBaLWS/Rl9ra2qJQKERra2vU1dVlvU6/aW5ujm/81V/H+x3tWa8CAOyBgdU18bOf/mSvitfd7TVnXMtUa2trvN/RHu8d/GfRXVvIeh0AYDdUbm+NePWJaG1t3avCdXcJ1zLXXVuI7sH7Zb0GAMDn5s1ZAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRCuAAAkQbgCAJAE4QoAQBKEKwAASRiQ9QL0rcr3WrJeAQDYTf6//cmEa5kb9NqKrFcAAOgVwrXMvTfmhOgetG/WawAAu6HyvRYnnT6BcC1z3YP2je7B+2W9BgDA5+bNWQAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJGFA1gvQtyq3t2a9AgCwm/x/+5MJ1zJVKBRiYHVNxKtPZL0KALAHBlbXRKFQyHqNXBKuZaq+vj5+9tOfRGurv7lBuXn99ddj4cKFccUVV8RBBx2U9TpALysUClFfX5/1GrkkXMtYfX29P/hQxg466KAYO3Zs1msA9BtvzgIAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJGQarosWLYqjjjoqhg4dGiNHjowZM2bEK6+80mNm+/btMWfOnBgxYkQMGTIkZs6cGc3NzRltDABAVjIN1yeeeCLmzJkTq1atil/96lfx/vvvx1e+8pXYtm1baebiiy+O+++/P+6+++544oknYuPGjXH66adnuDUAAFkYkOVvvnz58h7Pb7vtthg5cmQ899xzccIJJ0Rra2vceuutcccdd8SJJ54YERHLli2LL33pS7Fq1ao45phjslgbAIAM5Ooa19bW1oiIGD58eEREPPfcc/H+++/HtGnTSjPjxo2LxsbGWLly5Ud+j/b29mhra+vxBQBA+nITrt3d3TF37tw47rjj4tBDD42IiE2bNkV1dXXsu+++PWbr6+tj06ZNH/l9Fi1aFIVCofTV0NDQ16sDANAPchOuc+bMif/+7/+OO++883N9n/nz50dra2vpa8OGDb20IQAAWcr0GtedLrjggnjggQdixYoVceCBB5ZeHzVqVHR0dERLS0uPs67Nzc0xatSoj/xeNTU1UVNT09crAwDQzzI941osFuOCCy6IX/ziF/HYY4/FmDFjehw/4ogjYuDAgfHoo4+WXnvllVdi/fr1MXny5P5eFwCADGV6xnXOnDlxxx13xC9/+csYOnRo6brVQqEQgwYNikKhEOedd15ccsklMXz48Kirq4sLL7wwJk+e7I4CAAB7mUzD9eabb46IiKlTp/Z4fdmyZXHOOedERMQNN9wQlZWVMXPmzGhvb4/p06fHTTfd1M+bAgCQtUzDtVgsfupMbW1tLF68OBYvXtwPGwEAkFe5uasAAAB8EuEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AiRk7dq1MXv27IiImD17dqxduzbjjQD6z4CsFwBg90ydOvVDr1100UUREfH444/37zIAGXDGFSABHxWte3IcoBw44wplYPv27bF+/fqs16CPrFu3brfmHnjggRg7dmwfb0NWGhsbo7a2Nus1IFPCFcrA+vXrS9c9svf653/+56xXoA8tXbrUX0zY6wlXKAONjY2xdOnSrNegj+zJX0r8OShfjY2NWa8AmROuUAZqa2udidmLfOUrX4kzzzwz7rrrrnjkkUd6HPPnAChnwhUgITfeeGNMmDAhIiL+4R/+IU4++eTSnQUAyp1wBUjIzkg98cQT47HHHst4G4D+5XZYAAkSrcDeSLgC5NzRRx/dq3MAqRKuADm3YMGCXp0DSJVwBci5IUOGxLhx4z5xZty4cTFkyJB+2gggG8IVIAFLliz52HgdN25cLFmypJ83Auh/7ioAkIglS5bEH//4x1i0aFFs3LgxRo8eHfPnz3emFdhrVBSLxWLWS/Sltra2KBQK0draGnV1dVmvAwDAB+xur7lUAACAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAhXAACSIFwBAEiCcAUAIAnCFQCAJAzIeoG+ViwWIyKira0t400AAPgoOzttZ7d9nLIP161bt0ZERENDQ8abAADwSbZu3RqFQuFjj1cUPy1tE9fd3R0bN26MoUOHRkVFRdbrAHxubW1t0dDQEBs2bIi6urqs1wH43IrFYmzdujVGjx4dlZUffyVr2YcrQLlpa2uLQqEQra2twhXYq3hzFgAASRCuAAAkQbgCJKampiauuuqqqKmpyXoVgH7lGlcAAJLgjCsAAEkQrgAAJEG4AgCQBOEKAEAShCsAAEkQrgAAJEG4AgCQBOEKAEAS/h/s/2bAIBa2WAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#BMI 칼럼의 박스플롯 시각화를 통한 이상치 확인\n",
    "\n",
    "# 그래프의 크기를 설정\n",
    "plt.figure(figsize=(8, 6))\n",
    "# seaborn 라이브러리를 사용해 박스플롯을 생성하는 함수\n",
    "# 박스플롯에서 BMI 칼럼의 값을 y축에 표시\n",
    "# data=df: df 데이터프레임에서 데이터를 가져옴.\n",
    "sns.boxplot(y = 'BMI', data = df)\n",
    "\n",
    "# 그래프 그리기\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#BMI 칼럼에서 이상치(outliers)를 제거하는 과정\n",
    "\n",
    "# 1사분위수(Q1)를 계산, 이는 BMI 값 중에서 하위 25%에 해당하는 값을 의미\n",
    "Q1 = df['BMI'].quantile(0.25)\n",
    "# 3사분위수(Q3)를 계산, 이는 BMI 값 중 상위 25%에 해당하는 값을 의미\n",
    "Q3 = df['BMI'].quantile(0.75)\n",
    "\n",
    "# IQR(Interquartile Range, 사분위 범위)은 Q3에서 Q1을 뺀 값으로, 중간 50% 데이터의 범위를 나타낸다.\n",
    "# 이 값은 이상치를 탐지할 때 사용\n",
    "IQR = Q3 - Q1\n",
    "\n",
    "#  IQR의 1.5배를 의미하며, 일반적으로 이상치를 판단하는 기준으로 사용\n",
    "rev_range = 1.5\n",
    "\n",
    "# (df['BMI'] >= Q1 - rev_range * IQR)는 BMI 값이 Q1에서 1.5 * IQR 이하로 벗어나지 않도록 필터링\n",
    "# (df['BMI'] <= Q3 + rev_range * IQR)는 BMI 값이 Q3에서 1.5 * IQR 이상 벗어나지 않도록 필터링\n",
    "# 두 조건은 AND 연산자(&)로 연결되어 이 범위 내에 있는 값들만 정상 범위로 간주\n",
    "filter = (df['BMI'] >= Q1 - rev_range*IQR) & (df['BMI'] <= Q3 + rev_range*IQR)\n",
    "\n",
    "# 필터 조건을 만족하는 행들만 선택하여 새로운 데이터프레임 df_rmv에 저장\n",
    "df_rmv = df.loc[filter]\n",
    "\n",
    "#BMI 칼럼의 박스플롯 시각화를 통해 이상치가 잘 제거 되었는지 확인\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.boxplot(y = 'BMI', data = df_rmv)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    horsepower hp_bin\n",
      "0        130.0   보통출력\n",
      "1        165.0   보통출력\n",
      "2        150.0   보통출력\n",
      "3        150.0   보통출력\n",
      "4        140.0   보통출력\n",
      "5        198.0   보통출력\n",
      "6        220.0    고출력\n",
      "7        215.0    고출력\n",
      "8        225.0    고출력\n",
      "9        190.0   보통출력\n",
      "10       170.0   보통출력\n",
      "11       160.0   보통출력\n",
      "12       150.0   보통출력\n",
      "13       225.0    고출력\n",
      "14        95.0    저출력\n"
     ]
    }
   ],
   "source": [
    "# 자동차 연비 데이터(mpg.csv)에서 'horsepower' 값을 기반으로 출력을 범주형(bin)으로 나누는 작업을 수행\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "df = pd.read_csv(\"mpg.csv\")\n",
    "\n",
    "#  'horsepower' 열에서 결측값(NaN)을 가진 행을 삭제\n",
    "df.dropna(subset=['horsepower'], axis=0, inplace=True)\n",
    "\n",
    "# 자동차의 마력(horsepower)을 범주화하기 위해 사용할 **레이블(labels)**을 정의\n",
    "bin_names = ['저출력', '보통출력', '고출력']\n",
    "\n",
    "# 'horsepower' 값을 pd.cut() 함수를 사용해 범주형(bin) 데이터로 나눈다.\n",
    "# 0에서 100까지는 저출력, 101에서 200까지는 보통출력, 201에서 1000까지는 고출력으로 분류\n",
    "# labels=bin_names: 위에서 정의한 레이블을 각 구간에 할당\n",
    "# include_lowest=True: 첫 번째 구간(0-100)에 속하는 최소값을 포함\n",
    "df['hp_bin'] = pd.cut(x=df['horsepower'], bins=[0, 100, 200, 1000],\n",
    "                            labels=bin_names, include_lowest=True)\n",
    "\n",
    "# 데이터프레임에서 **'horsepower'**와 새로 만든 'hp_bin' 열만 선택하여 출력(15줄만)\n",
    "print(df[['horsepower', 'hp_bin']].head(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      저출력   보통출력    고출력\n",
      "0   False   True  False\n",
      "1   False   True  False\n",
      "2   False   True  False\n",
      "3   False   True  False\n",
      "4   False   True  False\n",
      "5   False   True  False\n",
      "6   False  False   True\n",
      "7   False  False   True\n",
      "8   False  False   True\n",
      "9   False   True  False\n",
      "10  False   True  False\n",
      "11  False   True  False\n",
      "12  False   True  False\n",
      "13  False  False   True\n",
      "14   True  False  False\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 'horsepower' 데이터를 범주형(bin)으로 나누고, 이 범주 데이터를 더미 변수(dummy variables)로 변환하는 작업\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('mpg.csv')\n",
    "# 결측치 제거\n",
    "df.dropna(subset=['horsepower'], axis=0, inplace=True)\n",
    "\n",
    "# 범주 레이블(labels) 정의\n",
    "bin_names = ['저출력', '보통출력', '고출력']\n",
    "\n",
    "#  'horsepower' 열의 값을 범주형 데이터로 나눔.\n",
    "df['hp_bin'] = pd.cut(x=df['horsepower'], bins=[0, 100, 200, 1000],\n",
    "                            labels=bin_names, include_lowest=True)\n",
    "\n",
    "# 범주형 데이터를 더미 변수(dummy variables)로 변환\n",
    "# 해당 범주에 해당하는 경우는 1, 그렇지 않은 경우는 0으로 표시\n",
    "horsepower_dummies = pd.get_dummies(df['hp_bin'])\n",
    "print(horsepower_dummies.head(15))\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      mpg  cylinders  displacement  horsepower  weight  acceleration  \\\n",
      "0    18.0          8         307.0       130.0    3504          12.0   \n",
      "1    15.0          8         350.0       165.0    3693          11.5   \n",
      "2    18.0          8         318.0       150.0    3436          11.0   \n",
      "3    16.0          8         304.0       150.0    3433          12.0   \n",
      "4    17.0          8         302.0       140.0    3449          10.5   \n",
      "..    ...        ...           ...         ...     ...           ...   \n",
      "393  27.0          4         140.0        86.0    2790          15.6   \n",
      "394  44.0          4          97.0        52.0    2130          24.6   \n",
      "395  32.0          4         135.0        84.0    2295          11.6   \n",
      "396  28.0          4         120.0        79.0    2625          18.6   \n",
      "397  31.0          4         119.0        82.0    2720          19.4   \n",
      "\n",
      "     model_year  origin                       name  hp_bin_저출력  hp_bin_보통출력  \\\n",
      "0            70     usa  chevrolet chevelle malibu       False         True   \n",
      "1            70     usa          buick skylark 320       False         True   \n",
      "2            70     usa         plymouth satellite       False         True   \n",
      "3            70     usa              amc rebel sst       False         True   \n",
      "4            70     usa                ford torino       False         True   \n",
      "..          ...     ...                        ...         ...          ...   \n",
      "393          82     usa            ford mustang gl        True        False   \n",
      "394          82  europe                  vw pickup        True        False   \n",
      "395          82     usa              dodge rampage        True        False   \n",
      "396          82     usa                ford ranger        True        False   \n",
      "397          82     usa                 chevy s-10        True        False   \n",
      "\n",
      "     hp_bin_고출력  \n",
      "0         False  \n",
      "1         False  \n",
      "2         False  \n",
      "3         False  \n",
      "4         False  \n",
      "..          ...  \n",
      "393       False  \n",
      "394       False  \n",
      "395       False  \n",
      "396       False  \n",
      "397       False  \n",
      "\n",
      "[392 rows x 12 columns]\n"
     ]
    }
   ],
   "source": [
    "# 기존 데이터프레임 df에서 'hp_bin' 열을 더미 변수로 변환하고, 결과를 새로운 데이터프레임 df1에 저장\n",
    "df1 = pd.get_dummies(df, columns=['hp_bin'])\n",
    "print(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Alcohol  Malic_Acid   Ash  Ash_Alcanity  Magnesium  Total_Phenols  \\\n",
      "0    14.23        1.71  2.43          15.6        127           2.80   \n",
      "1    13.20        1.78  2.14          11.2        100           2.65   \n",
      "2    13.16        2.36  2.67          18.6        101           2.80   \n",
      "3    14.37        1.95  2.50          16.8        113           3.85   \n",
      "4    13.24        2.59  2.87          21.0        118           2.80   \n",
      "\n",
      "   Flavanoids  Nonflavanoid_Phenols  Proanthocyanins  Color_Intensity   Hue  \\\n",
      "0        3.06                  0.28             2.29             5.64  1.04   \n",
      "1        2.76                  0.26             1.28             4.38  1.05   \n",
      "2        3.24                  0.30             2.81             5.68  1.03   \n",
      "3        3.49                  0.24             2.18             7.80  0.86   \n",
      "4        2.69                  0.39             1.82             4.32  1.04   \n",
      "\n",
      "   OD280  Proline  \n",
      "0   3.92     1065  \n",
      "1   3.40     1050  \n",
      "2   3.17     1185  \n",
      "3   3.45     1480  \n",
      "4   2.93      735  \n"
     ]
    }
   ],
   "source": [
    "# 데이터의 표준화와 정규화\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "df = pd.read_csv(\"wine-clustering.csv\")\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Alcohol  Malic_Acid       Ash  Ash_Alcanity  Magnesium  Total_Phenols  \\\n",
      "0  1.518613   -0.562250  0.232053     -1.169593   1.913905       0.808997   \n",
      "1  0.246290   -0.499413 -0.827996     -2.490847   0.018145       0.568648   \n",
      "2  0.196879    0.021231  1.109334     -0.268738   0.088358       0.808997   \n",
      "3  1.691550   -0.346811  0.487926     -0.809251   0.930918       2.491446   \n",
      "4  0.295700    0.227694  1.840403      0.451946   1.281985       0.808997   \n",
      "\n",
      "   Flavanoids  Nonflavanoid_Phenols  Proanthocyanins  Color_Intensity  \\\n",
      "0    1.034819             -0.659563         1.224884         0.251717   \n",
      "1    0.733629             -0.820719        -0.544721        -0.293321   \n",
      "2    1.215533             -0.498407         2.135968         0.269020   \n",
      "3    1.466525             -0.981875         1.032155         1.186068   \n",
      "4    0.663351              0.226796         0.401404        -0.319276   \n",
      "\n",
      "        Hue     OD280   Proline  \n",
      "0  0.362177  1.847920  1.013009  \n",
      "1  0.406051  1.113449  0.965242  \n",
      "2  0.318304  0.788587  1.395148  \n",
      "3 -0.427544  1.184071  2.334574  \n",
      "4  0.362177  0.449601 -0.037874  \n"
     ]
    }
   ],
   "source": [
    "# 표준화\n",
    "# 표준화는 데이터의 평균을 0, 분산을 1로 변환하는 과정\n",
    "\n",
    "# 객체 생성\n",
    "StandardScaler = StandardScaler()\n",
    "\n",
    "# 데이터 df를 표준화.\n",
    "# fit()은 데이터를 기반으로 평균과 표준편차를 계산하고, transform()은 이 계산된 값으로 데이터를 변환, 결과는 표준화된 값들\n",
    "df_stand = StandardScaler.fit_transform(df)\n",
    "\n",
    "# 표준화된 값을 다시 DataFrame으로 변환하여 df_stand에 저장.\n",
    "# 원래 데이터의 열 이름을 유지하기 위해 columns=df.columns를 사용\n",
    "df_stand = pd.DataFrame(data = df_stand, columns=df.columns)\n",
    "\n",
    "\n",
    "print(df_stand.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Alcohol  Malic_Acid       Ash  Ash_Alcanity  Magnesium  Total_Phenols  \\\n",
      "0  0.842105    0.191700  0.572193      0.257732   0.619565       0.627586   \n",
      "1  0.571053    0.205534  0.417112      0.030928   0.326087       0.575862   \n",
      "2  0.560526    0.320158  0.700535      0.412371   0.336957       0.627586   \n",
      "3  0.878947    0.239130  0.609626      0.319588   0.467391       0.989655   \n",
      "4  0.581579    0.365613  0.807487      0.536082   0.521739       0.627586   \n",
      "\n",
      "   Flavanoids  Nonflavanoid_Phenols  Proanthocyanins  Color_Intensity  \\\n",
      "0    0.573840              0.283019         0.593060         0.372014   \n",
      "1    0.510549              0.245283         0.274448         0.264505   \n",
      "2    0.611814              0.320755         0.757098         0.375427   \n",
      "3    0.664557              0.207547         0.558360         0.556314   \n",
      "4    0.495781              0.490566         0.444795         0.259386   \n",
      "\n",
      "        Hue     OD280   Proline  \n",
      "0  0.455285  0.970696  0.561341  \n",
      "1  0.463415  0.780220  0.550642  \n",
      "2  0.447154  0.695971  0.646933  \n",
      "3  0.308943  0.798535  0.857347  \n",
      "4  0.455285  0.608059  0.325963  \n"
     ]
    }
   ],
   "source": [
    "#정규화\n",
    "#  정규화는 데이터의 값을 특정 범위(기본적으로 0과 1)로 변환하는 과정. \n",
    "# 이는 데이터의 최소값을 0, 최대값을 1로 조정하여 데이터의 스케일을 맞추는 데 유용하다.\n",
    "\n",
    "# 객체 생성\n",
    "MinMaxScaler = MinMaxScaler()\n",
    "\n",
    "# 데이터 df를 정규화\n",
    "# fit()은 데이터의 최소값과 최대값을 계산하고, transform()은 이를 기준으로 데이터를 0과 1 사이의 값으로 변환\n",
    "df_minmax = MinMaxScaler.fit_transform(df)\n",
    "\n",
    "# 정규화된 값을 다시 DataFrame으로 변환하여 df_minmax에 저장\n",
    "df_minmax = pd.DataFrame(data = df_minmax, columns=df.columns)\n",
    "\n",
    "# 출력\n",
    "print(df_minmax.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     survived  pclass     sex   age  sibsp  parch     fare embarked   class  \\\n",
      "0           0       3    male  22.0      1      0   7.2500        S   Third   \n",
      "1           1       1  female  38.0      1      0  71.2833        C   First   \n",
      "2           1       3  female  26.0      0      0   7.9250        S   Third   \n",
      "3           1       1  female  35.0      1      0  53.1000        S   First   \n",
      "4           0       3    male  35.0      0      0   8.0500        S   Third   \n",
      "..        ...     ...     ...   ...    ...    ...      ...      ...     ...   \n",
      "886         0       2    male  27.0      0      0  13.0000        S  Second   \n",
      "887         1       1  female  19.0      0      0  30.0000        S   First   \n",
      "888         0       3  female   NaN      1      2  23.4500        S   Third   \n",
      "889         1       1    male  26.0      0      0  30.0000        C   First   \n",
      "890         0       3    male  32.0      0      0   7.7500        Q   Third   \n",
      "\n",
      "       who  adult_male deck  embark_town alive  alone  \n",
      "0      man        True  NaN  Southampton    no  False  \n",
      "1    woman       False    C    Cherbourg   yes  False  \n",
      "2    woman       False  NaN  Southampton   yes   True  \n",
      "3    woman       False    C  Southampton   yes  False  \n",
      "4      man        True  NaN  Southampton    no   True  \n",
      "..     ...         ...  ...          ...   ...    ...  \n",
      "886    man        True  NaN  Southampton    no   True  \n",
      "887  woman       False    B  Southampton   yes   True  \n",
      "888  woman       False  NaN  Southampton    no  False  \n",
      "889    man        True    C    Cherbourg   yes   True  \n",
      "890    man        True  NaN   Queenstown    no   True  \n",
      "\n",
      "[891 rows x 15 columns]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 머신러닝에 필요한 훈련용(train)과 테스트용(test) 데이터를 분리하는 과정\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_excel(\"titanic.xlsx\")\n",
    "print(df)\n",
    "print()\n",
    "\n",
    "# 데이터프레임 df에서 'survived' 열을 제외한 나머지 데이터를 X 변수에 저장, 이는 모델이 학습할 입력 데이터\n",
    "# 이는 모델이 학습할 입력 데이터\n",
    "X = df.drop('survived', axis=1)\n",
    "# y는 예측하려는 목표 변수(target variable)이며, 타이타닉 승객이 생존했는지 여부(0 또는 1)를 나타냄\n",
    "y = df['survived']\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 입력 데이터 X와 목표 변수 y를 훈련용과 테스트용으로 분리\n",
    "# test_size=0.3: 전체 데이터 중 30%를 테스트용 데이터로 할당하고, 70%를 훈련용 데이터로 사용\n",
    "# random_state=0: 무작위로 데이터를 섞을 때의 시드(seed) 값을 설정하여 데이터 분할이 항상 동일한 방식으로 이루어지도록 고정\n",
    "# stratify=y: 데이터를 층화 추출(stratified sampling) 방식으로 분할\n",
    "# shuffle=True: 데이터를 분할하기 전에 무작위로 섞어(shuffle)준다.\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0,\n",
    "                                                    stratify=y, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(array([  0,   1,   2,   3,   4,   5,   6,   8,   9,  10,  11,  12,  13,\n",
       "          14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,\n",
       "          27,  28,  29,  30,  31,  32,  34,  35,  36,  37,  38,  39,  41,\n",
       "          42,  43,  44,  45,  46,  47,  48,  49,  50,  52,  53,  55,  56,\n",
       "          57,  58,  59,  60,  61,  64,  65,  66,  67,  68,  69,  70,  72,\n",
       "          74,  75,  77,  78,  79,  80,  81,  82,  83,  84,  85,  87,  88,\n",
       "          89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99, 101, 102,\n",
       "         103, 104, 105, 106, 108, 109, 110, 111, 112, 113, 115, 116, 117,\n",
       "         118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n",
       "         131, 132, 133, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,\n",
       "         145, 146, 147, 148, 149]),\n",
       "  array([  7,  33,  40,  51,  54,  62,  63,  71,  73,  76,  86, 100, 107,\n",
       "         114, 134])),\n",
       " (array([  0,   1,   2,   3,   4,   5,   6,   7,   9,  10,  11,  12,  13,\n",
       "          14,  15,  17,  18,  19,  20,  21,  23,  25,  27,  28,  29,  30,\n",
       "          31,  32,  33,  34,  35,  36,  38,  39,  40,  41,  42,  43,  46,\n",
       "          47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,\n",
       "          60,  61,  62,  63,  64,  65,  67,  68,  69,  70,  71,  72,  73,\n",
       "          74,  75,  76,  77,  79,  80,  81,  82,  83,  84,  85,  86,  87,\n",
       "          88,  89,  91,  92,  94,  95,  96,  98,  99, 100, 101, 102, 103,\n",
       "         104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,\n",
       "         117, 118, 119, 120, 122, 123, 124, 125, 127, 128, 129, 130, 131,\n",
       "         132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,\n",
       "         145, 146, 147, 148, 149]),\n",
       "  array([  8,  16,  22,  24,  26,  37,  44,  45,  66,  78,  90,  93,  97,\n",
       "         121, 126])),\n",
       " (array([  0,   1,   3,   4,   5,   6,   7,   8,   9,  11,  12,  13,  14,\n",
       "          15,  16,  17,  19,  20,  21,  22,  23,  24,  25,  26,  28,  29,\n",
       "          30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,\n",
       "          44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,\n",
       "          57,  58,  60,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,\n",
       "          72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  85,  86,\n",
       "          87,  88,  89,  90,  91,  93,  94,  95,  96,  97,  98,  99, 100,\n",
       "         101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 113, 114,\n",
       "         115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128,\n",
       "         129, 130, 131, 133, 134, 135, 136, 138, 139, 140, 142, 143, 144,\n",
       "         145, 146, 147, 148, 149]),\n",
       "  array([  2,  10,  18,  27,  43,  59,  61,  83,  84,  92, 112, 127, 132,\n",
       "         137, 141])),\n",
       " (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,\n",
       "          13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,\n",
       "          26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,\n",
       "          39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  51,  52,\n",
       "          53,  54,  55,  57,  58,  59,  61,  62,  63,  64,  65,  66,  67,\n",
       "          68,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  81,  82,\n",
       "          83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,\n",
       "          96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 107, 109, 110,\n",
       "         111, 112, 113, 114, 115, 117, 118, 120, 121, 122, 124, 125, 126,\n",
       "         127, 128, 129, 130, 131, 132, 134, 136, 137, 138, 139, 140, 141,\n",
       "         142, 143, 145, 148, 149]),\n",
       "  array([ 50,  56,  60,  69,  80, 106, 108, 116, 119, 123, 133, 135, 144,\n",
       "         146, 147])),\n",
       " (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,\n",
       "          14,  16,  17,  18,  19,  21,  22,  23,  24,  25,  26,  27,  28,\n",
       "          29,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,\n",
       "          43,  44,  45,  46,  47,  49,  50,  51,  53,  54,  55,  56,  57,\n",
       "          58,  59,  60,  61,  62,  63,  65,  66,  67,  68,  69,  70,  71,\n",
       "          72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,\n",
       "          86,  87,  88,  90,  92,  93,  96,  97,  98,  99, 100, 102, 103,\n",
       "         104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117,\n",
       "         118, 119, 120, 121, 122, 123, 124, 126, 127, 128, 129, 130, 131,\n",
       "         132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,\n",
       "         145, 146, 147, 148, 149]),\n",
       "  array([ 13,  15,  20,  30,  48,  52,  64,  85,  89,  91,  94,  95, 101,\n",
       "         111, 125])),\n",
       " (array([  0,   1,   2,   4,   5,   7,   8,   9,  10,  13,  14,  15,  16,\n",
       "          17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,\n",
       "          30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,\n",
       "          43,  44,  45,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,\n",
       "          57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  69,  70,\n",
       "          71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,\n",
       "          84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  97,\n",
       "          99, 100, 101, 103, 105, 106, 107, 108, 111, 112, 113, 114, 115,\n",
       "         116, 117, 118, 119, 121, 122, 123, 124, 125, 126, 127, 129, 130,\n",
       "         131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,\n",
       "         144, 145, 146, 147, 148]),\n",
       "  array([  3,   6,  11,  12,  46,  68,  96,  98, 102, 104, 109, 110, 120,\n",
       "         128, 149])),\n",
       " (array([  0,   2,   3,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,\n",
       "          16,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,\n",
       "          30,  31,  32,  33,  34,  35,  36,  37,  39,  40,  43,  44,  45,\n",
       "          46,  47,  48,  49,  50,  51,  52,  54,  55,  56,  57,  58,  59,\n",
       "          60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,\n",
       "          73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,\n",
       "          86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,\n",
       "          99, 100, 101, 102, 103, 104, 106, 107, 108, 109, 110, 111, 112,\n",
       "         114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127,\n",
       "         128, 130, 131, 132, 133, 134, 135, 136, 137, 138, 140, 141, 142,\n",
       "         144, 145, 146, 147, 149]),\n",
       "  array([  1,   4,   5,  17,  38,  41,  42,  53, 105, 113, 124, 129, 139,\n",
       "         143, 148])),\n",
       " (array([  1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,\n",
       "          14,  15,  16,  17,  18,  19,  20,  21,  22,  24,  25,  26,  27,\n",
       "          29,  30,  33,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,\n",
       "          46,  47,  48,  49,  50,  51,  52,  53,  54,  56,  58,  59,  60,\n",
       "          61,  62,  63,  64,  66,  67,  68,  69,  70,  71,  72,  73,  76,\n",
       "          77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,\n",
       "          90,  91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102,\n",
       "         103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,\n",
       "         116, 117, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n",
       "         130, 132, 133, 134, 135, 136, 137, 139, 140, 141, 142, 143, 144,\n",
       "         145, 146, 147, 148, 149]),\n",
       "  array([  0,  23,  28,  31,  32,  34,  35,  55,  57,  65,  74,  75, 118,\n",
       "         131, 138])),\n",
       " (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,\n",
       "          13,  15,  16,  17,  18,  20,  21,  22,  23,  24,  26,  27,  28,\n",
       "          30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,\n",
       "          43,  44,  45,  46,  47,  48,  50,  51,  52,  53,  54,  55,  56,\n",
       "          57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,\n",
       "          70,  71,  73,  74,  75,  76,  78,  80,  81,  83,  84,  85,  86,\n",
       "          87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98, 100,\n",
       "         101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,\n",
       "         114, 116, 117, 118, 119, 120, 121, 123, 124, 125, 126, 127, 128,\n",
       "         129, 131, 132, 133, 134, 135, 137, 138, 139, 140, 141, 142, 143,\n",
       "         144, 146, 147, 148, 149]),\n",
       "  array([ 14,  19,  25,  29,  49,  72,  77,  79,  82,  99, 115, 122, 130,\n",
       "         136, 145])),\n",
       " (array([  0,   1,   2,   3,   4,   5,   6,   7,   8,  10,  11,  12,  13,\n",
       "          14,  15,  16,  17,  18,  19,  20,  22,  23,  24,  25,  26,  27,\n",
       "          28,  29,  30,  31,  32,  33,  34,  35,  37,  38,  40,  41,  42,\n",
       "          43,  44,  45,  46,  48,  49,  50,  51,  52,  53,  54,  55,  56,\n",
       "          57,  59,  60,  61,  62,  63,  64,  65,  66,  68,  69,  71,  72,\n",
       "          73,  74,  75,  76,  77,  78,  79,  80,  82,  83,  84,  85,  86,\n",
       "          89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101,\n",
       "         102, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,\n",
       "         116, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n",
       "         130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 141, 143, 144,\n",
       "         145, 146, 147, 148, 149]),\n",
       "  array([  9,  21,  36,  39,  47,  58,  67,  70,  81,  87,  88, 103, 117,\n",
       "         140, 142]))]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# KFold 교차 검증을 설정하여 데이터를 10개의 폴드(fold)로 분할하려는 작업을 수행\n",
    "\n",
    "import pandas as pd\n",
    "df = pd.read_excel(\"iris.xlsx\")\n",
    "\n",
    "from sklearn.model_selection import KFold\n",
    "\n",
    "# n_splits=10: 데이터를 10개의 폴드(folds)로 나눔. 즉, 각 폴드는 10%의 데이터를 포함하며, 전체 데이터셋에서 10번 반복해서 훈련과 테스트를 수행\n",
    "# shuffle=True: 데이터를 분할하기 전에 무작위로 섞는다.\n",
    "# shuffle=True와 함께 사용되어 데이터가 항상 동일한 방식으로 섞이도록 난수 seed 고정\n",
    "kfold = KFold(n_splits=10, shuffle=True, random_state=0)\n",
    "\n",
    "# 데이터를 10개의 폴드로 나누고, 각 폴드의 훈련 인덱스와 테스트 인덱스를 생성\n",
    "# 반환값은 각 폴드에 대한 (train_index, test_index)의 쌍으로 이루어진 리스트\n",
    "list(kfold.split(df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    y_test  y_pred\n",
      "0        0       0\n",
      "1        1       1\n",
      "2        1       1\n",
      "3        1       1\n",
      "4        0       0\n",
      "5        0       1\n",
      "6        0       1\n",
      "7        0       0\n",
      "8        0       1\n",
      "9        0       0\n",
      "10       0       0\n",
      "11       1       1\n",
      "12       1       1\n",
      "13       1       1\n",
      "14       1       0\n",
      "15       0       0\n",
      "16       0       1\n",
      "17       0       0\n",
      "18       0       0\n",
      "19       0       0\n",
      "20       0       0\n",
      "21       1       1\n",
      "22       1       1\n",
      "23       1       1\n",
      "24       0       1\n",
      "25       1       1\n",
      "26       0       0\n",
      "27       1       1\n",
      "28       1       1\n",
      "29       1       1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 혼동 행렬(confusion matrix)과 분류 보고서(classification report)를 출력하는 작업\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "df = pd.read_excel(\"test.xlsx\")\n",
    "print(df)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 혼동 행렬(confusion matrix)을 계산\n",
    "confusion_matrix(df['y_test'], df['y_pred'])\n",
    "\n",
    "# 분류 보고서(classification report)를 생성하여 모델의 성능 지표를 제공\n",
    "# Precision: 모델이 Positive로 예측한 샘플 중 실제로 Positive인 비율.\n",
    "# Recall: 실제 Positive인 샘플 중에서 모델이 올바르게 예측한 비율.\n",
    "# F1-Score: Precision과 Recall의 조화 평균. 이 점수는 Precision과 Recall의 균형을 측정.\n",
    "# Support: 각 클래스에 속하는 샘플의 개수.\n",
    "classification_report(df['y_test'], df['y_pred'])\n",
    "\n",
    "\n",
    "print(classification_report(df['y_test'], df['y_pred']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 정확도(accuracy) 계산\n",
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(df['y_test'], df['y_pred'])\n",
    "\n",
    "# 정밀도 (Precision Score) 계산\n",
    "from sklearn.metrics import precision_score\n",
    "precision_score(df['y_test'], df['y_pred'], average=None)\n",
    "\n",
    "# 재현율 (Recall Score) 계산\n",
    "from sklearn.metrics import recall_score\n",
    "recall_score(df['y_test'], df['y_pred'], average=None)\n",
    "\n",
    "# F1-점수 (F1 Score) 계산\n",
    "from sklearn.metrics import f1_score\n",
    "f1_score(df['y_test'], df['y_pred'], average=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "439.5036496350372\n",
      "964.0\n",
      "1292.9635036496354\n",
      "3.3333333333333406\n"
     ]
    }
   ],
   "source": [
    "# 회귀 분석 결과를 평가하기 위해 잔차(residuals), SSE, SST, SSR, 그리고 AE를 계산하는 작업을 수행\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "# data['y']: 실제 값(종속 변수, y)이 포함된 열\n",
    "data = pd.read_excel(\"회귀예측.xlsx\")\n",
    "# pred['pred']: 회귀 모델에서 예측한 값(독립 변수, pred)이 포함된 열\n",
    "pred = pd.read_csv(\"pred.csv\")\n",
    "\n",
    "\n",
    "# 잔차(residuals)는 실제 값과 예측 값의 차이를 나타냄\n",
    "residuals = data['y']-pred['pred'] #잔차\n",
    "\n",
    "# SSE(Sum of Squared Errors, 잔차 제곱합)는 잔차의 제곱을 모두 더한 값\n",
    "SSE = (residuals**2).sum()\n",
    "print(SSE)\n",
    "\n",
    "# SST(Total Sum of Squares, 총 제곱합)은 실제 값과 평균 값 간의 차이를 제곱한 후 모두 더한 값\n",
    "SST = ((data['y']-data['y'].mean())**2).sum()\n",
    "print(SST)\n",
    "\n",
    "# SSR(Sum of Squares for Regression, 회귀 제곱합)은 예측 값과 실제 값의 평균 간의 차이를 제곱한 후 모두 더한 값\n",
    "SSR = ((pred['pred'] - data['y'].mean())**2).sum()\n",
    "print(SSR)\n",
    "\n",
    "# AE(Average Error, 평균 오차)는 실제 값과 예측 값 간의 차이의 평균을 계산한 값\n",
    "AE = ((data['y'] - pred['pred']).sum())/6\n",
    "print(AE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.958637469586378\n",
      "73.2506082725062\n",
      "8.558656919897315\n",
      "0.08751420459298238\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/sindongseong/DsStudy/konkuk-da/myenv/lib/python3.9/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# 다양한 회귀 모델 성능 평가 지표를 사용하여 \n",
    "# 평균 절대 오차(MAE), 평균 제곱 오차(MSE), 평균 제곱근 오차(RMSE), \n",
    "# 평균 절대 백분율 오차(MAPE)를 계산하는 작업을 수행\n",
    "\n",
    "# MAE(평균 절대 오차)는 실제 값과 예측 값의 차이의 절대값을 평균한 값\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "MAE = mean_absolute_error(data['y'], pred['pred'])\n",
    "print(MAE)\n",
    "\n",
    "# MSE(평균 제곱 오차)는 예측 오차의 제곱을 평균한 값\n",
    "from sklearn.metrics import mean_squared_error\n",
    "MSE = mean_squared_error(data['y'], pred['pred'])\n",
    "print(MSE)\n",
    "\n",
    "# RMSE(평균 제곱근 오차)는 MSE의 제곱근으로, MSE에서 제곱의 단위를 원래 스케일로 되돌리기 위한 값\n",
    "from sklearn.metrics import mean_squared_error\n",
    "RMSE = mean_squared_error(data['y'], pred['pred'], squared=False)\n",
    "print(RMSE)\n",
    "\n",
    "# MAPE(평균 절대 백분율 오차)는 실제 값과 예측 값 사이의 차이를 백분율로 나타낸 것\n",
    "from sklearn.metrics import mean_absolute_percentage_error\n",
    "MAPE = mean_absolute_percentage_error(data['y'], pred['pred'])\n",
    "print(MAPE)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myenv",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}