moderno_cpu.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Copying files: 58 files [00:00, 553.84 files/s]\n"
     ]
    }
   ],
   "source": [
    "# 224x336\n",
    "\n",
    "import splitfolders\n",
    "splitfolders.ratio('cpu', output=\"cpu_slpitted\", seed=1337, ratio=(0.6, 0.2, 0.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import os\n",
    "import torch\n",
    "from torchvision import datasets\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_transform = transforms.Compose([\n",
    "        transforms.Resize((224,336)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "\n",
    "transform = transforms.Compose([\n",
    "        transforms.Resize((224,336)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantidade de classes: 2\n",
      "Nome das classes: \n",
      "['cpu_NOK', 'cpu_OK']\n"
     ]
    }
   ],
   "source": [
    "data_dir = 'cpu_slpitted'\n",
    "\n",
    "train_dataset = datasets.ImageFolder(os.path.join(data_dir + \"/train\"), transform=train_transform)\n",
    "val_dataset = datasets.ImageFolder(os.path.join(data_dir + \"/val\"), transform=transform)\n",
    "test_dataset = datasets.ImageFolder(os.path.join(data_dir + \"/test\"), transform=transform)\n",
    "\n",
    "train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=2, shuffle=True)\n",
    "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "num_classes = len(train_dataset.classes)\n",
    "class_names = train_dataset.classes\n",
    "\n",
    "print(f'Quantidade de classes: {num_classes}')\n",
    "print(f'Nome das classes: \\n{class_names}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ResNet(\n",
      "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
      "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (relu): ReLU(inplace=True)\n",
      "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "  (layer1): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (layer2): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (layer3): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (layer4): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
      "  (fc): Linear(in_features=512, out_features=2, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from torchvision import models\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "\n",
    "device = torch.device('cpu')\n",
    "\n",
    "model = models.resnet18(pretrained=True)\n",
    "model.fc = nn.Linear(in_features=512, out_features=num_classes, bias=True)\n",
    "print(model)\n",
    "\n",
    "model.to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=3e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "import copy\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def plot_losses(train_losses, valid_losses):\n",
    "    '''\n",
    "    Function for plotting training and validation losses\n",
    "    '''\n",
    "    \n",
    "    plt.style.use('seaborn')\n",
    "\n",
    "    train_losses = np.array(train_losses) \n",
    "    valid_losses = np.array(valid_losses)\n",
    "\n",
    "    fig, ax = plt.subplots(figsize = (8, 4.5))\n",
    "\n",
    "    ax.plot(train_losses, color='blue', label='Training loss') \n",
    "    ax.plot(valid_losses, color='red', label='Validation loss')\n",
    "    ax.set(title=\"Loss over epochs\", \n",
    "            xlabel='Epoch',\n",
    "            ylabel='Loss') \n",
    "    ax.legend()\n",
    "    \n",
    "def get_accuracy(model, data_loader, device):\n",
    "    correct_pred = 0 \n",
    "    n = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        for inputs, labels in data_loader:\n",
    "\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            output_prob = model(inputs)\n",
    "            _, predicted_labels = torch.max(output_prob, 1)\n",
    "\n",
    "            n += labels.size(0) # add batch_size num of samples being iterated\n",
    "            correct_pred += (predicted_labels == labels).sum() # sum array of bools (1's are correct predictions)\n",
    "\n",
    "    return correct_pred.float() / n\n",
    "\n",
    "def train(train_loader, model, criterion, optimizer, device):\n",
    "    model.train()\n",
    "    running_loss = 0\n",
    "    \n",
    "    for inputs, labels in train_loader:\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "    \n",
    "        # Forward pass\n",
    "        outputs = model(inputs) \n",
    "        loss = criterion(outputs, labels) \n",
    "        running_loss += loss.item() * inputs.size(0)\n",
    "\n",
    "        # Backward pass\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    epoch_loss = running_loss / len(train_loader.dataset)\n",
    "    return model, optimizer, epoch_loss\n",
    "\n",
    "def val(val_loader, model, criterion, device):\n",
    "  \n",
    "    model.eval()\n",
    "    running_loss = 0\n",
    "    \n",
    "    for inputs, labels in val_loader:\n",
    "    \n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # Forward pass and record loss\n",
    "        with torch.no_grad():\n",
    "            outputs = model(inputs) \n",
    "            loss = criterion(outputs, labels) \n",
    "            running_loss += loss.item() * inputs.size(0)\n",
    "\n",
    "    epoch_loss = running_loss / len(val_loader.dataset)\n",
    "        \n",
    "    return model, epoch_loss\n",
    "\n",
    "\n",
    "def training_loop(model, criterion, optimizer, train_loader, valid_loader, test_dataloader, epoches, device, print_every=1):\n",
    "    '''\n",
    "    Function defining the entire training loop\n",
    "    '''\n",
    "    # set objects for storing metrics\n",
    "    best_acc = 0.0\n",
    "    best_loss = 1e10\n",
    "    train_losses = []\n",
    "    valid_losses = []\n",
    "\n",
    "    # Train model and validate\n",
    "    for epoch in range(epoches):\n",
    "\n",
    "        # training\n",
    "        model, optimizer, train_loss = train(train_loader, model, criterion, optimizer, device)\n",
    "        train_losses.append(train_loss)\n",
    "\n",
    "        # validation\n",
    "        with torch.no_grad():\n",
    "            model, valid_loss = val(valid_loader, model, criterion, device)\n",
    "            valid_losses.append(valid_loss)\n",
    "\n",
    "        # accuracies\n",
    "        if epoch % print_every == (print_every - 1):\n",
    "            \n",
    "            train_acc = get_accuracy(model, train_loader, device=device)\n",
    "            valid_acc = get_accuracy(model, valid_loader, device=device)\n",
    "            test_acc = get_accuracy(model, test_dataloader, device=device)\n",
    "            \n",
    "            print(f'{datetime.now().time().replace(microsecond=0)} --- '\n",
    "                    f'Epoch: {epoch}\\t'\n",
    "                    f'Train loss: {train_loss:.4f}\\t'\n",
    "                    f'Valid loss: {valid_loss:.4f}\\t'\n",
    "                    f'Train accuracy: {100 * train_acc:.2f}\\t'\n",
    "                    f'Val accuracy: {100 * valid_acc:.2f}\\t'\n",
    "                    f'Test accuracy: {100 * test_acc:.2f}')\n",
    "\n",
    "        # create a copy of our model when it test its best\n",
    "        if test_acc >= best_acc:\n",
    "            best_acc = test_acc\n",
    "            best_model_wts = copy.deepcopy(model.state_dict())\n",
    "        \n",
    "    plot_losses(train_losses, valid_losses)\n",
    "    print('Best test Acc: {:4f}'.format(best_acc))\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:01:58 --- Epoch: 0\tTrain loss: 0.7241\tValid loss: 0.3592\tTrain accuracy: 100.00\tVal accuracy: 80.00\tTest accuracy: 100.00\n",
      "12:02:07 --- Epoch: 1\tTrain loss: 0.8406\tValid loss: 1.3963\tTrain accuracy: 82.35\tVal accuracy: 50.00\tTest accuracy: 71.43\n",
      "12:02:16 --- Epoch: 2\tTrain loss: 0.5769\tValid loss: 0.3671\tTrain accuracy: 94.12\tVal accuracy: 90.00\tTest accuracy: 78.57\n",
      "12:02:25 --- Epoch: 3\tTrain loss: 0.2135\tValid loss: 0.3185\tTrain accuracy: 100.00\tVal accuracy: 80.00\tTest accuracy: 85.71\n",
      "12:02:34 --- Epoch: 4\tTrain loss: 0.3685\tValid loss: 0.1918\tTrain accuracy: 94.12\tVal accuracy: 90.00\tTest accuracy: 71.43\n",
      "12:02:43 --- Epoch: 5\tTrain loss: 0.1653\tValid loss: 0.2519\tTrain accuracy: 100.00\tVal accuracy: 90.00\tTest accuracy: 92.86\n",
      "12:02:54 --- Epoch: 6\tTrain loss: 0.1850\tValid loss: 0.1810\tTrain accuracy: 100.00\tVal accuracy: 90.00\tTest accuracy: 85.71\n",
      "12:03:03 --- Epoch: 7\tTrain loss: 0.2638\tValid loss: 0.1979\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 85.71\n",
      "12:03:12 --- Epoch: 8\tTrain loss: 0.1703\tValid loss: 0.2750\tTrain accuracy: 100.00\tVal accuracy: 80.00\tTest accuracy: 78.57\n",
      "12:03:21 --- Epoch: 9\tTrain loss: 0.1241\tValid loss: 0.1326\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "12:03:30 --- Epoch: 10\tTrain loss: 0.0879\tValid loss: 0.1768\tTrain accuracy: 100.00\tVal accuracy: 90.00\tTest accuracy: 92.86\n",
      "12:03:39 --- Epoch: 11\tTrain loss: 0.0511\tValid loss: 0.1473\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 92.86\n",
      "12:03:47 --- Epoch: 12\tTrain loss: 0.0568\tValid loss: 0.0852\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 92.86\n",
      "12:03:56 --- Epoch: 13\tTrain loss: 0.0369\tValid loss: 0.0641\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "12:04:05 --- Epoch: 14\tTrain loss: 0.0341\tValid loss: 0.0665\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "12:04:15 --- Epoch: 15\tTrain loss: 0.0200\tValid loss: 0.0695\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "12:04:24 --- Epoch: 16\tTrain loss: 0.0314\tValid loss: 0.0987\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 92.86\n",
      "12:04:33 --- Epoch: 17\tTrain loss: 0.0201\tValid loss: 0.0906\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 92.86\n",
      "12:04:42 --- Epoch: 18\tTrain loss: 0.0221\tValid loss: 0.0919\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 92.86\n",
      "12:04:51 --- Epoch: 19\tTrain loss: 0.0161\tValid loss: 0.0826\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 92.86\n",
      "Best val Acc: 1.000000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x324 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = training_loop(model=model, \n",
    "    criterion=criterion, \n",
    "    optimizer=optimizer, \n",
    "    train_loader=train_dataloader, \n",
    "    valid_loader=val_dataloader, \n",
    "    test_dataloader=test_dataloader,\n",
    "    epoches=20, \n",
    "    device=device, \n",
    "    print_every=1\n",
    ")\n",
    "\n",
    "torch.save(model.state_dict(), \"cpu_classificacao.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "41f14c764d27c962d5d4530fd3a129dfbfc6c63683c24b6097e69cef7d6a7dc1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}