v1/notebooks/qubvel-segmentation_models-U-Net-ML-Pipeline.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ntpath, os\n",
    "import azureml.core, azureml.data\n",
    "print(\"SDK version:\", azureml.core.VERSION)\n",
    "\n",
    "from azureml.contrib.pipeline.steps import ParallelRunStep, ParallelRunConfig\n",
    "from azureml.core import Datastore, Environment, Experiment, ScriptRunConfig, Workspace\n",
    "from azureml.core.compute import AmlCompute\n",
    "from azureml.core.compute import ComputeTarget\n",
    "from azureml.core.conda_dependencies import CondaDependencies\n",
    "from azureml.core.dataset import Dataset\n",
    "from azureml.core.model import Model\n",
    "from azureml.core.runconfig import DEFAULT_CPU_IMAGE, RunConfiguration\n",
    "from azureml.data.azure_storage_datastore import AzureFileDatastore, AzureBlobDatastore\n",
    "from azureml.data.data_reference import DataReference\n",
    "from azureml.pipeline.core import Pipeline, PipelineData\n",
    "from azureml.pipeline.steps import PythonScriptStep\n",
    "from azureml.train.estimator import Estimator\n",
    "from azureml.widgets import RunDetails\n",
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFAULT_CPU_IMAGE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run Common.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ws = Workspace.from_config()\n",
    "print('Name: {0}'.format(ws.name), 'Resource Group: {0}'.format(ws.resource_group), 'Location: {0}'.format(ws.location), 'Subscription Id: {0}'.format(ws.subscription_id), sep = '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_name = 'CPU'\n",
    "\n",
    "if compute_name in ws.compute_targets:\n",
    "    compute_target = ws.compute_targets[compute_name]\n",
    "    \n",
    "    if compute_target and type(compute_target) is AmlCompute:\n",
    "        print('Found compute target: ' + compute_name)\n",
    "else:\n",
    "    provisioning_configuration = AmlCompute.provisioning_configuration(vm_size = 'STANDARD_D2_V2',\n",
    "                                                                min_nodes = 1,\n",
    "                                                                max_nodes = 2)\n",
    "\n",
    "    compute_target = ComputeTarget.create(ws, compute_name, provisioning_configuration)\n",
    "    \n",
    "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
    "    \n",
    "    print(compute_target.status.serialize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compute_name = 'GPU'\n",
    "\n",
    "if compute_name in ws.compute_targets:\n",
    "    compute_target = ws.compute_targets[compute_name]\n",
    "    \n",
    "    if compute_target and type(compute_target) is AmlCompute:\n",
    "        print('Found compute target: ' + compute_name)\n",
    "else:\n",
    "    provisioning_configuration = AmlCompute.provisioning_configuration(vm_size = 'Standard_NC6',\n",
    "                                                                min_nodes = 1,\n",
    "                                                                max_nodes = 2)\n",
    "\n",
    "    compute_target = ComputeTarget.create(ws, compute_name, provisioning_configuration)\n",
    "    \n",
    "    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)\n",
    "    \n",
    "    print(compute_target.status.serialize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_DIR = './data/CamVid/'\n",
    "\n",
    "# load repo with data if it is not exists\n",
    "if not os.path.exists(DATA_DIR):\n",
    "    print('Loading data...')\n",
    "    os.system('git clone https://github.com/alexgkendall/SegNet-Tutorial ./data')\n",
    "    print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw = Datastore.register_azure_blob_container(workspace=ws,\n",
    "                                              datastore_name='raw',\n",
    "                                              container_name='raw',\n",
    "                                              account_name='healthyhabitatsvb',\n",
    "                                              account_key='0crB6HIwJxefIX/Op19ZVLepgE41jCp/SYTnlBGpPBB0To9Jrpf37pLvWX/eMhNyIVM8JxBC+n94IQOH1Cf9/g==',\n",
    "                                              create_if_not_exists=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_path = \"CamVid\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw.upload(src_dir=DATA_DIR[0:-1],\n",
    "                 target_path=target_path,\n",
    "                 overwrite=True,\n",
    "                 show_progress=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "camvid_data = DataReference(\n",
    "    datastore=raw,\n",
    "    data_reference_name='camvid_data',\n",
    "    path_on_datastore=target_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scripts\n",
    "- train.py\n",
    "- score.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile ./scripts/train.py\n",
    "\n",
    "import argparse, cv2, keras, os, sys\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
    "\n",
    "import albumentations as A\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import segmentation_models as sm\n",
    "\n",
    "from azureml.core import Run\n",
    "from keras.callbacks import Callback\n",
    "\n",
    "print(\"In train.py\")\n",
    "\n",
    "parser = argparse.ArgumentParser(\"train\")\n",
    "\n",
    "parser.add_argument(\"--input_data\", type=str, help=\"input data\")\n",
    "\n",
    "args = parser.parse_args()\n",
    "\n",
    "print(\"Argument 1: %s\" % args.input_data)\n",
    "\n",
    "x_train_dir = os.path.join(args.input_data, 'train')\n",
    "y_train_dir = os.path.join(args.input_data, 'trainannot')\n",
    "\n",
    "x_valid_dir = os.path.join(args.input_data, 'val')\n",
    "y_valid_dir = os.path.join(args.input_data, 'valannot')\n",
    "\n",
    "x_test_dir = os.path.join(args.input_data, 'test')\n",
    "y_test_dir = os.path.join(args.input_data, 'testannot')\n",
    "\n",
    "# helper function for data visualization\n",
    "def visualize(**images):\n",
    "    \"\"\"PLot images in one row.\"\"\"\n",
    "    n = len(images)\n",
    "    plt.figure(figsize=(16, 5))\n",
    "    for i, (name, image) in enumerate(images.items()):\n",
    "        plt.subplot(1, n, i + 1)\n",
    "        plt.xticks([])\n",
    "        plt.yticks([])\n",
    "        plt.title(' '.join(name.split('_')).title())\n",
    "    plt.savefig('{0}/{1}.png'.format(args.input_data, name))\n",
    "    plt.savefig('./outputs/{0}.png'.format(name))\n",
    "    \n",
    "    \n",
    "# helper function for data visualization    \n",
    "def denormalize(x):\n",
    "    \"\"\"Scale image to range 0..1 for correct plot\"\"\"\n",
    "    x_max = np.percentile(x, 98)\n",
    "    x_min = np.percentile(x, 2)    \n",
    "    x = (x - x_min) / (x_max - x_min)\n",
    "    x = x.clip(0, 1)\n",
    "    return x\n",
    "    \n",
    "\n",
    "# classes for data loading and preprocessing\n",
    "class Dataset:\n",
    "    \"\"\"CamVid Dataset. Read images, apply augmentation and preprocessing transformations.\n",
    "    \n",
    "    Args:\n",
    "        images_dir (str): path to images folder\n",
    "        masks_dir (str): path to segmentation masks folder\n",
    "        class_values (list): values of classes to extract from segmentation mask\n",
    "        augmentation (albumentations.Compose): data transfromation pipeline \n",
    "            (e.g. flip, scale, etc.)\n",
    "        preprocessing (albumentations.Compose): data preprocessing \n",
    "            (e.g. noralization, shape manipulation, etc.)\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    CLASSES = ['sky', 'building', 'pole', 'road', 'pavement', \n",
    "               'tree', 'signsymbol', 'fence', 'car', \n",
    "               'pedestrian', 'bicyclist', 'unlabelled']\n",
    "    \n",
    "    def __init__(\n",
    "            self, \n",
    "            images_dir, \n",
    "            masks_dir, \n",
    "            classes=None, \n",
    "            augmentation=None, \n",
    "            preprocessing=None,\n",
    "    ):\n",
    "        self.ids = os.listdir(images_dir)\n",
    "        self.images_fps = [os.path.join(images_dir, image_id) for image_id in self.ids]\n",
    "        self.masks_fps = [os.path.join(masks_dir, image_id) for image_id in self.ids]\n",
    "        \n",
    "        # convert str names to class values on masks\n",
    "        self.class_values = [self.CLASSES.index(cls.lower()) for cls in classes]\n",
    "        \n",
    "        self.augmentation = augmentation\n",
    "        self.preprocessing = preprocessing\n",
    "    \n",
    "    def __getitem__(self, i):\n",
    "        \n",
    "        # read data\n",
    "        image = cv2.imread(self.images_fps[i])\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        mask = cv2.imread(self.masks_fps[i], 0)\n",
    "        \n",
    "        # extract certain classes from mask (e.g. cars)\n",
    "        masks = [(mask == v) for v in self.class_values]\n",
    "        mask = np.stack(masks, axis=-1).astype('float')\n",
    "        \n",
    "        # add background if mask is not binary\n",
    "        if mask.shape[-1] != 1:\n",
    "            background = 1 - mask.sum(axis=-1, keepdims=True)\n",
    "            mask = np.concatenate((mask, background), axis=-1)\n",
    "        \n",
    "        # apply augmentations\n",
    "        if self.augmentation:\n",
    "            sample = self.augmentation(image=image, mask=mask)\n",
    "            image, mask = sample['image'], sample['mask']\n",
    "        \n",
    "        # apply preprocessing\n",
    "        if self.preprocessing:\n",
    "            sample = self.preprocessing(image=image, mask=mask)\n",
    "            image, mask = sample['image'], sample['mask']\n",
    "            \n",
    "        return image, mask\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.ids)\n",
    "    \n",
    "    \n",
    "class Dataloder(keras.utils.Sequence):\n",
    "    \"\"\"Load data from dataset and form batches\n",
    "    \n",
    "    Args:\n",
    "        dataset: instance of Dataset class for image loading and preprocessing.\n",
    "        batch_size: Integet number of images in batch.\n",
    "        shuffle: Boolean, if `True` shuffle image indexes each epoch.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, dataset, batch_size=1, shuffle=False):\n",
    "        self.dataset = dataset\n",
    "        self.batch_size = batch_size\n",
    "        self.shuffle = shuffle\n",
    "        self.indexes = np.arange(len(dataset))\n",
    "\n",
    "        self.on_epoch_end()\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        \n",
    "        # collect batch data\n",
    "        start = i * self.batch_size\n",
    "        stop = (i + 1) * self.batch_size\n",
    "        data = []\n",
    "        for j in range(start, stop):\n",
    "            data.append(self.dataset[j])\n",
    "        \n",
    "        # transpose list of lists\n",
    "        batch = [np.stack(samples, axis=0) for samples in zip(*data)]\n",
    "        \n",
    "        return batch\n",
    "    \n",
    "    def __len__(self):\n",
    "        \"\"\"Denotes the number of batches per epoch\"\"\"\n",
    "        return len(self.indexes) // self.batch_size\n",
    "    \n",
    "    def on_epoch_end(self):\n",
    "        \"\"\"Callback function to shuffle indexes each epoch\"\"\"\n",
    "        if self.shuffle:\n",
    "            self.indexes = np.random.permutation(self.indexes)\n",
    "\n",
    "def round_clip_0_1(x, **kwargs):\n",
    "    return x.round().clip(0, 1)\n",
    "\n",
    "# define heavy augmentations\n",
    "def get_training_augmentation():\n",
    "    train_transform = [\n",
    "\n",
    "        A.HorizontalFlip(p=0.5),\n",
    "\n",
    "        A.ShiftScaleRotate(scale_limit=0.5, rotate_limit=0, shift_limit=0.1, p=1, border_mode=0),\n",
    "\n",
    "        A.PadIfNeeded(min_height=320, min_width=320, always_apply=True, border_mode=0),\n",
    "        A.RandomCrop(height=320, width=320, always_apply=True),\n",
    "\n",
    "        A.IAAAdditiveGaussianNoise(p=0.2),\n",
    "        A.IAAPerspective(p=0.5),\n",
    "\n",
    "        A.OneOf(\n",
    "            [\n",
    "                A.CLAHE(p=1),\n",
    "                A.RandomBrightness(p=1),\n",
    "                A.RandomGamma(p=1),\n",
    "            ],\n",
    "            p=0.9,\n",
    "        ),\n",
    "\n",
    "        A.OneOf(\n",
    "            [\n",
    "                A.IAASharpen(p=1),\n",
    "                A.Blur(blur_limit=3, p=1),\n",
    "                A.MotionBlur(blur_limit=3, p=1),\n",
    "            ],\n",
    "            p=0.9,\n",
    "        ),\n",
    "\n",
    "        A.OneOf(\n",
    "            [\n",
    "                A.RandomContrast(p=1),\n",
    "                A.HueSaturationValue(p=1),\n",
    "            ],\n",
    "            p=0.9,\n",
    "        ),\n",
    "        A.Lambda(mask=round_clip_0_1)\n",
    "    ]\n",
    "    return A.Compose(train_transform)\n",
    "\n",
    "\n",
    "def get_validation_augmentation():\n",
    "    \"\"\"Add paddings to make image shape divisible by 32\"\"\"\n",
    "    test_transform = [\n",
    "        A.PadIfNeeded(384, 480)\n",
    "    ]\n",
    "    return A.Compose(test_transform)\n",
    "\n",
    "def get_preprocessing(preprocessing_fn):\n",
    "    \"\"\"Construct preprocessing transform\n",
    "    \n",
    "    Args:\n",
    "        preprocessing_fn (callbale): data normalization function \n",
    "            (can be specific for each pretrained neural network)\n",
    "    Return:\n",
    "        transform: albumentations.Compose\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    _transform = [\n",
    "        A.Lambda(image=preprocessing_fn),\n",
    "    ]\n",
    "    return A.Compose(_transform)\n",
    "\n",
    "# Lets look at data we have\n",
    "dataset = Dataset(x_train_dir, y_train_dir, classes=['car', 'pedestrian'])\n",
    "\n",
    "image, mask = dataset[5] # get some sample\n",
    "visualize(\n",
    "    image=image, \n",
    "    cars_mask=mask[..., 0].squeeze(),\n",
    "    sky_mask=mask[..., 1].squeeze(),\n",
    "    background_mask=mask[..., 2].squeeze(),\n",
    ")\n",
    "\n",
    "# Lets look at augmented data we have\n",
    "dataset = Dataset(x_train_dir, y_train_dir, classes=['car', 'sky'], augmentation=get_training_augmentation())\n",
    "\n",
    "image, mask = dataset[12] # get some sample\n",
    "visualize(\n",
    "    image=image, \n",
    "    cars_mask=mask[..., 0].squeeze(),\n",
    "    sky_mask=mask[..., 1].squeeze(),\n",
    "    background_mask=mask[..., 2].squeeze(),\n",
    ")\n",
    "\n",
    "BACKBONE = 'efficientnetb3'\n",
    "BATCH_SIZE = 8\n",
    "CLASSES = ['car']\n",
    "LR = 0.0001\n",
    "#EPOCHS = 40\n",
    "EPOCHS = 5\n",
    "\n",
    "preprocess_input = sm.get_preprocessing(BACKBONE)\n",
    "\n",
    "# define network parameters\n",
    "n_classes = 1 if len(CLASSES) == 1 else (len(CLASSES) + 1)  # case for binary and multiclass segmentation\n",
    "activation = 'sigmoid' if n_classes == 1 else 'softmax'\n",
    "\n",
    "#create model\n",
    "model = sm.Unet(BACKBONE, classes=n_classes, activation=activation)\n",
    "\n",
    "# define optomizer\n",
    "optim = keras.optimizers.Adam(LR)\n",
    "\n",
    "# Segmentation models losses can be combined together by '+' and scaled by integer or float factor\n",
    "dice_loss = sm.losses.DiceLoss()\n",
    "focal_loss = sm.losses.BinaryFocalLoss() if n_classes == 1 else sm.losses.CategoricalFocalLoss()\n",
    "total_loss = dice_loss + (1 * focal_loss)\n",
    "\n",
    "# actulally total_loss can be imported directly from library, above example just show you how to manipulate with losses\n",
    "# total_loss = sm.losses.binary_focal_dice_loss # or sm.losses.categorical_focal_dice_loss \n",
    "\n",
    "metrics = [sm.metrics.IOUScore(threshold=0.5), sm.metrics.FScore(threshold=0.5)]\n",
    "\n",
    "# compile keras model with defined optimozer, loss and metrics\n",
    "model.compile(optim, total_loss, metrics)\n",
    "\n",
    "# Dataset for train images\n",
    "train_dataset = Dataset(\n",
    "    x_train_dir, \n",
    "    y_train_dir, \n",
    "    classes=CLASSES, \n",
    "    augmentation=get_training_augmentation(),\n",
    "    preprocessing=get_preprocessing(preprocess_input),\n",
    ")\n",
    "\n",
    "# Dataset for validation images\n",
    "valid_dataset = Dataset(\n",
    "    x_valid_dir, \n",
    "    y_valid_dir, \n",
    "    classes=CLASSES, \n",
    "    augmentation=get_validation_augmentation(),\n",
    "    preprocessing=get_preprocessing(preprocess_input),\n",
    ")\n",
    "\n",
    "train_dataloader = Dataloder(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "valid_dataloader = Dataloder(valid_dataset, batch_size=1, shuffle=False)\n",
    "\n",
    "# check shapes for errors\n",
    "assert train_dataloader[0][0].shape == (BATCH_SIZE, 320, 320, 3)\n",
    "assert train_dataloader[0][1].shape == (BATCH_SIZE, 320, 320, n_classes)\n",
    "\n",
    "run = Run.get_context()\n",
    "\n",
    "class LogRunMetrics(Callback):\n",
    "    # callback at the end of every epoch\n",
    "    def on_epoch_end(self, epoch, log):\n",
    "        # log a value repeated which creates a list\n",
    "        run.log('Val. Loss', log['val_loss'])\n",
    "        run.log('Val. IoU Score', log['val_iou_score'])\n",
    "        run.log('Val. F1 Score', log['val_f1-score'])\n",
    "        run.log('Loss', log['loss'])\n",
    "        run.log('IoU Score', log['iou_score'])\n",
    "        run.log('F1 Score', log['f1-score'])\n",
    "        run.log('LR', log['lr'])\n",
    "\n",
    "# define callbacks for learning rate scheduling and best checkpoints saving\n",
    "callbacks = [\n",
    "    keras.callbacks.ModelCheckpoint('./outputs/best_model.h5', save_weights_only=True, save_best_only=True, mode='min'),\n",
    "    #keras.callbacks.ModelCheckpoint(os.path.join(args.input_data, 'best_model.h5'), save_weights_only=True, save_best_only=True, mode='min'),\n",
    "    keras.callbacks.ReduceLROnPlateau(),\n",
    "    LogRunMetrics()\n",
    "]\n",
    "\n",
    "# train model\n",
    "history = model.fit_generator(\n",
    "    train_dataloader, \n",
    "    steps_per_epoch=len(train_dataloader), \n",
    "    epochs=EPOCHS, \n",
    "    callbacks=callbacks, \n",
    "    validation_data=valid_dataloader, \n",
    "    validation_steps=len(valid_dataloader),\n",
    ")\n",
    "\n",
    "fname = 'plot.jpg'\n",
    "\n",
    "# Plot training & validation iou_score values\n",
    "plt.figure(figsize=(30, 5))\n",
    "plt.subplot(121)\n",
    "plt.plot(history.history['iou_score'])\n",
    "plt.plot(history.history['val_iou_score'])\n",
    "plt.title('Model iou_score')\n",
    "plt.ylabel('iou_score')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Test'], loc='upper left')\n",
    "\n",
    "# Plot training & validation loss values\n",
    "plt.subplot(122)\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'Test'], loc='upper left')\n",
    "plt.savefig('{0}/{1}'.format(args.input_data, fname))\n",
    "plt.savefig('./outputs/{0}'.format(fname))\n",
    "\n",
    "test_dataset = Dataset(\n",
    "    x_test_dir,\n",
    "    y_test_dir,\n",
    "    classes=CLASSES,\n",
    "    augmentation=get_validation_augmentation(),\n",
    "    preprocessing=get_preprocessing(preprocess_input),\n",
    ")\n",
    "\n",
    "test_dataloader = Dataloder(test_dataset, batch_size=1, shuffle=False)\n",
    "\n",
    "# load best weights\n",
    "model.load_weights('./outputs/best_model.h5') \n",
    "\n",
    "scores = model.evaluate_generator(test_dataloader)\n",
    "\n",
    "print(\"Loss: {:.5}\".format(scores[0]))\n",
    "for metric, value in zip(metrics, scores[1:]):\n",
    "    print(\"mean {}: {:.5}\".format(metric.__name__, value))\n",
    "\n",
    "n = 5\n",
    "ids = np.random.choice(np.arange(len(test_dataset)), size=n)\n",
    "\n",
    "for i in ids:\n",
    "    \n",
    "    image, gt_mask = test_dataset[i]\n",
    "    image = np.expand_dims(image, axis=0)\n",
    "    pr_mask = model.predict(image).round()\n",
    "    \n",
    "    visualize(\n",
    "        image=denormalize(image.squeeze()),\n",
    "        gt_mask=gt_mask[..., 0].squeeze(),\n",
    "        pr_mask=pr_mask[..., 0].squeeze(),\n",
    "    )\n",
    "    \n",
    "model = run.register_model(model_name='qubvel-segmentation_models-u-net', model_path='./outputs/best_model.h5')\n",
    "print(model.name, model.id, model.version, sep = '\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!python3.6 -m pip install azureml-contrib-pipeline-steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keras, os, sys\n",
    "\n",
    "import numpy as np\n",
    "import segmentation_models as sm\n",
    "\n",
    "from azureml.core import Run\n",
    "from azureml.core.model import Model\n",
    "\n",
    "model_path = Model.get_model_path('qubvel-segmentation_models-u-net', _workspace=ws)\n",
    "print(model_path)\n",
    "BACKBONE = 'efficientnetb3'\n",
    "CLASSES = ['car']\n",
    "LR = 0.0001\n",
    "\n",
    "# define network parameters\n",
    "n_classes = 1 if len(CLASSES) == 1 else (len(CLASSES) + 1)  # case for binary and multiclass segmentation\n",
    "activation = 'sigmoid' if n_classes == 1 else 'softmax'\n",
    "\n",
    "#create model\n",
    "model = sm.Unet(BACKBONE, classes=n_classes, activation=activation)\n",
    "\n",
    "# define optomizer\n",
    "optim = keras.optimizers.Adam(LR)\n",
    "\n",
    "# Segmentation models losses can be combined together by '+' and scaled by integer or float factor\n",
    "dice_loss = sm.losses.DiceLoss()\n",
    "focal_loss = sm.losses.BinaryFocalLoss() if n_classes == 1 else sm.losses.CategoricalFocalLoss()\n",
    "total_loss = dice_loss + (1 * focal_loss)\n",
    "\n",
    "# actulally total_loss can be imported directly from library, above example just show you how to manipulate with losses\n",
    "# total_loss = sm.losses.binary_focal_dice_loss # or sm.losses.categorical_focal_dice_loss \n",
    "\n",
    "metrics = [sm.metrics.IOUScore(threshold=0.5), sm.metrics.FScore(threshold=0.5)]\n",
    "\n",
    "# compile keras model with defined optimozer, loss and metrics\n",
    "model.compile(optim, total_loss, metrics)\n",
    "\n",
    "model.load_weights(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile ./scripts/score.py\n",
    "\n",
    "import keras, os, sys\n",
    "\n",
    "import numpy as np\n",
    "import segmentation_models as sm\n",
    "\n",
    "from azureml.core import Run\n",
    "from azureml.core.model import Model\n",
    "\n",
    "print(\"In score.py\")\n",
    "\n",
    "def init():\n",
    "    global model\n",
    "    \n",
    "    parser = argparse.ArgumentParser(\"score\")\n",
    "    \n",
    "    parser.add_argument('--model_name', type=str, help=\"model name\", required=True)\n",
    "    \n",
    "    args, unknown_args = parser.parse_known_args()\n",
    "\n",
    "    model_path = Model.get_model_path(args.model_name)\n",
    "    print(model_path)\n",
    "    \n",
    "    print(os.path.isfile(model_path))\n",
    "    \n",
    "    BACKBONE = 'efficientnetb3'\n",
    "    CLASSES = ['car']\n",
    "    LR = 0.0001\n",
    "\n",
    "    # define network parameters\n",
    "    n_classes = 1 if len(CLASSES) == 1 else (len(CLASSES) + 1)  # case for binary and multiclass segmentation\n",
    "    activation = 'sigmoid' if n_classes == 1 else 'softmax'\n",
    "\n",
    "    #create model\n",
    "    model = sm.Unet(BACKBONE, classes=n_classes, activation=activation)\n",
    "    \n",
    "    # define optomizer\n",
    "    optim = keras.optimizers.Adam(LR)\n",
    "    \n",
    "    # Segmentation models losses can be combined together by '+' and scaled by integer or float factor\n",
    "    dice_loss = sm.losses.DiceLoss()\n",
    "    focal_loss = sm.losses.BinaryFocalLoss() if n_classes == 1 else sm.losses.CategoricalFocalLoss()\n",
    "    total_loss = dice_loss + (1 * focal_loss)\n",
    "\n",
    "    # actulally total_loss can be imported directly from library, above example just show you how to manipulate with losses\n",
    "    # total_loss = sm.losses.binary_focal_dice_loss # or sm.losses.categorical_focal_dice_loss \n",
    "\n",
    "    metrics = [sm.metrics.IOUScore(threshold=0.5), sm.metrics.FScore(threshold=0.5)]\n",
    "\n",
    "    # compile keras model with defined optimozer, loss and metrics\n",
    "    model.compile(optim, total_loss, metrics)\n",
    "\n",
    "    model.load_weights(model_path)\n",
    "    \n",
    "def run(mini_batch):\n",
    "    resultList = []\n",
    "    print(mini_batch)\n",
    "    \n",
    "    '''\n",
    "    test_dataloader = Dataloder(test_dataset, batch_size=1, shuffle=False)\n",
    "\n",
    "    scores = model.evaluate_generator(test_dataloader)\n",
    "\n",
    "    print(\"Loss: {:.5}\".format(scores[0]))\n",
    "    for metric, value in zip(metrics, scores[1:]):\n",
    "        print(\"mean {}: {:.5}\".format(metric.__name__, value))\n",
    "    '''\n",
    "    \n",
    "    '''\n",
    "    for image in mini_batch:\n",
    "        # prepare each image\n",
    "        data = Image.open(image)\n",
    "        np_im = np.array(data).reshape((1, 784))\n",
    "        # perform inference\n",
    "        inference_result = output.eval(feed_dict={in_tensor: np_im}, session=g_tf_sess)\n",
    "        # find best probability, and add to result list\n",
    "        best_result = np.argmax(inference_result)\n",
    "        resultList.append(\"{}: {}\".format(os.path.basename(image), best_result))\n",
    "    '''\n",
    "    return resultList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Model Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conda_dependencies = CondaDependencies()\n",
    "conda_dependencies.add_pip_package('albumentations')\n",
    "conda_dependencies.add_pip_package('keras')\n",
    "conda_dependencies.add_pip_package('matplotlib')\n",
    "conda_dependencies.add_pip_package('opencv-python')\n",
    "conda_dependencies.add_pip_package('segmentation-models')\n",
    "conda_dependencies.add_pip_package('tensorflow')\n",
    "\n",
    "environment = Environment(name='qubvel-segmentation_models')\n",
    "environment.docker.enabled = True\n",
    "environment.docker.base_image = DEFAULT_CPU_IMAGE\n",
    "environment.python.conda_dependencies = conda_dependencies\n",
    "environment.python.user_managed_dependencies = False\n",
    "\n",
    "run_configuration = RunConfiguration()\n",
    "run_configuration.environment = environment\n",
    "run_configuration.target = compute_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source_directory = './scripts'\n",
    "\n",
    "train_step = PythonScriptStep(name='train',\n",
    "                              source_directory=source_directory,\n",
    "                              script_name='train.py',\n",
    "                              arguments=['--input_data', camvid_data],\n",
    "                              inputs=[camvid_data],\n",
    "                              compute_target=compute_target,\n",
    "                              runconfig=run_configuration,\n",
    "                              allow_reuse=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline = Pipeline(workspace=ws, steps=[train_step])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment = Experiment(ws, 'train_pipeline')\n",
    "experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline_run = experiment.submit(pipeline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RunDetails(pipeline_run).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pipeline_run.wait_for_completion(show_output=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Batch Score Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latest_model = None\n",
    "model_version = 0\n",
    "\n",
    "models = Model.list(ws)\n",
    "\n",
    "for model in models:\n",
    "    if model.name == 'qubvel-segmentation_models-u-net':\n",
    "        if model.version > model_version:\n",
    "            model_version = model.version\n",
    "            latest_model = model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latest_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_name = 'camvid_dataset'\n",
    "\n",
    "camvid_dataset = Dataset.File.from_files(path=camvid_data , validate=False)\n",
    "registered_camvid_dataset = camvid_dataset.register(ws, dataset_name, create_new_version=True)\n",
    "named_camvid_dataset = registered_camvid_dataset.as_named_input(dataset_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_data = PipelineData(name=\"results\",\n",
    "                           datastore=raw,\n",
    "                           output_path_on_compute=\"CamVid/results\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "source_directory = './scripts'\n",
    "\n",
    "parallel_run_config = ParallelRunConfig(source_directory=source_directory,\n",
    "                                        entry_script='score.py',\n",
    "                                        mini_batch_size='5',\n",
    "                                        error_threshold=10,\n",
    "                                        output_action='append_row',\n",
    "                                        environment=environment,\n",
    "                                        compute_target=compute_target,\n",
    "                                        node_count=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parallel_run_step = ParallelRunStep(name='batch-score',\n",
    "                                    parallel_run_config=parallel_run_config,\n",
    "                                    arguments=['--model_name', 'qubvel-segmentation_models-u-net'],\n",
    "                                    inputs=[named_camvid_dataset],\n",
    "                                    output=output_data,\n",
    "                                    models=[],\n",
    "                                    allow_reuse=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline = Pipeline(workspace=ws, steps=[parallel_run_step])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment = Experiment(ws, 'batch_score_pipeline')\n",
    "experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline_run = experiment.submit(pipeline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RunDetails(pipeline_run).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pipeline_run.wait_for_completion(show_output=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6 - AzureML",
   "language": "python",
   "name": "python3-azureml"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}