Ultrasound_Image_Challenge_code.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Ultrasound_Image_Challenge_code.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "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.8.5"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MEGNEOrnela/Ultrasound-Image-Challenge/blob/main/Ultrasound_Image_Challenge_code.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KgSKAuYhMfMV"
      },
      "source": [
        "# Cameroon Advance Analytic Ultrasound Image Challenge"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvSXLI6iODfA"
      },
      "source": [
        "## Import  necessary modules and libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gl-F3uxPOCnw"
      },
      "source": [
        "import os\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "from torch.utils.data import random_split, DataLoader\n",
        "from torchvision import utils\n",
        "from PIL import Image\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "np.random.seed(0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kS5KIGAZMxfR"
      },
      "source": [
        "## Dataset Preparation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NyWS16TlMlli"
      },
      "source": [
        "!wget https://github.com/sankasom/cmrn-kdny/raw/master/kidney_challenge.zip\n",
        "!unzip kidney_challenge.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xASDUo1EM6Ba"
      },
      "source": [
        "class KidneyDataLoader():\n",
        "  \"\"\"\n",
        "  A class that reads the images, the corresponding labels and file names\n",
        "  Input:\n",
        "    * imgs_dir ==> images directory\n",
        "    * labelsfile => the file containing the labels\n",
        "    * transform => the data_transformer\n",
        "  \"\"\"\n",
        "  def __init__(self, imgs_dir, labelsfile, transform):\n",
        "    data = pd.read_csv(labelsfile)\n",
        "    file_names = data['img_IDs'].values\n",
        "    # obtain labels from data frame\n",
        "    self.full_filenames = [os.path.join(imgs_dir, name+'.jpg') for name in file_names]\n",
        "    self.labels = data['target'].values\n",
        "    self.transform = transform\n",
        "\n",
        "  def __len__(self):\n",
        "    # return size of dataset\n",
        "    return len(self.full_filenames)\n",
        "\n",
        "  def __getitem__(self, idx):\n",
        "    # open image, apply transforms and return with label\n",
        "    #image = Image.open(self.full_filenames[idx]).resize((1039, 810)) # PIL image\n",
        "    image = Image.open(self.full_filenames[idx]).resize((1039, 810))\n",
        "    image = self.transform(image)\n",
        "    return image, self.labels[idx]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjtTeiGEPMrt"
      },
      "source": [
        "### Setup dataset direcorty and labels"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H84-OwWxPbpL"
      },
      "source": [
        "#data transformer\n",
        "data_transformer = transforms.Compose([transforms.ToTensor()])\n",
        "#setup directories and labels\n",
        "data_dir = \"./images/\"\n",
        "labelsFile = \"Train.csv\"\n",
        "kidneyDataSet = KidneyDataLoader(data_dir, labelsFile, data_transformer)\n",
        "#kidneyDataSet = KidneyDataLoader(data_dir, labelsFile, train_transforms)\n",
        "print(len(kidneyDataSet))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujlmc2vpPfZb"
      },
      "source": [
        "#### Check the size of a random image"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dem9UwUKP8Wy"
      },
      "source": [
        "# load an image -- image 9 for example\n",
        "img,label = kidneyDataSet[9]\n",
        "print(img.shape,torch.min(img),torch.max(img))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4bWXmb6AQK8p"
      },
      "source": [
        "### Split the Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bemUaduBP-dH"
      },
      "source": [
        "# import pytorch data splitter\n",
        "\n",
        "#print the leng of the data\n",
        "len_dataset = len(kidneyDataSet)\n",
        "len_train = int(0.8*len_dataset)\n",
        "len_val = len_dataset - len_train\n",
        "train_ds, val_ds = random_split(kidneyDataSet,[len_train,len_val])\n",
        "print(\"training dataset contains {} images.\".format(len(train_ds)))\n",
        "print(\"validation dataset contains {} images.\".format(len(val_ds)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ykzMxfX9QbkC"
      },
      "source": [
        "### Visualize some random Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MrK7uXgXQ4Bg"
      },
      "source": [
        "def show(img,y,color=False):\n",
        "    # convert tensor to numpy array\n",
        "    npimg = img.numpy()\n",
        "    # Convert to H*W*C shape\n",
        "    npimg_tr=np.transpose(npimg, (1,2,0))\n",
        "    if color==False:\n",
        "        npimg_tr=npimg_tr[:,:,0]\n",
        "        plt.imshow(npimg_tr,interpolation='nearest',cmap=\"gray\")\n",
        "    else:\n",
        "        # display images\n",
        "        plt.imshow(npimg_tr,interpolation='nearest')\n",
        "        plt.title(\"label: \"+str(y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YtdtYcnxRAQ6"
      },
      "source": [
        "\n",
        "# show random image => image 20 for example\n",
        "img, label = kidneyDataSet[20]\n",
        "show(img, label)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n67ZwEJjRJjK"
      },
      "source": [
        "### Training, validation and test transformer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_0HETWbdf-rT"
      },
      "source": [
        "mean=[0.485, 0.456, 0.406]\n",
        "std=[0.229, 0.224, 0.225]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5n4TswDf6mcP"
      },
      "source": [
        "train_transformer = transforms.Compose([\n",
        "transforms.RandomHorizontalFlip(p=0.1),\n",
        "transforms.RandomVerticalFlip(p=0.1),\n",
        "transforms.RandomRotation(95),\n",
        "transforms.ToTensor(), transforms.Normalize(mean=mean, std=std)])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6fkq59KK64sT"
      },
      "source": [
        "val_transformer = transforms.Compose([transforms.ToTensor()])\n",
        "test_transformer = transforms.Compose([transforms.ToTensor()])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IwFmITgFpflv"
      },
      "source": [
        "# Data Loaders\n",
        "train_dl = DataLoader(train_ds, batch_size=4, shuffle=True)\n",
        "val_dl = DataLoader(val_ds, batch_size=2, shuffle=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eLimWjOT3hqv"
      },
      "source": [
        "ts_data = pd.read_csv(\"./SampleSubmission.csv\")\n",
        "ts_data.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f8BYwJHMpjo5"
      },
      "source": [
        "### Create the test dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OoBa36C4pjg3"
      },
      "source": [
        "ts_data = pd.read_csv(\"./SampleSubmission.csv\")\n",
        "# set the output values to 0 ==> just to follow the formality of the dataset loader\n",
        "ts_data['target'] = 0\n",
        "# save it to Test file name\n",
        "test_labels_file = \"custom_test.csv\"\n",
        "ts_data.to_csv(test_labels_file)\n",
        "# test dataset\n",
        "tst_ds = KidneyDataLoader(data_dir, test_labels_file, test_transformer)\n",
        "# the batch size should be the same as the test dataset size [i.e. 34 images]\n",
        "tst_dl = DataLoader(tst_ds, batch_size=1, shuffle=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jU5LZCf245Rg"
      },
      "source": [
        "len(tst_ds)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfOHc2GgEaGh"
      },
      "source": [
        "## Model Architecture"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XUOWDGICFrtv"
      },
      "source": [
        "# Device configuration\n",
        "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ne3oGdHff0p6"
      },
      "source": [
        "from torch.optim import lr_scheduler"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qupZdpL_Kv5g"
      },
      "source": [
        "### Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jbt57sdMKK27"
      },
      "source": [
        "def train(model, criterion, data_loader, optimizer, num_epochs, scheduler):\n",
        "    \"\"\"Simple training loop for a PyTorch model.\"\"\" \n",
        "    \n",
        "    # Make sure model is in training mode.\n",
        "    model.train()\n",
        "    \n",
        "    # Move model to the device (CPU or GPU).\n",
        "    model.to(device)\n",
        "    \n",
        "    # Exponential moving average of the loss.\n",
        "    ema_loss = None\n",
        "\n",
        "    print('----- Training Loop -----')\n",
        "    # Loop over epochs.\n",
        "    for epoch in range(num_epochs):\n",
        "        \n",
        "      # Loop over data.\n",
        "      for batch_idx, (features, target) in enumerate(data_loader):\n",
        "            \n",
        "          # Forward pass.\n",
        "        output = model(features.to(device))\n",
        "        loss = criterion(output.to(device), target.to(device))\n",
        "          # Backward pass.\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "      # NOTE: It is important to call .item() on the loss before summing.\n",
        "        if ema_loss is None:\n",
        "            ema_loss = loss.item()\n",
        "        else:\n",
        "            ema_loss += (loss.item() - ema_loss) * 0.01 \n",
        "\n",
        "        # if phase == 'train':\n",
        "        #         scheduler.step()\n",
        "\n",
        "      # Print out progress the end of epoch.\n",
        "      print('Epoch: {} \\tLoss: {:.6f}'.format((epoch+1), ema_loss),)\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z0iR6sRJKzlq"
      },
      "source": [
        "### Validation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "padna7f_K532"
      },
      "source": [
        "def validate(model, data_loader):\n",
        "    \"\"\"Measures the accuracy of a model on a data set.\"\"\" \n",
        "    # Make sure the model is in evaluation mode.\n",
        "    model.eval()\n",
        "    correct = 0\n",
        "    print('----- Model Evaluation -----')\n",
        "    # We do not need to maintain intermediate activations while testing.\n",
        "    with torch.no_grad():\n",
        "        \n",
        "        # Loop over test data.\n",
        "        for features, target in data_loader:\n",
        "          \n",
        "            # Forward pass.\n",
        "            output = model(features.to(device))\n",
        "            # Get the label corresponding to the highest predicted probability.\n",
        "            pred = output.argmax(dim=1, keepdim=True)\n",
        "            \n",
        "            # Count number of correct predictions.\n",
        "            correct += pred.cpu().eq(target.view_as(pred)).sum().item()\n",
        "\n",
        "    # Print test accuracy.\n",
        "    percent = 100. * correct / len(data_loader.sampler)\n",
        "    print(f'Test accuracy: {correct} / {len(data_loader.sampler)} ({percent:.0f}%)')\n",
        "    torch.save(model.state_dict(), 'model.ckpt')\n",
        "    return percent"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jFR5MFboLNHB"
      },
      "source": [
        "### Submission prediction"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RvWyAxHHX_04"
      },
      "source": [
        "### Model configuration"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kriay3BOYEk_"
      },
      "source": [
        "model = torchvision.models.vgg16(pretrained=True)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0NAPNTclYafQ"
      },
      "source": [
        "model.to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "53tJTbmWZn11"
      },
      "source": [
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
        "# exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)\n",
        "exp_lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, 20)\n",
        "\n",
        "#optimizer = torch.optim.Adam(model.parameters(), lr=1e-5,weight_decay=1e-3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BCTz0ZqsaLO7"
      },
      "source": [
        "**Train the model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uI2QSiJWZofM"
      },
      "source": [
        "epochs = 20\n",
        "# odel.to(device)\n",
        "train(model, criterion, train_dl, optimizer, num_epochs=epochs, scheduler= exp_lr_scheduler)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bgUuu5EmaP4X"
      },
      "source": [
        "**Validate the model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "moTo1wVuZ21w"
      },
      "source": [
        "validate(model, val_dl)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_-Smj08dZ9w"
      },
      "source": [
        "## Submission prediction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KbQOz12Tdg-V"
      },
      "source": [
        "def sumission_predict(model, test_loader, tst_labels_file):\n",
        "  model.eval()\n",
        "  result = []\n",
        "  softmax = torch.nn.Softmax(dim=1)\n",
        "  with torch.no_grad():\n",
        "    \n",
        "    # Loop over test data.\n",
        "    for features, target in test_loader:\n",
        "      \n",
        "        # Forward pass.\n",
        "        logits = model(features.to(device))\n",
        "        probs = softmax(logits)\n",
        "        result.append(torch.max(probs).detach().cpu().numpy())\n",
        "        \n",
        "  print(result)\n",
        "  sub = pd.read_csv(tst_labels_file)\n",
        "  sub['target'] = result\n",
        "  sub.to_csv(\"submission03.csv\",index=False)\n",
        "  print(\"--------------- Process completed successfully ---------------\")\n",
        "  return sub"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LaIdXJNeaKCd"
      },
      "source": [
        "res=sumission_predict(model, tst_dl, test_labels_file)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_qS8ezLO7fda"
      },
      "source": [
        "res.columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LBnvOdzv7Wld"
      },
      "source": [
        "res.drop('Unnamed: 0', axis=1, inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RALDl1e36foy"
      },
      "source": [
        "res.to_csv('submission11.csv', index=False)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}