Glaucoma_Manuscript_Gopal_Open_Source.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Glaucoma Manuscript - Gopal Open Source.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOanr1Cszl6ObCkZPK0ccKr",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JayRGopal/CRAFT-pytorch/blob/master/Glaucoma_Manuscript_Gopal_Open_Source.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1qrjcKn5lKMY"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import glob\n",
        "from scipy.misc import *"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EfZjfqp4lRs7"
      },
      "source": [
        "from skimage.util import view_as_blocks, view_as_windows, montage\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from numpy.random import randint\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.optim import lr_scheduler\n",
        "import torchvision\n",
        "from torchvision import datasets, transforms\n",
        "import time\n",
        "import os\n",
        "import copy\n",
        "import torch\n",
        "from torch import tensor \n",
        "from torch.autograd import Variable\n",
        "from torch import randn, matmul\n",
        "import matplotlib.pyplot as plt\n",
        "from progressbar import progressbar\n",
        "from google.colab import files\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "from torchvision.models import *\n",
        "from PIL import Image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rsNrEaYUlSth"
      },
      "source": [
        "def plot(x):\n",
        "    fig, ax = plt.subplots()\n",
        "    im = ax.imshow(x)\n",
        "    ax.axis('off')\n",
        "    fig.set_size_inches(8, 8)\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JtGZttm8lT8x"
      },
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5zIu2HCxlVVN"
      },
      "source": [
        "from google.colab import drive\n",
        "\n",
        "drive.mount('/content/drive', force_remount=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TacdWWqSlWjm"
      },
      "source": [
        "def read_ims(directory, imsz):\n",
        "\n",
        "\n",
        "    main_dir = os.getcwd()\n",
        "    os.chdir(directory)\n",
        "\n",
        "    num_channels = 3  # remove\n",
        "\n",
        "    num_ims = sum([len(files) for (r, d, files) in os.walk(directory)])\n",
        "\n",
        "\n",
        "    imgs = np.zeros([num_ims, imsz, imsz, num_channels])\n",
        "\n",
        "    im_num = 0\n",
        "    class_num = 0\n",
        "\n",
        "\n",
        "\n",
        "    for filename in sorted(os.listdir(os.getcwd())):\n",
        "        print(filename)\n",
        "        im = Image.open(filename)\n",
        "        im = np.array(im.resize((imsz, imsz)))\n",
        "\n",
        "\n",
        "        imgs[im_num, :, :, :] = im\n",
        "\n",
        "\n",
        "\n",
        "        im_num += 1\n",
        "    os.chdir(directory)\n",
        "    os.chdir(main_dir)\n",
        "    return (imgs)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OqFTquIOlaMG"
      },
      "source": [
        "!pwd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uxk5uwghlatT"
      },
      "source": [
        "path = '/content/drive/My Drive/OpticsAI/GlaucomaRetinalData/Images'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "90FWxrJRlcJQ"
      },
      "source": [
        "imsz = 227"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A96RrBtLlePo"
      },
      "source": [
        "X = read_ims(path, imsz)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GV65lzxTlfeF"
      },
      "source": [
        "X = X /255"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VRa3VEl0lg5_"
      },
      "source": [
        "Y = np.zeros((X.shape[0],4))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kICRIIwMliv0"
      },
      "source": [
        "import csv\n",
        "index = 0  \n",
        "with open('/content/drive/My Drive/OpticsAI/GlaucomaRetinalData/GlaucomaDataSuspectCSV.csv') as csv_file:\n",
        "    csv_reader = csv.reader(csv_file, delimiter=',')\n",
        "    line_count = 0\n",
        "    for row in csv_reader:\n",
        "        if line_count == 0:\n",
        "            print(f'Column names are {\", \".join(row)}')\n",
        "            line_count += 1\n",
        "        else:\n",
        "            line_count += 1\n",
        "            if(index < Y.shape[0]):\n",
        "              Y[index, int(row[1])] = 1\n",
        "            index+=1\n",
        "    print(f'Processed {line_count} lines.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "40ezXN71lksE"
      },
      "source": [
        "r = np.random.permutation(X.shape[0])\n",
        "X = X[r,:,:,:]\n",
        "Y = Y[r,:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7X11tiaElmeR"
      },
      "source": [
        "X_train = X[0:int(0.8*X.shape[0])]\n",
        "X_val = X[int(0.8*X.shape[0]):X.shape[0]] \n",
        "\n",
        "Y_train = Y[0:int(0.8*Y.shape[0])]\n",
        "Y_val = Y[int(0.8*Y.shape[0]):Y.shape[0]] "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B-V72aKZlnf1"
      },
      "source": [
        "Data = {'train':X_train,'val':X_val}\n",
        "Labels = {'train':Y_train,'val':Y_val}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jstCIyenlqNM"
      },
      "source": [
        "data_transforms = {\n",
        "    'train': transforms.Compose([\n",
        "        transforms.RandomResizedCrop(224),\n",
        "        transforms.RandomHorizontalFlip(),\n",
        "        transforms.RandomVerticalFlip(),\n",
        "        transforms.RandomRotation([-15, 15], resample=False, expand=False, center=None),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "    'val': transforms.Compose([\n",
        "        transforms.Resize(256),\n",
        "        transforms.CenterCrop(224),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "    ]),\n",
        "}\n",
        "\n",
        "image_datasets = {x: torch.utils.data.TensorDataset(torch.tensor(Data[x], dtype=torch.float).transpose(3,1),torch.tensor(Labels[x], dtype=torch.float)) for x in ['train', 'val']}\n",
        "dataloaders    = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=4) for x in ['train', 'val']}\n",
        "dataset_sizes  = {x: len(image_datasets[x]) for x in ['train', 'val']}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nql8hIAWlqrr"
      },
      "source": [
        "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
        "    since = time.time()\n",
        "\n",
        "    best_model_wts = copy.deepcopy(model.state_dict())\n",
        "    best_acc = 0.0\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n",
        "        print('-' * 10)\n",
        "\n",
        "        # Each epoch has a training and validation phase\n",
        "        for phase in ['train', 'val']:\n",
        "            if phase == 'train':\n",
        "                scheduler.step()\n",
        "                model.train()  # Set model to training mode\n",
        "            else:\n",
        "                model.eval()   # Set model to evaluate mode\n",
        "\n",
        "            running_loss = 0.0\n",
        "            running_corrects = 0\n",
        "\n",
        "            # Iterate over data.\n",
        "            for inputs, labels in dataloaders[phase]:\n",
        "                inputs = inputs.to(device)\n",
        "                labels = labels.to(device)\n",
        "\n",
        "                # zero the parameter gradients\n",
        "                optimizer.zero_grad()\n",
        "\n",
        "                # forward\n",
        "                # track history if only in train\n",
        "                with torch.set_grad_enabled(phase == 'train'):\n",
        "                    outputs = model(inputs)\n",
        "                    _, preds = torch.max(outputs, 1)\n",
        "                    loss = criterion(outputs, torch.argmax(labels,1))\n",
        "\n",
        "                    # backward + optimize only if in training phase\n",
        "                    if phase == 'train':\n",
        "                        loss.backward()\n",
        "                        optimizer.step()\n",
        "\n",
        "                # statistics\n",
        "                running_loss += loss.item() * inputs.size(0)\n",
        "                running_corrects += torch.sum(preds == torch.argmax(labels.data,1))\n",
        "\n",
        "            epoch_loss = running_loss / dataset_sizes[phase]\n",
        "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
        "\n",
        "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(\n",
        "                phase, epoch_loss, epoch_acc))\n",
        "\n",
        "            # deep copy the model\n",
        "            if phase == 'val' and epoch_acc > best_acc:\n",
        "                best_acc = epoch_acc\n",
        "                best_model_wts = copy.deepcopy(model.state_dict())\n",
        "\n",
        "        print()\n",
        "\n",
        "    time_elapsed = time.time() - since\n",
        "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
        "        time_elapsed // 60, time_elapsed % 60))\n",
        "    print('Best val Acc: {:4f}'.format(best_acc))\n",
        "\n",
        "    # load best model weights\n",
        "    model.load_state_dict(best_model_wts)\n",
        "    return model\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fRLCJmw9lssV"
      },
      "source": [
        "net = resnext101_32x8d(pretrained=True).to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bBEwNSUVlwNo"
      },
      "source": [
        "optimizer_ft = optim.SGD(net.parameters(), lr=0.003162, momentum=0.75)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4JfF3mJ6lw1A"
      },
      "source": [
        "net = train_model(net, criterion, optimizer_ft, exp_lr_scheduler, num_epochs=100)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}