Newest_VGG_Datagenerator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "pbc_Datagenerator.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "CIiG_K6175sb",
        "colab_type": "code",
        "outputId": "bbe310ab-980b-48ad-f5e0-1e7eea2ba8aa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "!pip install SimpleITK"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: SimpleITK in /usr/local/lib/python3.6/dist-packages (1.2.4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J9oTyro-2ByE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "outputId": "0fc2499b-6da4-4de9-abe6-8c1e5a1082c5"
      },
      "source": [
        "import keras\n",
        "import tensorflow as tf\n",
        "import json, os, time, copy\n",
        "import numpy as np\n",
        "import skimage\n",
        "import seaborn as sns\n",
        "import glob\n",
        "import SimpleITK as sitk\n",
        "from keras import applications\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from keras import optimizers\n",
        "from keras.models import Sequential, Model \n",
        "from keras.layers import Dropout, Flatten, Dense, GlobalAveragePooling2D\n",
        "from keras import backend as k \n",
        "from keras.callbacks import ModelCheckpoint, LearningRateScheduler, TensorBoard, EarlyStopping\n",
        "\n",
        "sns.set()\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n",
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n6SAzbtHzdN1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from random import randint\n",
        "import cv2\n",
        "\n",
        "\n",
        "class DataGenerator(keras.utils.Sequence):\n",
        "    'Generates data for Keras'\n",
        "    #Have to set parameters here\n",
        "    def __init__(self, list_IDs, labels, batch_size=32, dim=(128,128,128), n_channels=3,\n",
        "                 n_classes=7, shuffle=True):\n",
        "        'Initialization'\n",
        "        self.dim = dim\n",
        "        self.batch_size = batch_size\n",
        "        self.labels = labels\n",
        "        self.list_IDs = list_IDs\n",
        "        self.n_channels = n_channels\n",
        "        self.n_classes = n_classes\n",
        "        self.shuffle = shuffle\n",
        "        self.on_epoch_end()\n",
        "\n",
        "    def __len__(self):\n",
        "        'Denotes the number of batches per epoch'\n",
        "        return int(np.floor(len(self.list_IDs) / self.batch_size))\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        'Generate one batch of data'\n",
        "        # Generate indexes of the batch\n",
        "        indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]\n",
        "\n",
        "        # Find list of IDs\n",
        "        list_IDs_temp = [self.list_IDs[k] for k in indexes]\n",
        "\n",
        "        # Generate data\n",
        "        X, y = self.__data_generation(list_IDs_temp)\n",
        "\n",
        "        return X, y\n",
        "\n",
        "    def on_epoch_end(self):\n",
        "        'Updates indexes after each epoch'\n",
        "        self.indexes = np.arange(len(self.list_IDs))\n",
        "        if self.shuffle == True:\n",
        "            np.random.shuffle(self.indexes)\n",
        " \n",
        "    def __data_generation(self, list_IDs_temp):\n",
        "        'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)\n",
        "        # Initialization\n",
        "        X = np.empty((self.batch_size, 128, 128 , self.n_channels))\n",
        "        y = np.empty((self.batch_size), dtype=int)\n",
        "        \n",
        "        \n",
        "\n",
        "        # Generate data\n",
        "        for i, ID in enumerate(list_IDs_temp):\n",
        "            # Store sample\n",
        "            #X[i,] = np.load('data/' + ID + '.npy')\n",
        "            image = sitk.ReadImage(ID) \n",
        "        \n",
        "           # im = sitk.GetImageFromArray(image)\n",
        "\n",
        "            num_dim = image.GetDimension()\n",
        "\n",
        "            orig_pixelid = image.GetPixelIDValue()\n",
        "            orig_origin = image.GetOrigin()\n",
        "            orig_direction = image.GetDirection()\n",
        "            orig_spacing = np.array(image.GetSpacing())\n",
        "            orig_size = np.array(image.GetSize(), dtype=np.int)\n",
        "\n",
        "\n",
        "\n",
        "            new_size = [128,128,128] #  SimpleITK expects lists, not ndarrays\n",
        "\n",
        "            new_spacing = [sz*spc/nsz for nsz,sz,spc in zip(new_size, image.GetSize(), image.GetSpacing())]\n",
        "\n",
        "            resample_filter = sitk.ResampleImageFilter()\n",
        "\n",
        "            resampled_sitk_image = resample_filter.Execute(image,\n",
        "                                                           new_size,\n",
        "                                                           sitk.Transform(),\n",
        "                                                           sitk.sitkNearestNeighbor,\n",
        "                                                           orig_origin,\n",
        "                                                           new_spacing,\n",
        "                                                           orig_direction,\n",
        "                                                           fill_value,\n",
        "                                                           orig_pixelid)\n",
        "\n",
        "           # resampled_sitk_image = np.expand_dims (resampled_sitk_image, axis =2)\n",
        "\n",
        "\n",
        "\n",
        "            imageArray = sitk.GetArrayFromImage(resampled_sitk_image)\n",
        "\n",
        "            angle = 0.0\n",
        "            scale = 0\n",
        "            rangle = np.random.random() * angle\n",
        "            sc = (np.random.random() - 0.5) * 2 * scale + 1.0\n",
        "            rows, cols = (128,128)\n",
        "            M = cv2.getRotationMatrix2D((cols / 2, rows / 2), rangle, sc)\n",
        "            \n",
        "            warped_img = np.expand_dims(cv2.warpAffine(imageArray[32+randint(0,64)], M, (cols, rows), flags=0), -1)\n",
        "            #X[i]= cv2.merge(warped_img, warped_img, warped_img)\n",
        "            #print(X[i].shape)\n",
        "\n",
        "            for j in range (128):\n",
        "              for k in range (128):\n",
        "                for l in range(2):\n",
        "                  X[i][j][k][l] = warped_img[j][k][0]\n",
        "\n",
        "\n",
        "            # Store class\n",
        "            y[i] = self.labels[ID]\n",
        "\n",
        "        return X, keras.utils.to_categorical(y, num_classes=self.n_classes)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t6AzBI4sDhhP",
        "colab_type": "code",
        "outputId": "7a47f95f-77f7-487b-c4f8-d04e2f702677",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OkbfTLJHwTmO",
        "colab_type": "code",
        "outputId": "cf87dc8e-3c80-4478-abf9-ceeaa4e8da20",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "from keras.models import Sequential\n",
        "\n",
        "\n",
        "# Parameters - Have to fix this\n",
        "params = {'dim': (128,128,128),\n",
        "          'batch_size': 32,\n",
        "          'n_classes': 7,\n",
        "          'n_channels': 3,\n",
        "          'shuffle': True}\n",
        "\n",
        "labels = {}\n",
        "partition = {}\n",
        "\n",
        "rootdir = \"/content/drive/My Drive/Classifier_train/\"\n",
        "train_niiPaths = []\n",
        "num_files= len(train_niiPaths)\n",
        "\n",
        "\n",
        "for subdir, dirs, files in os.walk(rootdir):\n",
        "    for file in files:\n",
        "        if(file.endswith(\"nii.gz\")):\n",
        "                train_niiPaths.append(os.path.join(subdir, file))\n",
        "\n",
        "print(\"Number of source filePaths: \" + str(len(train_niiPaths)))\n",
        "\n",
        "\n",
        "for fileCount, filePath in enumerate(train_niiPaths[:]):\n",
        "    if \"No treatment\" in filePath:\n",
        "        labels[filePath] = 0\n",
        "    elif \"Ex\" in filePath:\n",
        "        if \"/1m\" in filePath:\n",
        "            labels[filePath] = 1\n",
        "        elif \"/5m\" in filePath:\n",
        "            labels[filePath] = 2\n",
        "        elif \"/30m\" in filePath:\n",
        "            labels[filePath] = 3\n",
        "    else:\n",
        "        if \"/1m\" in filePath:\n",
        "            labels[filePath] = 4\n",
        "        elif \"/5m\" in filePath:\n",
        "            labels[filePath] = 5\n",
        "        elif \"/30m\" in filePath:\n",
        "            labels[filePath] = 6\n",
        "\n",
        "    \n",
        "    #print(\"Saving Labels: \" + str(fileCount+1) + \". Label:\" + str(label) + \"for filepath \" + str(filePath))\n",
        "    \n",
        "\n",
        "    \n",
        "partition['train'] = train_niiPaths\n",
        "\n",
        "test_rootdir = \"/content/drive/My Drive/Classifier_valid/\"\n",
        "test_niiPaths = []\n",
        "fill_value = 0\n",
        "num_files= len(test_niiPaths) \n",
        "\n",
        "\n",
        "for subdir, dirs, files in os.walk(test_rootdir):\n",
        "    for file in files:\n",
        "        if(file.endswith(\"nii.gz\")):\n",
        "                test_niiPaths.append(os.path.join(subdir, file))\n",
        "\n",
        "\n",
        "for fileCount, filePath in enumerate(test_niiPaths[:]):\n",
        "    if \"No treatment\" in filePath:\n",
        "        labels[filePath] = 0\n",
        "    elif \"Ex\" in filePath:\n",
        "        if \"/1m\" in filePath:\n",
        "            labels[filePath] = 1\n",
        "        elif \"/5m\" in filePath:\n",
        "            labels[filePath] = 2\n",
        "        elif \"/30m\" in filePath:\n",
        "            labels[filePath] = 3\n",
        "    else:\n",
        "        if \"/1m\" in filePath:\n",
        "            labels[filePath] = 4\n",
        "        elif \"/5m\" in filePath:\n",
        "            labels[filePath] = 5\n",
        "        elif \"/30m\" in filePath:\n",
        "            labels[filePath] = 6\n",
        "\n",
        "partition['validation'] = test_niiPaths\n",
        "\n",
        "#partition['test'] = test_niiPaths    //note: we are using \"test\" data as validation in our case, would need to make another \"D:/INS-1E Source Images/Unlabeled_validation\" folder\n",
        "\n",
        "\n",
        "img_width, img_height = 128, 128\n",
        "train_data_dir = \"/content/drive/My Drive/Classifier_train/\"\n",
        "validation_data_dir = \"/content/drive/My Drive/Classifier_valid/\"\n",
        "nb_train_samples = len(train_niiPaths) \n",
        "nb_validation_samples = len(test_niiPaths) \n",
        "batch_size = 32\n",
        "epochs = 10\n",
        "\n",
        "\n",
        "# Generators\n",
        "training_generator = DataGenerator(partition['train'], labels, **params)\n",
        "validation_generator = DataGenerator(partition['validation'], labels, **params)\n",
        "\n",
        "# Design model\n",
        "model = applications.VGG19(weights = \"imagenet\", include_top=False, input_shape = (img_width, img_height, 3))\n",
        "\n",
        "for layer in model.layers[:5]:\n",
        "    layer.trainable = False\n",
        "x = model.output\n",
        "x = Flatten()(x)\n",
        "x = Dense(1024, activation=\"relu\")(x)\n",
        "x = Dropout(0.5)(x)\n",
        "x = Dense(1024, activation=\"relu\")(x)\n",
        "predictions = Dense(7, activation=\"softmax\")(x)\n",
        "\n",
        "model_final = Model(input = model.input, output = predictions)\n",
        "model_final.summary()\n",
        "\n",
        "model_final.compile(loss = \"categorical_crossentropy\", optimizer = optimizers.SGD(lr=0.0001, momentum=0.9), metrics=[\"accuracy\"])\n",
        "\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of source filePaths: 196\n",
            "Model: \"model_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_1 (InputLayer)         (None, 128, 128, 3)       0         \n",
            "_________________________________________________________________\n",
            "block1_conv1 (Conv2D)        (None, 128, 128, 64)      1792      \n",
            "_________________________________________________________________\n",
            "block1_conv2 (Conv2D)        (None, 128, 128, 64)      36928     \n",
            "_________________________________________________________________\n",
            "block1_pool (MaxPooling2D)   (None, 64, 64, 64)        0         \n",
            "_________________________________________________________________\n",
            "block2_conv1 (Conv2D)        (None, 64, 64, 128)       73856     \n",
            "_________________________________________________________________\n",
            "block2_conv2 (Conv2D)        (None, 64, 64, 128)       147584    \n",
            "_________________________________________________________________\n",
            "block2_pool (MaxPooling2D)   (None, 32, 32, 128)       0         \n",
            "_________________________________________________________________\n",
            "block3_conv1 (Conv2D)        (None, 32, 32, 256)       295168    \n",
            "_________________________________________________________________\n",
            "block3_conv2 (Conv2D)        (None, 32, 32, 256)       590080    \n",
            "_________________________________________________________________\n",
            "block3_conv3 (Conv2D)        (None, 32, 32, 256)       590080    \n",
            "_________________________________________________________________\n",
            "block3_conv4 (Conv2D)        (None, 32, 32, 256)       590080    \n",
            "_________________________________________________________________\n",
            "block3_pool (MaxPooling2D)   (None, 16, 16, 256)       0         \n",
            "_________________________________________________________________\n",
            "block4_conv1 (Conv2D)        (None, 16, 16, 512)       1180160   \n",
            "_________________________________________________________________\n",
            "block4_conv2 (Conv2D)        (None, 16, 16, 512)       2359808   \n",
            "_________________________________________________________________\n",
            "block4_conv3 (Conv2D)        (None, 16, 16, 512)       2359808   \n",
            "_________________________________________________________________\n",
            "block4_conv4 (Conv2D)        (None, 16, 16, 512)       2359808   \n",
            "_________________________________________________________________\n",
            "block4_pool (MaxPooling2D)   (None, 8, 8, 512)         0         \n",
            "_________________________________________________________________\n",
            "block5_conv1 (Conv2D)        (None, 8, 8, 512)         2359808   \n",
            "_________________________________________________________________\n",
            "block5_conv2 (Conv2D)        (None, 8, 8, 512)         2359808   \n",
            "_________________________________________________________________\n",
            "block5_conv3 (Conv2D)        (None, 8, 8, 512)         2359808   \n",
            "_________________________________________________________________\n",
            "block5_conv4 (Conv2D)        (None, 8, 8, 512)         2359808   \n",
            "_________________________________________________________________\n",
            "block5_pool (MaxPooling2D)   (None, 4, 4, 512)         0         \n",
            "_________________________________________________________________\n",
            "flatten_1 (Flatten)          (None, 8192)              0         \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 1024)              8389632   \n",
            "_________________________________________________________________\n",
            "dropout_1 (Dropout)          (None, 1024)              0         \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 1024)              1049600   \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 7)                 7175      \n",
            "=================================================================\n",
            "Total params: 29,470,791\n",
            "Trainable params: 29,358,215\n",
            "Non-trainable params: 112,576\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:112: UserWarning: Update your `Model` call to the Keras 2 API: `Model(inputs=Tensor(\"in..., outputs=Tensor(\"de...)`\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4NUidz17mvXs",
        "colab_type": "code",
        "outputId": "bbd28d55-32a1-4e25-aa06-2753d99ba6a0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "model_final.compile(loss = \"categorical_crossentropy\", optimizer = optimizers.SGD(lr=0.0001, momentum=0.9), metrics=[\"accuracy\"])\n",
        "\n",
        "checkpoint = ModelCheckpoint(\"vgg16_1.h5\", monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)\n",
        "#early = EarlyStopping(monitor='val_acc', min_delta=0, patience=10, verbose=1, mode='auto')\n",
        "\n",
        "# Train model on dataset\n",
        "model_final.fit_generator(generator=training_generator,\n",
        "                    validation_data=validation_generator, epochs=200, verbose=1)\n",
        "\n",
        "\n",
        "#score = model_final.evaluate(x_test, y_test, verbose=1)\n",
        "\n",
        "model.save_weights('G:/classifier_models/model_weights_04_03_2020.h5') \n",
        "\n",
        "print(\"saved\")\n",
        "\n",
        "\n",
        "with open('G:/classifier_models/model_architecture_04_03_2020.json', 'w') as f:\n",
        "\n",
        "    f.write(model.to_json())\n",
        "\n",
        "from keras.models import model_from_json\n",
        "\n",
        "\n",
        "# Model reconstruction from JSON file\n",
        "\n",
        "with open('G:/classifier_models/model_architecture_04_03_2020.json', 'r') as f:\n",
        "\n",
        "    model = model_from_json(f.read())\n",
        "\n",
        "\n",
        "# Load weights into the new model\n",
        "\n",
        "model.load_weights('G:/classifier_models/model_weights_04_03_2020.h5') #change names\n",
        "\n",
        "\n",
        "# confusion matrix\n",
        "\n",
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "test_labels = np.zeros((len(test_labelArray)))\n",
        "\n",
        "for i,label in enumerate(test_labelArray):\n",
        "\n",
        "    for j in range(7):\n",
        "\n",
        "        if label[j] == 1:\n",
        "\n",
        "            test_labels[i] = j\n",
        "\n",
        "print(ynew)\n",
        "\n",
        "print(test_labels)\n",
        "\n",
        "confusionArray = confusion_matrix(test_labels, ynew)\n",
        "\n",
        "print(confusionArray)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/200\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8lkpZ7rL9PC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}