LogReg.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMeFdJTj2TEejtv6BRgxWjB",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ethanarsht/detective-dogs/blob/main/LogReg.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "B0Kl0uxZ7SMf"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision.transforms as T\n",
        "from torchvision.datasets import ImageFolder\n",
        "import os\n",
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "mydrive = \"/content/drive/MyDrive/Pneumonia_Detective_Dogs\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "osPwHx1q7WPZ",
        "outputId": "9b7fa4c8-bd7f-4da6-913f-7e8c555cc919"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class CustomImageDataset(Dataset):\n",
        "    def __init__(self, csv_file, img_dir_path, transform=None):\n",
        "        self.img_labels = pd.read_csv(csv_file)\n",
        "        self.img_dir = img_dir_path\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.img_labels)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])\n",
        "        image = Image.open(img_path).convert('RGB')\n",
        "        label_str = self.img_labels.iloc[idx, 1]\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "        label = 0 if label_str == \"NORMAL\" else 1\n",
        "        return image, torch.tensor(label)\n",
        "\n",
        "transforms = T.Compose([\n",
        "    T.Resize((128, 128)),\n",
        "    T.ToTensor(),\n",
        "    T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n",
        "])\n",
        "\n",
        "training_data = CustomImageDataset('/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/train/train.csv',\n",
        "                                   '/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/train/train_images',\n",
        "                                   transforms)\n",
        "val_data = CustomImageDataset('/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/val/val.csv',\n",
        "                              '/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/val/val_images',\n",
        "                               transforms)\n",
        "test_data = CustomImageDataset('/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/test/test.csv',\n",
        "                              '/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/test/test_images',\n",
        "                               transforms)\n",
        "\n",
        "train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)\n",
        "val_dataloader = DataLoader(val_data, batch_size=64, shuffle=True)\n",
        "test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)\n",
        "\n",
        "input_size = 128 * 128 * 3\n",
        "num_classes = 2\n",
        "\n"
      ],
      "metadata": {
        "id": "YNF8qHmv7YbY"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Logistic regression model\n",
        "model = nn.Linear(input_size, num_classes)\n",
        "\n",
        "class PneumoniaModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.linear = nn.Linear(input_size, num_classes)\n",
        "        \n",
        "    def forward(self, xb):\n",
        "        xb = xb.view(-1, input_size)\n",
        "        out = self.linear(xb)\n",
        "        return out\n",
        "\n",
        "loss_fn = F.cross_entropy\n",
        "\n",
        "def fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):\n",
        "    optimizer = opt_func(model.parameters(), lr=lr)\n",
        "    history = []\n",
        "    \n",
        "    for epoch in range(epochs):\n",
        "        for batch in train_loader:\n",
        "            images, labels = batch\n",
        "            images = images.view(images.size(0), -1)\n",
        "            outputs = model(images)\n",
        "            loss = loss_fn(outputs, labels)\n",
        "            \n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "        \n",
        "        result = evaluate(model, val_loader)\n",
        "        history.append(result)\n",
        "    \n",
        "    return history\n",
        "\n",
        "def evaluate(model, val_loader):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    \n",
        "    with torch.no_grad():\n",
        "        for batch in val_loader:\n",
        "            images, labels = batch\n",
        "            images = images.view(images.size(0), -1)  # Reshape images\n",
        "            outputs = model(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "\n",
        "    accuracy = correct / total\n",
        "    return accuracy\n",
        "\n",
        "\n",
        "def predict_image(img, model):\n",
        "    xb = img.unsqueeze(0)\n",
        "    yb = model(xb)\n",
        "    _, preds = torch.max(yb, dim=1)\n",
        "    return preds[0].item()\n",
        "\n",
        "test_dataset = ImageFolder('/content/drive/MyDrive/Pneumonia_Detective_Dogs/pneumonia_images/test', transform=transforms)\n",
        "test_loader = DataLoader(test_dataset, batch_size=256)\n",
        "result = evaluate(model, test_loader)\n",
        "result"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8EHaNxrm7ZS5",
        "outputId": "8f27ad7b-ada9-4a79-e49c-e6413c0ebba2"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.27323717948717946"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import f1_score\n",
        "\n",
        "def evaluate(model, data_loader):\n",
        "    model.eval()\n",
        "    targets = []\n",
        "    predictions = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for images, labels in data_loader:\n",
        "            images = images.view(images.size(0), -1)\n",
        "            outputs = model(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "\n",
        "            targets.extend(labels.tolist())\n",
        "            predictions.extend(predicted.tolist())\n",
        "\n",
        "    f1 = f1_score(targets, predictions, average='macro')\n",
        "    return f1\n",
        "\n",
        "\n",
        "result = evaluate(model, test_loader)\n",
        "result"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9QNVaHApK1gP",
        "outputId": "4bac72b2-6c81-42d5-9976-121b9aa6071e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.23489536007384648"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    }
  ]
}