데이터 전처리 및 URF 분류모델.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9029f06b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader, random_split\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "12dae837",
   "metadata": {}, 
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\82102\\Desktop\\Datasets(Right)\\Datasets(Right) 최종\n"
     ]
    }
   ],
   "source": [
    "cd C:\\Users\\82102\\Desktop\\Datasets(Right)\\Datasets(Right) 최종"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5765005c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(x1, y1, x2, y2):       # 기울기 공식 \n",
    "    m = (y2-y1) / (x2-x1)\n",
    "    return m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "76992aab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Coefficient(df):       #기울기 구하는 함수 정의 \n",
    "    coef = []\n",
    "    for i in range(49, 351):                # 400프레임 중 앞 뒤 50프레임 자르기 \n",
    "        frame1 = df[i][gradlab1][0:2]\n",
    "        frame2 = df[i][gradlab2][0:2]\n",
    "        coef.append(distance(frame1[0], frame1[1], frame2[0], frame2[1]))  # 기울기 구하기 \n",
    "    coef = pd.DataFrame(coef, columns= ['coef'])\n",
    "    \n",
    "    q3=coef['coef'].quantile(0.75)             #IQR 이상치 변환\n",
    "    q1=coef['coef'].quantile(0.25)              \n",
    "    iqr=q3-q1 \n",
    "    outlier_top=q3+1.5*iqr\n",
    "    outlier_bottom=q1-1.5*iqr\n",
    "    idx=coef[(coef['coef']<outlier_bottom) | (coef['coef']>outlier_top)].index\n",
    "    \n",
    "    idx_list=[]               \n",
    "    for i in idx:\n",
    "        idx_list.append(str(i))\n",
    "    idx_list.append('end')\n",
    "\n",
    "    idx_string = ' '.join(idx_list)\n",
    "    idx_string_split = idx_string.split('end')\n",
    "    outlier_str = idx_string_split[0].strip()\n",
    "    outlier = list(map(int, outlier_str.split(' ')[:-1]))\n",
    "\n",
    "    for i in range(len(coef)-1):\n",
    "        if i in outlier:\n",
    "            if i == 0:\n",
    "                continue\n",
    "            elif i != (len(coef)-1):\n",
    "                coef['coef'][i] = (coef['coef'][i-1] + coef['coef'][i+1])/2\n",
    "            else:\n",
    "                break\n",
    "                \n",
    "    coef = np.array(coef)[1:301]\n",
    "    \n",
    "    return coef\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "64139fea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Acceleration(pos_1, array_1, acclab):              # 가속도 이상치  함수 정의 \n",
    "    df = pd.DataFrame(array_1[:,acclab,:], columns=['x','y','z'])\n",
    "    idx_list=[]\n",
    "    for i in ['x','y','z']:              \n",
    "        q3=df[i].quantile(0.75)\n",
    "        q1=df[i].quantile(0.25)\n",
    "        iqr=q3-q1\n",
    "        outlier_top=q3+1.5*iqr\n",
    "        outlier_bottom=q1-1.5*iqr\n",
    "\n",
    "        idx=df[(df[i]<outlier_bottom) | (df[i]>outlier_top)].index\n",
    "        for i in idx:\n",
    "            idx_list.append(str(i))\n",
    "        idx_list.append('end')\n",
    "    \n",
    "    idx_string = ' '.join(idx_list)\n",
    "    idx_string_split = idx_string.split('end')\n",
    "    x_outlier_str = idx_string_split[0].strip()\n",
    "    y_outlier_str = idx_string_split[1].strip()\n",
    "    x_outlier = list(map(int, x_outlier_str.split(' ')[:-1]))\n",
    "    y_outlier = list(map(int, y_outlier_str.split(' ')[:-1]))\n",
    "    \n",
    "    acc_1_parsed = array_1[:,acclab,:]\n",
    "    for i in range(len(pos_1)-1):\n",
    "        if i in x_outlier:\n",
    "            acc_1_parsed[i][0] = (acc_1_parsed[i-1][0] + acc_1_parsed[i+1][0])/2 \n",
    "        if i in y_outlier:\n",
    "            acc_1_parsed[i][2] = (acc_1_parsed[i-1][2] + acc_1_parsed[i+1][2])/2 \n",
    "       \n",
    "    final_df = pd.DataFrame(acc_1_parsed, columns = ['x','y','z'])\n",
    "    acc_array = StandardScaler().fit_transform(final_df)         # 가속도 정규 표준화 \n",
    "    acc_array = acc_array[49:349,:]\n",
    "    return acc_array[:,:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "48bd2929-4bcb-4a48-8ce2-bd3b73633171",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocessing(gesture):             # 정답 데이터셋 구성 \n",
    "    data2 = np.zeros((1,300,6))\n",
    "    for i in range(1, num_session+1):\n",
    "        data = np.zeros((300,1))\n",
    "        pos = np.load('%s_%s_p_%d.npy' % (hand, gesture, i))  # 위치데이터 로드\n",
    "        acc = np.load('%s_%s_a_%d.npy' % (hand, gesture, i))  # 가속도데이터 로드\n",
    "        acc1 = Acceleration(pos, acc, acclab1)    # 첫 번재 랜드마크 가속도 데이터       \n",
    "        acc2 = Acceleration(pos, acc, acclab2)    # 두 번째 랜드마크 가속도 데이터\n",
    "        coef = Coefficient(pos)       # 기울기 데이터 (랜드마크 이은)\n",
    "        if gesture == right_gesture:\n",
    "            label = np.ones((300,1))\n",
    "        else:\n",
    "            label = np.zeros((300,1))\n",
    "        data = np.hstack((data,acc1,acc2,coef,label))\n",
    "        data = data[:, 1:].reshape((1,300,6))\n",
    "        data2 = np.vstack((data2,data))\n",
    "        \n",
    "    return data2[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "97832cee-8a95-4103-b556-486f7f78690c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random # 랜덤시드 바꿔보기\n",
    "random.seed(256)\n",
    "num_session2 = 25\n",
    "def preprocessing2(right_gesture):    # 오류 데이터셋 구성 \n",
    "    data2 = np.zeros((1,300,6))\n",
    "    for j in (gesture_list):\n",
    "        if j == right_gesture:\n",
    "            gesture_list.remove(j)\n",
    "            print(gesture_list)\n",
    "    for i in range(1, num_session2+1):\n",
    "        gesture_choice = random.choice(gesture_list)\n",
    "        data = np.zeros((300,1))\n",
    "        pos = np.load('%s_%s_p_%d.npy' % (hand, gesture_choice, i))\n",
    "        acc = np.load('%s_%s_a_%d.npy' % (hand, gesture_choice, i))\n",
    "        acc1 = Acceleration(pos, acc, acclab1)\n",
    "        acc2 = Acceleration(pos, acc, acclab2)\n",
    "        coef = Coefficient(pos)\n",
    "        \n",
    "        label = np.zeros((300,1))\n",
    "        \n",
    "        data = np.hstack((data,acc1,acc2,coef,label))\n",
    "        data = data[:, 1:].reshape((1,300,6))\n",
    "        data2 = np.vstack((data2,data))\n",
    "    \n",
    "    return data2[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6dbd941b",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_session = 100      \n",
    "gesture_list = ['URF','UMF','ULF','DLF','DMF','DRF','URB','UMB','ULB','DLB','DMB','DRB','URO','ULO','DLO','DRO']\n",
    "right_gesture = gesture_list[0]   #정답 영역 선택\n",
    "hand = 'Right'   # 왼손 오른손 선택 \n",
    "\n",
    "# 랜드마크 지정 \n",
    "acclab1 = 0\n",
    "acclab2 = 5\n",
    "gradlab1 = 8\n",
    "gradlab2 = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "eeca63c0-db9a-486f-9a99-503b4b9221a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['UMF', 'ULF', 'DLF', 'DMF', 'DRF', 'URB', 'UMB', 'ULB', 'DLB', 'DMB', 'DRB', 'URO', 'ULO', 'DLO', 'DRO']\n"
     ]
    }
   ],
   "source": [
    "target_data = preprocessing('URF')\n",
    "error_data = preprocessing2('URF')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0546b55d-c465-438f-8c85-22af508085be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((100, 300, 6), (25, 300, 6))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_data.shape, error_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "556bbbf3-03ca-450f-82bd-7c763a5dca41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(125, 300, 6)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.vstack((target_data, error_data))     # 정답데이터 셋 + 오류데이터 셋 = 활용할 데이터 셋 \n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "48794343",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('data_URF.npy', data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6bf35771",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomDataset(Dataset):        # 데이터 불러오기 \n",
    "    def __init__(self, file_name, transform=None,  target_transform=None):\n",
    "        df = np.load(file_name)\n",
    "        self.x_data = df[:,:,:-1]  # feature \n",
    "        self.y_data = df[:,:,-1]   # label \n",
    "        \n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        x_data = torch.FloatTensor([self.x_data[idx]])\n",
    "        y_data = torch.Tensor(self.y_data[idx])\n",
    "        \n",
    "        return x_data, y_data\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.x_data) #데이터셋 크기 리턴\n",
    "               \n",
    "        #i번째 샘플을 찾는데 사용됨. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5a210653",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = CustomDataset('data_URF.npy')\n",
    "dataset_size = len(dataset)\n",
    "train_size = int(dataset_size * 0.8)     # 훈련데이터\n",
    "validation_size = int(dataset_size * 0.1)   # 검증데이터\n",
    "test_size = dataset_size - train_size - validation_size  # 테스트 데이터 \n",
    "train_dataset, val_dataset, test_dataset = random_split(dataset, [train_size, validation_size, test_size]) # session 기준으로 randomsplit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "63b08c54-f14d-4dd1-a52d-af66a2e9deb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader = DataLoader(train_dataset, shuffle=True)\n",
    "val_dataloader = DataLoader(val_dataset, shuffle = True)\n",
    "test_dataloader = DataLoader(test_dataset, shuffle = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e5752f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader = DataLoader(train_dataset, batch_size=10, shuffle=True)\n",
    "val_dataloader = DataLoader(val_dataset, batch_size=validation_size, shuffle = True)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=test_size, shuffle = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9aecca48-0270-4952-82e8-cf0ff82d26eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([10, 300, 5]), torch.Size([10, 1]))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x, train_y = next(iter(train_dataloader))\n",
    "train_x = train_x.squeeze(dim=1)\n",
    "train_y = train_y[:,-1].unsqueeze(dim=1)\n",
    "train_x.size(), train_y.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cdf15a95",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size= 5\n",
    "hidden_size = 32 \n",
    "num_layers = 2\n",
    "dropout_rate= 0.5\n",
    "num_classes = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5a01b99d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM_Chicka(nn.Module):\n",
    "    def __init__(self, num_classes, input_size, hidden_size, num_layers, dropout_rate):\n",
    "        super(LSTM_Chicka,self).__init__()\n",
    "        self.num_classes = num_classes #number of classes\n",
    "        self.num_layers = num_layers  #layers\n",
    "        self.input_size = input_size #input size\n",
    "        self.hidden_size = hidden_size #hidden state\n",
    "        self.dropout_rate = dropout_rate  #dropout_rate\n",
    "        self.lstm =  nn.LSTM(input_size = input_size, hidden_size = hidden_size, num_layers = num_layers, dropout = dropout_rate, batch_first = True)\n",
    "        self.layer_out = nn.Linear(hidden_size, num_classes) \n",
    "        self.sigmoid = nn.Sigmoid()  #이중분류 시 sigmoid 함수 활용\n",
    "        \n",
    "    def forward(self,x):\n",
    "        out, _status = self.lstm(x)\n",
    "        out = self.layer_out(out[:, -1]) \n",
    "        out = self.sigmoid(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2b975c9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LSTM_Chicka(num_classes, input_size, hidden_size, num_layers, dropout_rate)\n",
    "criterion = torch.nn.BCELoss()     #이중분류시 사용하는 binarycrossentropy 손실함수 사용 \n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)  # Adam 제일 성능이 좋았음  / 보류 (미정)\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer= optimizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cbde117c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([12, 300, 5]), torch.Size([12, 1]))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val_x, val_y = next(iter(val_dataloader))\n",
    "val_x = val_x.squeeze(dim=1)\n",
    "val_y = val_y[:,-1].unsqueeze(dim=1)\n",
    "val_x.size(), val_y.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "884e024c",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_iterations = []\n",
    "train_losses = []\n",
    "val_iterations = []\n",
    "val_losses = []\n",
    "train_accuracy_final = []\n",
    "accuracy_final = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6f985021",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(num_epochs):\n",
    "\n",
    "    print(\"Begin training...\") \n",
    "    for epoch in range(1, num_epochs+1): \n",
    "        running_train_loss = 0.0 \n",
    "        running_accuracy = 0.0 \n",
    "        running_vall_loss = 0.0 \n",
    "        total = 0 \n",
    "        train_running_accuracy = 0.0\n",
    "         # Training Loop \n",
    "        for data in train_dataloader: \n",
    "            inputs, outputs = data  # get the input and real species as outputs; data is a list of [inputs, outputs] \n",
    "            inputs = inputs.squeeze(dim=1)\n",
    "            outputs = outputs[:,-1].unsqueeze(dim=1)\n",
    "            optimizer.zero_grad()   # zero the parameter gradients          \n",
    "            predicted_outputs = model(inputs)   # predict output from the model \n",
    "            train_loss = criterion(predicted_outputs, outputs)   # calculate loss for the predicted output  \n",
    "            train_loss.backward()   # backpropagate the loss \n",
    "            optimizer.step()        # adjust parameters based on the calculated gradients \n",
    "            running_train_loss +=train_loss.item()  # track the loss value \n",
    "            train_predicted = predicted_outputs.detach().numpy()\n",
    "            train_predicted = np.round(train_predicted)                   # 임계값 0.5 기준으로 0.5이상이면 1, 이하이면 0 \n",
    "            train_accuracy = (accuracy_score(train_predicted, outputs))\n",
    "            total += outputs.size(0) \n",
    "            train_running_accuracy += train_accuracy.sum().item()\n",
    "            \n",
    "        # Calculate training loss value / accuracy\n",
    "        train_loss_value = running_train_loss/len(train_dataloader)\n",
    "        train_iterations.append(epoch)\n",
    "        train_losses.append(train_loss_value)\n",
    "        train_accuracy_final.append(100 * train_running_accuracy / total) \n",
    "            \n",
    "        # Validation Loop \n",
    "        with torch.no_grad(): \n",
    "            model.eval() \n",
    "            for data in val_dataloader: \n",
    "                inputs, outputs = data\n",
    "                inputs = inputs.squeeze(dim=1)\n",
    "                outputs = outputs[:,-1].unsqueeze(dim=1)\n",
    "                predicted_outputs = model(inputs)\n",
    "                val_loss = criterion(predicted_outputs, outputs) \n",
    "                \n",
    "                predicted = predicted_outputs.detach().numpy()\n",
    "                predicted = np.round(predicted)                   # 임계값 0.5 기준으로 0.5이상이면 1, 이하이면 0 \n",
    "                accuracy = (accuracy_score(predicted, outputs))\n",
    "                \n",
    "                running_vall_loss += val_loss.item()  \n",
    "                total += outputs.size(0) \n",
    "                running_accuracy += accuracy.sum().item() \n",
    "        \n",
    "        # Calculate validation loss value \n",
    "        val_loss_value = running_vall_loss/len(val_dataloader) \n",
    "        val_iterations.append(epoch)\n",
    "        val_losses.append(val_loss_value)        \n",
    "        # Calculate accuracy as the number of correct predictions in the validation batch divided by the total number of predictions done.  \n",
    "        accuracy_final.append(100 * running_accuracy / total) \n",
    "         \n",
    "        # Print the statistics of the epoch \n",
    "        print('Completed training batch', epoch, 'Training Loss is: %.4f' %train_loss_value, 'Validation Loss is: %.4f' %val_loss_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "daa2a06b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Begin training...\n",
      "Completed training batch 1 Training Loss is: 0.5368 Validation Loss is: 0.4857\n",
      "Completed training batch 2 Training Loss is: 0.4822 Validation Loss is: 0.4965\n",
      "Completed training batch 3 Training Loss is: 0.4544 Validation Loss is: 0.5082\n",
      "Completed training batch 4 Training Loss is: 0.4528 Validation Loss is: 0.8595\n",
      "Completed training batch 5 Training Loss is: 0.5427 Validation Loss is: 0.4662\n",
      "Completed training batch 6 Training Loss is: 0.4751 Validation Loss is: 0.4410\n",
      "Completed training batch 7 Training Loss is: 0.4792 Validation Loss is: 0.4412\n",
      "Completed training batch 8 Training Loss is: 0.4735 Validation Loss is: 0.4459\n",
      "Completed training batch 9 Training Loss is: 0.4717 Validation Loss is: 0.4463\n",
      "Completed training batch 10 Training Loss is: 0.4722 Validation Loss is: 0.4461\n",
      "Completed training batch 11 Training Loss is: 0.4722 Validation Loss is: 0.4444\n",
      "Completed training batch 12 Training Loss is: 0.4731 Validation Loss is: 0.4454\n",
      "Completed training batch 13 Training Loss is: 0.4750 Validation Loss is: 0.4507\n",
      "Completed training batch 14 Training Loss is: 0.4718 Validation Loss is: 0.4519\n",
      "Completed training batch 15 Training Loss is: 0.4709 Validation Loss is: 0.4500\n",
      "Completed training batch 16 Training Loss is: 0.4721 Validation Loss is: 0.4475\n",
      "Completed training batch 17 Training Loss is: 0.4717 Validation Loss is: 0.4481\n",
      "Completed training batch 18 Training Loss is: 0.4704 Validation Loss is: 0.4506\n",
      "Completed training batch 19 Training Loss is: 0.4720 Validation Loss is: 0.4537\n",
      "Completed training batch 20 Training Loss is: 0.4719 Validation Loss is: 0.4516\n"
     ]
    }
   ],
   "source": [
    "train(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c1f2c8f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(1, len(train_iterations)+1), train_losses, color='r')\n",
    "plt.plot(range(1, len(val_iterations)+1), val_losses, color='b')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('loss')\n",
    "plt.xlim(0, len(train_iterations)+1) # 일정한 scale\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f0bf1527-3505-41ff-b6ac-d5a742351dcb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(1, len(train_iterations)+1), train_accuracy_final , color='r')\n",
    "plt.plot(range(1, len(val_iterations)+1), accuracy_final , color='b')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('accuarcy')\n",
    "plt.xlim(0, len(train_iterations)+1) # 일정한 scale\n",
    "plt.grid(True)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e45affa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}