model2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92bbe965-f99c-4b7f-b4dd-828d5eaadc58",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/mhrrs/.conda/envs/pytorch/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "2023-04-21 18:36:09.875769: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  SSE4.1 SSE4.2 AVX AVX2 AVX512F AVX512_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "import nibabel as nib\n",
    "import matplotlib.pyplot as plt\n",
    "import gzip\n",
    "# import tensorflow as tf\n",
    "import os\n",
    "import torch\n",
    "import shutil\n",
    "import numpy as np\n",
    "from scipy import ndimage\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from transformers import get_linear_schedule_with_warmup\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.nn.modules import Softmax\n",
    "from torch.nn.modules.activation import ReLU\n",
    "# from tensorflow import keras\n",
    "# from tensorflow.keras import layers\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db475cd0-41f5-43e7-961e-cf4cc5174321",
   "metadata": {},
   "outputs": [],
   "source": [
    "def unzip_files(folderpath):\n",
    "    \n",
    "    for file in os.listdir(folderpath):\n",
    "        filepath = os.path.join(folderpath, file)\n",
    "    \n",
    "        with gzip.open(filepath, 'rb') as f_in:\n",
    "            outpath = os.path.splitext(filepath)[0]\n",
    "            print(f\"outpath: {outpath} | filename: {file[:-3]}\")\n",
    "            outputfolder = os.path.join(\"./image_data/BSE_BET_DATA/nifti_files\", file[:-3])\n",
    "            with open(outputfolder, 'wb') as f_out:\n",
    "                f_out.write(f_in.read())\n",
    "        print(file)\n",
    "    \n",
    "\n",
    "def read_nifti_file(filepath):\n",
    "    \"\"\"Read and load volume\"\"\"\n",
    "    # Read file\n",
    "    scan = nib.load(filepath)\n",
    "    # Get raw data\n",
    "    scan = scan.get_fdata()\n",
    "    return scan\n",
    "\n",
    "def normalize(volume):\n",
    "    \"\"\"Normalize the volume\"\"\"\n",
    "    min = -1000\n",
    "    max = 400\n",
    "    volume[volume < min] = min\n",
    "    volume[volume > max] = max\n",
    "    volume = (volume - min) / (max - min)\n",
    "    volume = volume.astype(\"float32\")\n",
    "    return volume\n",
    "\n",
    "\n",
    "def resize_volume(img):\n",
    "    \"\"\"Resize across z-axis\"\"\"\n",
    "    # Set the desired depth\n",
    "    desired_depth = 64\n",
    "    desired_width = 128\n",
    "    desired_height = 128\n",
    "    # Get current depth\n",
    "    current_depth = img.shape[-1]\n",
    "    current_width = img.shape[0]\n",
    "    current_height = img.shape[1]\n",
    "    # Compute depth factor\n",
    "    depth = current_depth / desired_depth\n",
    "    width = current_width / desired_width\n",
    "    height = current_height / desired_height\n",
    "    depth_factor = 1 / depth\n",
    "    width_factor = 1 / width\n",
    "    height_factor = 1 / height\n",
    "    # Rotate\n",
    "    img = ndimage.rotate(img, 90, reshape=False)\n",
    "    # Resize across z-axis\n",
    "    img = ndimage.zoom(img, (width_factor, height_factor, depth_factor), order=1)\n",
    "    return img\n",
    "\n",
    "\n",
    "def display_scan(data):\n",
    "    # Select the slice index you want to display or save (e.g., slice 20)\n",
    "    slice_index = 100\n",
    "    center = 32\n",
    "\n",
    "    # Display the image data for the selected slice\n",
    "    plt.imshow(data[:,:,center], cmap='gray')\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    # Save the image for the selected slice as JPEG\n",
    "    plt.imsave(f'slice_{center}.jpg', data[:,center,:], cmap='gray')\n",
    "\n",
    "\n",
    "def process_scan(path):\n",
    "    \"\"\"Read and resize volume\"\"\"\n",
    "    # Read scan\n",
    "    volume = read_nifti_file(path)\n",
    "    # Normalize\n",
    "    volume = normalize(volume)\n",
    "    # Resize width, height and depth\n",
    "    volume = resize_volume(volume)\n",
    "    \n",
    "    return volume"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89583e1c-7f39-4cd3-90a7-07c43c4ba0db",
   "metadata": {},
   "source": [
    "# Break up the Nifti_files folder into two different folders: recognizable and other\n",
    "Recognizable will be known as non_strip, and other will be known as stripped\n",
    "\n",
    "NOTE: Due to issues with whatever computer you are using, you may need to physically move the folders that contain the images into 3 folders named: A, B, and C within a folder name image_folder. This will allow you to skip the following cell and carry on with the rest of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b1f5b78-af9d-431b-9f13-1b89a7f173c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "nifti_folder = \"./image_data/BSE_BET_DATA/nifti_files\"\n",
    "\n",
    "csv = np.loadtxt(\"./image_data/BSE_BET_DATA/labels.csv\", delimiter=\",\", dtype=str)\n",
    "\n",
    "recognizable = []\n",
    "for item in csv:\n",
    "    if item[1] == \"Yes\":\n",
    "        recognizable.append(item[0])\n",
    "\n",
    "outputfolder = \"./image_data/BSE_BET_DATA/recognizable_features\"\n",
    "if not os.path.exists(outputfolder):\n",
    "    os.makedirs(outputfolder)\n",
    "    \n",
    "nonfolder = \"./image_data/BSE_BET_DATA/non_features\"\n",
    "if not os.path.exists(nonfolder):\n",
    "    os.makedirs(nonfolder)\n",
    "\n",
    "# for file in os.listdir(nifti_folder):\n",
    "#     if file in recognizable:\n",
    "#         filepath = os.path.join(nifti_folder, file)\n",
    "#         outputpath = os.path.join(outputfolder, file)\n",
    "#         with open(filepath, 'rb') as f_in, open(outputpath, 'wb') as f_out:\n",
    "#             shutil.copyfileobj(f_in, f_out)\n",
    "    \n",
    "#     else:\n",
    "#         filepath = os.path.join(nifti_folder, file)\n",
    "#         nonpath = os.path.join(nonfolder, file)\n",
    "#         with open(filepath, 'rb') as f_in, open(nonpath, 'wb') as f_out:\n",
    "#             shutil.copyfileobj(f_in, f_out)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e493d96-8312-4f11-971e-8ead2d75b140",
   "metadata": {},
   "outputs": [],
   "source": [
    "A_folder = os.listdir(\"./image_folder/A\") # recognizable/ no data loss\n",
    "B_folder = os.listdir(\"./image_folder/B\") #non-recognizable/ data loss\n",
    "C_folder = os.listdir(\"./image_folder/C\") #non-recognizable/ no data loss\n",
    "\n",
    "A_set = np.array([process_scan(os.path.join(\"./image_folder/A\",path)) for path in A_folder[:350]])\n",
    "print(\"A set done.\")\n",
    "B_set = np.array([process_scan(os.path.join(\"./image_folder/B\",path)) for path in B_folder[:350]])\n",
    "print(\"B set done.\")\n",
    "C_set = np.array([process_scan(os.path.join(\"./image_folder/C\",path)) for path in C_folder[:350]])\n",
    "print(\"C set done.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "a947bf20-6386-4539-bd20-46b44191dfb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x train: (750, 128, 128, 64) | x val: (300, 128, 128, 64)\n",
      "y train: (750,) | y val: (300,)\n"
     ]
    }
   ],
   "source": [
    "# 2 == A_set and 1 == B_set and 0 == C_set\n",
    "A_set_labels = np.array([0 for _ in range(len(A_set))])\n",
    "B_set_labels = np.array([1 for _ in range(len(B_set))])\n",
    "C_set_labels = np.array([2 for _ in range(len(C_set))])\n",
    "\n",
    "x_train = np.concatenate((A_set[:250], B_set[:250], C_set[:250]),axis=0)\n",
    "y_train = np.concatenate((A_set_labels[:250], B_set_labels[:250], C_set_labels[:250]),axis=0)\n",
    "x_val = np.concatenate((A_set[250:], B_set[250:], C_set[250:]),axis=0)\n",
    "y_val = np.concatenate((A_set_labels[250:], B_set_labels[250:], C_set_labels[250:]),axis=0)\n",
    "\n",
    "print(f\"x train: {x_train.shape} | x val: {x_val.shape}\")\n",
    "print(f\"y train: {y_train.shape} | y val: {y_val.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "176de354-4099-4c5f-b08d-8b84f6e98240",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([750, 1, 64, 128, 128])\n"
     ]
    }
   ],
   "source": [
    "# turn x_train and y_train into a dataloader\n",
    "x_train = torch.tensor(x_train, dtype=torch.float32)\n",
    "x_train = np.transpose(x_train, (0,3,1,2))\n",
    "x_train = x_train.unsqueeze(1)\n",
    "print(x_train.shape)\n",
    "y_train = torch.tensor(y_train, dtype=torch.long)\n",
    "train_ds = TensorDataset(x_train, y_train)\n",
    "\n",
    "# turn x_val and y_val into a dataloader\n",
    "x_val = torch.tensor(x_val, dtype=torch.float32)\n",
    "x_val = np.transpose(x_val, (0,3,1,2))\n",
    "x_val = x_val.unsqueeze(1)\n",
    "y_val = torch.tensor(y_val, dtype=torch.long)\n",
    "val_ds = TensorDataset(x_val, y_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "411f2dc2-5b11-42f3-945e-99183da1f496",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'train_ds' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m train_dl \u001b[38;5;241m=\u001b[39m DataLoader(\u001b[43mtrain_ds\u001b[49m, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, shuffle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;66;03m#creates shape: (2, 64, 128, 128)\u001b[39;00m\n\u001b[1;32m      2\u001b[0m torch\u001b[38;5;241m.\u001b[39msave(train_dl, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_dl_ext_v2.pth\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      3\u001b[0m val_dl \u001b[38;5;241m=\u001b[39m DataLoader(val_ds, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, shuffle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'train_ds' is not defined"
     ]
    }
   ],
   "source": [
    "train_dl = DataLoader(train_ds, batch_size=2, shuffle=True) #creates shape: (2, 64, 128, 128)\n",
    "torch.save(train_dl, 'train_dl_ext_v2.pth')\n",
    "val_dl = DataLoader(val_ds, batch_size=2, shuffle=True)\n",
    "torch.save(val_dl, 'val_dl_ext_v2.pth')\n",
    "print(\"dl saved.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "248ff43c-05b0-4fe3-96bb-8b87c16af5d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "375 150\n"
     ]
    }
   ],
   "source": [
    "# load the saved dataloader\n",
    "# train_dataloader = DataLoader(my_dataset)\n",
    "# train_dataloader.load_state_dict(torch.load('train_dl.pth'))\n",
    "\n",
    "train_dl = torch.load('train_dl_ext_v2.pth')\n",
    "val_dl = torch.load('val_dl_ext_v2.pth')\n",
    "print(len(train_dl), len(val_dl))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b94743d0-81e4-4d8a-9f6d-ccfb7d6d4ac4",
   "metadata": {},
   "source": [
    "# 3D PyTorch Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0988a719-0636-4e96-ab94-de89efe6e757",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.3355, 0.3065, 0.3580],\n",
      "        [0.3335, 0.3087, 0.3578]], grad_fn=<SoftmaxBackward0>)\n",
      "\n",
      "\n",
      "torch.return_types.max(\n",
      "values=tensor([0.3580, 0.3578], grad_fn=<MaxBackward0>),\n",
      "indices=tensor([2, 2]))\n",
      "\n",
      "Output shape: torch.Size([2, 3])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "class Simple3DCNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Simple3DCNN, self).__init__()\n",
    "        \n",
    "        self.conv1 = nn.Conv3d(1, 32, kernel_size=3, padding=1)\n",
    "        self.pool1 = nn.MaxPool3d(2)\n",
    "        \n",
    "        self.conv2 = nn.Conv3d(32, 64, kernel_size=3, padding=1)\n",
    "        self.pool2 = nn.MaxPool3d(2)\n",
    "        \n",
    "        self.conv3 = nn.Conv3d(64, 128, kernel_size=3, padding=1)\n",
    "        self.pool3 = nn.MaxPool3d(2)\n",
    "        \n",
    "        self.fc1 = nn.Linear(128 * 2 * 32 * 32, 512)\n",
    "        self.fc2 = nn.Linear(512, 128)\n",
    "        \n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.dropout = nn.Dropout(.8)\n",
    "        \n",
    "        self.fc3 = nn.Linear(128, 3)\n",
    "        self.softmax = nn.Softmax(dim=1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.pool1(self.conv1(x))\n",
    "        x = self.pool2(self.relu(self.conv2(x)))\n",
    "        x = self.pool3(self.relu(self.conv3(x)))\n",
    "        \n",
    "        x = x.view(-1, 128 * 2 * 32 * 32)\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        \n",
    "        return self.softmax(x)\n",
    "\n",
    "# Create the network instance\n",
    "simple_3d_cnn = Simple3DCNN()\n",
    "\n",
    "# Create a random input tensor of size (2, 1, 5, 128, 128)\n",
    "input_tensor = torch.randn(2, 1, 64, 128, 128)\n",
    "\n",
    "# Forward pass through the network\n",
    "output = simple_3d_cnn(input_tensor)\n",
    "print(output)\n",
    "print()\n",
    "# print(output[0,1])\n",
    "print()\n",
    "pred = torch.max(output,1)\n",
    "print(pred)\n",
    "print()\n",
    "print(\"Output shape:\", output.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "faaebc4d-0553-45d2-988c-aa14e2865c76",
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_weights(model):\n",
    "    for m in model.modules():\n",
    "        if isinstance(m, (nn.Conv3d, nn.BatchNorm2d)):\n",
    "            nn.init.xavier_uniform_(m.weight.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c30f669c-218d-41c3-8990-1be3832f2b88",
   "metadata": {},
   "outputs": [],
   "source": [
    "def amp_fit(model, n_epochs):\n",
    "    # initialize the weights of the model\n",
    "    init_weights(model)\n",
    "    \n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optim = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
    "    scaler = torch.cuda.amp.GradScaler()\n",
    "    total_loss = 0\n",
    "    loss_items = []\n",
    "    \n",
    "    # linear learning rate decay setup\n",
    "    n_t_steps = len(train_dl) * n_epochs\n",
    "    n_w_steps = .1 * n_t_steps\n",
    "    scheduler = get_linear_schedule_with_warmup(optim, n_w_steps, n_t_steps)\n",
    "    \n",
    "    model.train()\n",
    "    for epoch in range(n_epochs):\n",
    "        \n",
    "        for step, (inputs, labels) in enumerate(train_dl): #inputs.shape =(2,5,128,128)\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "            with torch.cuda.amp.autocast():\n",
    "                output = model(inputs)\n",
    "                loss = criterion(output, labels)\n",
    "            \n",
    "            scaler.scale(loss).backward()\n",
    "            scaler.step(optim)\n",
    "            scaler.update()\n",
    "            scheduler.step()\n",
    "            \n",
    "            if (step+1)%len(train_dl) == 0:\n",
    "                loss_items.append(loss.item())\n",
    "                print(f\"epoch: {epoch+1} | step: {step+1}/{len(train_dl)} | loss: {loss.item():4f}\")\n",
    "                \n",
    "    return loss_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2af6edbc-5cb3-4661-9c9e-a9702e0cc500",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1 | step: 375/375 | loss: 0.862117\n",
      "epoch: 2 | step: 375/375 | loss: 0.880895\n",
      "epoch: 3 | step: 375/375 | loss: 0.870207\n",
      "epoch: 4 | step: 375/375 | loss: 0.895141\n",
      "epoch: 5 | step: 375/375 | loss: 0.870365\n",
      "epoch: 6 | step: 375/375 | loss: 1.131137\n",
      "epoch: 7 | step: 375/375 | loss: 0.805357\n",
      "epoch: 8 | step: 375/375 | loss: 0.837643\n",
      "epoch: 9 | step: 375/375 | loss: 0.997870\n",
      "epoch: 10 | step: 375/375 | loss: 0.999548\n",
      "epoch: 11 | step: 375/375 | loss: 0.890131\n",
      "epoch: 12 | step: 375/375 | loss: 0.751628\n",
      "epoch: 13 | step: 375/375 | loss: 0.729746\n",
      "epoch: 14 | step: 375/375 | loss: 0.888280\n",
      "epoch: 15 | step: 375/375 | loss: 0.860480\n",
      "epoch: 16 | step: 375/375 | loss: 0.959564\n",
      "epoch: 17 | step: 375/375 | loss: 0.997441\n",
      "epoch: 18 | step: 375/375 | loss: 0.691168\n",
      "epoch: 19 | step: 375/375 | loss: 1.017558\n",
      "epoch: 20 | step: 375/375 | loss: 0.755588\n"
     ]
    }
   ],
   "source": [
    "model = Simple3DCNN()\n",
    "model.to(device)\n",
    "model_loss = amp_fit(model,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8863f279-d684-4eaa-8934-6fb0599b0971",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(model_loss, color=\"blue\", label=\"model two\")\n",
    "\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training loss over Epochs')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e4fefb71-1c66-4ce9-b75f-70f635505ad5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.0740, 0.7281, 0.1979],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.2353, 0.6569, 0.1079],\n",
      "        [0.0646, 0.6800, 0.2554]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.5986, 0.3503, 0.0511],\n",
      "        [0.0811, 0.4022, 0.5167]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0721, 0.7651, 0.1627],\n",
      "        [0.0701, 0.3828, 0.5471]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0641, 0.8061, 0.1298],\n",
      "        [0.5972, 0.3456, 0.0572]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.0750, 0.5178, 0.4072],\n",
      "        [0.0701, 0.3830, 0.5470]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.5734, 0.3647, 0.0619],\n",
      "        [0.0722, 0.8227, 0.1051]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.4647, 0.4560, 0.0793],\n",
      "        [0.0729, 0.6232, 0.3038]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.4856, 0.4581, 0.0563],\n",
      "        [0.0703, 0.4239, 0.5058]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.5286, 0.4051, 0.0664],\n",
      "        [0.0751, 0.8332, 0.0916]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0701, 0.3831, 0.5467],\n",
      "        [0.6652, 0.2646, 0.0702]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3831, 0.5468],\n",
      "        [0.0858, 0.4948, 0.4193]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.4420, 0.4925, 0.0655],\n",
      "        [0.6122, 0.3379, 0.0499]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0653, 0.8210, 0.1137],\n",
      "        [0.0861, 0.4714, 0.4425]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0663, 0.4491, 0.4846],\n",
      "        [0.0701, 0.3827, 0.5472]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0662, 0.7948, 0.1390],\n",
      "        [0.0672, 0.8288, 0.1039]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0658, 0.7649, 0.1692],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0701, 0.3829, 0.5471],\n",
      "        [0.0701, 0.3829, 0.5470]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.6771, 0.2756, 0.0473],\n",
      "        [0.0724, 0.8335, 0.0941]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0701, 0.3830, 0.5469],\n",
      "        [0.0701, 0.3828, 0.5471]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.6286, 0.3291, 0.0423],\n",
      "        [0.5171, 0.4170, 0.0660]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0672, 0.4281, 0.5046],\n",
      "        [0.0701, 0.3829, 0.5470]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0701, 0.3830, 0.5469],\n",
      "        [0.0771, 0.4596, 0.4633]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0701, 0.3828, 0.5471],\n",
      "        [0.5015, 0.4253, 0.0732]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3829, 0.5470],\n",
      "        [0.5651, 0.3678, 0.0671]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0616, 0.6996, 0.2388],\n",
      "        [0.0827, 0.8040, 0.1134]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.5933, 0.3415, 0.0653],\n",
      "        [0.0735, 0.4705, 0.4560]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.4490, 0.4616, 0.0895],\n",
      "        [0.0685, 0.4048, 0.5267]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0613, 0.6956, 0.2431],\n",
      "        [0.0686, 0.7933, 0.1381]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0687, 0.7282, 0.2031],\n",
      "        [0.0638, 0.6826, 0.2536]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.5301, 0.3731, 0.0968],\n",
      "        [0.0798, 0.5094, 0.4108]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.4405, 0.4870, 0.0724],\n",
      "        [0.0689, 0.4389, 0.4922]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.6425, 0.3102, 0.0473],\n",
      "        [0.0827, 0.5218, 0.3955]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0701, 0.8067, 0.1232],\n",
      "        [0.0736, 0.8096, 0.1168]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.4458, 0.4817, 0.0725],\n",
      "        [0.1081, 0.4773, 0.4145]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.5983, 0.3556, 0.0461],\n",
      "        [0.0610, 0.5949, 0.3442]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0702, 0.4757, 0.4541],\n",
      "        [0.0754, 0.5385, 0.3861]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.5846, 0.3611, 0.0543],\n",
      "        [0.0701, 0.3829, 0.5471]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0651, 0.8025, 0.1323],\n",
      "        [0.0784, 0.7775, 0.1441]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0660, 0.6367, 0.2973],\n",
      "        [0.1411, 0.7645, 0.0944]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.5714, 0.3671, 0.0615],\n",
      "        [0.0609, 0.4656, 0.4735]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.5771, 0.3655, 0.0574],\n",
      "        [0.0658, 0.7744, 0.1598]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0660, 0.7919, 0.1421],\n",
      "        [0.0739, 0.3900, 0.5361]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.6543, 0.2982, 0.0475],\n",
      "        [0.0715, 0.4604, 0.4681]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0796, 0.8034, 0.1170],\n",
      "        [0.0893, 0.4497, 0.4609]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0669, 0.4343, 0.4989],\n",
      "        [0.4824, 0.4284, 0.0892]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0749, 0.8128, 0.1123],\n",
      "        [0.0701, 0.8026, 0.1273]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0701, 0.3827, 0.5472],\n",
      "        [0.0670, 0.6711, 0.2619]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.4193, 0.5040, 0.0767],\n",
      "        [0.4351, 0.4878, 0.0771]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.5750, 0.3706, 0.0543],\n",
      "        [0.1017, 0.7649, 0.1334]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0722, 0.4340, 0.4938],\n",
      "        [0.0815, 0.7956, 0.1229]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.5048, 0.4270, 0.0682],\n",
      "        [0.3663, 0.5206, 0.1131]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3828, 0.5471],\n",
      "        [0.0701, 0.3828, 0.5471]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0698, 0.4075, 0.5227],\n",
      "        [0.4930, 0.4341, 0.0729]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0675, 0.7849, 0.1476],\n",
      "        [0.0704, 0.4520, 0.4776]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.4768, 0.4377, 0.0854],\n",
      "        [0.0678, 0.4640, 0.4682]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.6325, 0.3155, 0.0519],\n",
      "        [0.0689, 0.8190, 0.1120]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0764, 0.4067, 0.5170],\n",
      "        [0.6492, 0.3040, 0.0469]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0711, 0.7619, 0.1670],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0889, 0.4863, 0.4248],\n",
      "        [0.0701, 0.3829, 0.5470]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0885, 0.4198, 0.4917],\n",
      "        [0.0618, 0.5449, 0.3933]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0902, 0.4802, 0.4296],\n",
      "        [0.0825, 0.4361, 0.4815]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.4621, 0.4697, 0.0682],\n",
      "        [0.0710, 0.4303, 0.4987]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.6428, 0.3123, 0.0449],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.3855, 0.4896, 0.1250],\n",
      "        [0.6932, 0.2607, 0.0461]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3831, 0.5468],\n",
      "        [0.1001, 0.7673, 0.1325]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0662, 0.8126, 0.1212],\n",
      "        [0.0647, 0.7938, 0.1415]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.3824, 0.5390, 0.0786],\n",
      "        [0.6376, 0.2914, 0.0710]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.4961, 0.4407, 0.0632],\n",
      "        [0.4478, 0.4720, 0.0802]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.3576, 0.5557, 0.0867],\n",
      "        [0.0631, 0.6181, 0.3188]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0707, 0.4061, 0.5232],\n",
      "        [0.0680, 0.4294, 0.5026]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.5116, 0.4315, 0.0569],\n",
      "        [0.0644, 0.7239, 0.2117]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0670, 0.8260, 0.1070],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0683, 0.5069, 0.4248],\n",
      "        [0.0894, 0.5323, 0.3783]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0721, 0.4459, 0.4819],\n",
      "        [0.0818, 0.7654, 0.1528]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0623, 0.4018, 0.5359],\n",
      "        [0.0701, 0.3829, 0.5470]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0696, 0.4702, 0.4601],\n",
      "        [0.4145, 0.4925, 0.0931]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0679, 0.8097, 0.1224],\n",
      "        [0.5349, 0.3962, 0.0689]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.0775, 0.8024, 0.1201],\n",
      "        [0.0632, 0.7719, 0.1649]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0656, 0.7716, 0.1628],\n",
      "        [0.0599, 0.3922, 0.5479]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.5346, 0.4008, 0.0646],\n",
      "        [0.4699, 0.4531, 0.0770]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.4693, 0.4605, 0.0702],\n",
      "        [0.0671, 0.7728, 0.1601]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.6157, 0.3333, 0.0510],\n",
      "        [0.4810, 0.4426, 0.0764]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.1702, 0.6274, 0.2024],\n",
      "        [0.0612, 0.5976, 0.3412]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0691, 0.7897, 0.1412],\n",
      "        [0.3744, 0.5373, 0.0883]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.6040, 0.3365, 0.0595],\n",
      "        [0.0649, 0.8036, 0.1316]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0946, 0.4222, 0.4832],\n",
      "        [0.0702, 0.4869, 0.4429]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0671, 0.8324, 0.1005],\n",
      "        [0.0825, 0.7707, 0.1469]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0681, 0.4880, 0.4439],\n",
      "        [0.5425, 0.3895, 0.0680]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0695, 0.8216, 0.1089],\n",
      "        [0.4902, 0.4350, 0.0748]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.5629, 0.3710, 0.0661],\n",
      "        [0.4318, 0.4969, 0.0713]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3830, 0.5469],\n",
      "        [0.0664, 0.7940, 0.1396]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.5630, 0.3639, 0.0731],\n",
      "        [0.5718, 0.3697, 0.0585]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0689, 0.4933, 0.4378],\n",
      "        [0.4914, 0.4214, 0.0872]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0634, 0.8016, 0.1350],\n",
      "        [0.0695, 0.8263, 0.1042]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.6095, 0.3352, 0.0553],\n",
      "        [0.0604, 0.6785, 0.2611]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0738, 0.8040, 0.1222],\n",
      "        [0.0819, 0.8019, 0.1162]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.2620, 0.6388, 0.0992],\n",
      "        [0.0827, 0.7431, 0.1742]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.1090, 0.7819, 0.1090],\n",
      "        [0.0630, 0.3915, 0.5455]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.6627, 0.2902, 0.0471],\n",
      "        [0.0630, 0.7561, 0.1810]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.2344, 0.6844, 0.0811],\n",
      "        [0.0730, 0.4394, 0.4876]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.4473, 0.4785, 0.0742],\n",
      "        [0.6187, 0.3247, 0.0566]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0632, 0.7462, 0.1906],\n",
      "        [0.0670, 0.7761, 0.1569]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.1290, 0.4990, 0.3720],\n",
      "        [0.3492, 0.5751, 0.0758]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.1111, 0.4984, 0.3905],\n",
      "        [0.0768, 0.7590, 0.1642]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0720, 0.8362, 0.0918],\n",
      "        [0.5561, 0.3631, 0.0809]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.4879, 0.4346, 0.0774],\n",
      "        [0.4862, 0.4506, 0.0632]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0707, 0.4246, 0.5048],\n",
      "        [0.0715, 0.4021, 0.5265]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0784, 0.4380, 0.4835],\n",
      "        [0.0542, 0.3901, 0.5557]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0697, 0.4661, 0.4642],\n",
      "        [0.5879, 0.3404, 0.0717]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3828, 0.5471],\n",
      "        [0.6456, 0.3155, 0.0389]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.1331, 0.7633, 0.1036],\n",
      "        [0.0695, 0.8240, 0.1065]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.5590, 0.3845, 0.0565],\n",
      "        [0.4748, 0.4556, 0.0696]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0701, 0.3832, 0.5467],\n",
      "        [0.5381, 0.3817, 0.0802]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0677, 0.7832, 0.1492],\n",
      "        [0.0713, 0.4546, 0.4741]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0648, 0.7895, 0.1457],\n",
      "        [0.0702, 0.4754, 0.4544]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0701, 0.3829, 0.5470],\n",
      "        [0.0722, 0.7746, 0.1532]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.4939, 0.4193, 0.0868],\n",
      "        [0.0724, 0.4096, 0.5180]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0657, 0.8035, 0.1308],\n",
      "        [0.0633, 0.6467, 0.2900]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0899, 0.8083, 0.1018],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.4945, 0.4335, 0.0719],\n",
      "        [0.0880, 0.4916, 0.4204]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0708, 0.4047, 0.5245],\n",
      "        [0.0777, 0.7764, 0.1459]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0769, 0.8416, 0.0815],\n",
      "        [0.7319, 0.2336, 0.0345]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.0839, 0.4501, 0.4660],\n",
      "        [0.4751, 0.4504, 0.0745]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0790, 0.4939, 0.4271],\n",
      "        [0.7322, 0.2347, 0.0331]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.5767, 0.3637, 0.0596],\n",
      "        [0.0732, 0.3912, 0.5356]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0696, 0.8367, 0.0937],\n",
      "        [0.0654, 0.7293, 0.2053]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.6407, 0.3053, 0.0540],\n",
      "        [0.0665, 0.7855, 0.1480]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 1], device='cuda:0')\n",
      "tensor([[0.0678, 0.4496, 0.4825],\n",
      "        [0.0723, 0.7847, 0.1429]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0653, 0.7561, 0.1786],\n",
      "        [0.0677, 0.8122, 0.1201]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.0665, 0.7887, 0.1448],\n",
      "        [0.2674, 0.6134, 0.1192]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.1095, 0.7910, 0.0996],\n",
      "        [0.0685, 0.3995, 0.5320]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0700, 0.8264, 0.1037],\n",
      "        [0.0690, 0.4600, 0.4710]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.4411, 0.4807, 0.0783],\n",
      "        [0.0683, 0.4148, 0.5170]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0793, 0.6256, 0.2951],\n",
      "        [0.5175, 0.4183, 0.0642]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.0681, 0.4533, 0.4785],\n",
      "        [0.0701, 0.3830, 0.5469]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 2], device='cuda:0') | tensor([2, 2], device='cuda:0')\n",
      "tensor([[0.0701, 0.3827, 0.5472],\n",
      "        [0.4782, 0.4593, 0.0626]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.0667, 0.7660, 0.1673],\n",
      "        [0.0733, 0.4068, 0.5199]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 2], device='cuda:0')\n",
      "tensor([[0.0688, 0.8211, 0.1102],\n",
      "        [0.0714, 0.4329, 0.4957]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.3908, 0.5392, 0.0699],\n",
      "        [0.0698, 0.4284, 0.5019]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 2], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0683, 0.8088, 0.1229],\n",
      "        [0.4466, 0.4705, 0.0829]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 0], device='cuda:0')\n",
      "tensor([[0.5666, 0.3820, 0.0514],\n",
      "        [0.4103, 0.4887, 0.1010]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0642, 0.7923, 0.1435],\n",
      "        [0.1099, 0.8012, 0.0888]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.5865, 0.3612, 0.0523],\n",
      "        [0.0729, 0.4680, 0.4591]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 1], device='cuda:0') | tensor([0, 2], device='cuda:0')\n",
      "tensor([[0.0642, 0.8255, 0.1103],\n",
      "        [0.0638, 0.5757, 0.3605]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([1, 1], device='cuda:0')\n",
      "tensor([[0.4105, 0.5125, 0.0770],\n",
      "        [0.4970, 0.4154, 0.0876]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.0851, 0.5139, 0.4009],\n",
      "        [0.1036, 0.7740, 0.1223]], device='cuda:0')\n",
      "predicted | actual: tensor([1, 1], device='cuda:0') | tensor([2, 1], device='cuda:0')\n",
      "tensor([[0.0771, 0.4524, 0.4705],\n",
      "        [0.6344, 0.3102, 0.0553]], device='cuda:0')\n",
      "predicted | actual: tensor([2, 0], device='cuda:0') | tensor([2, 0], device='cuda:0')\n",
      "tensor([[0.5190, 0.4035, 0.0775],\n",
      "        [0.7329, 0.2303, 0.0368]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "tensor([[0.4851, 0.4559, 0.0590],\n",
      "        [0.5825, 0.3445, 0.0730]], device='cuda:0')\n",
      "predicted | actual: tensor([0, 0], device='cuda:0') | tensor([0, 0], device='cuda:0')\n",
      "Accuracy: 82.66666666666667%\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for data in val_dl:\n",
    "        inp, val_outp = data\n",
    "        inp, val_outp = inp.cuda(), val_outp.cuda()\n",
    "        out = model(inp)\n",
    "        # shape (batch, 3)\n",
    "        \n",
    "        # print(out)\n",
    "        _, pred = torch.max(out.data,1)\n",
    "        print(out.data)\n",
    "        \n",
    "        total += val_outp.size(0)\n",
    "        print(f\"predicted | actual: {pred} | {val_outp}\")\n",
    "        correct += (pred == val_outp).sum().item()\n",
    "        \n",
    "print(f'Accuracy: {100*(correct/total)}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "81759dca-a3b9-4616-9cd0-0db357400a7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model, \"modelv3.pth\")"
   ]
  }
 ],
 "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}