put_model_into_webapp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prerequisites\n",
    "\n",
    "This file was last updated on May 3rd, 2022 - if any changes have been made to the class found in ./my_model.py then there may be issues with running this code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load in Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision.models\n",
    "\n",
    "import my_model\n",
    "import utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_to_model_weights = \"model.pth\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_densenet = torchvision.models.DenseNet(\n",
    "    growth_rate=32,\n",
    "    block_config=(2,2,2,2),\n",
    "    num_init_features=64,\n",
    "    bn_size=4,\n",
    "    drop_rate=0,\n",
    "    num_classes=3\n",
    ")\n",
    "model_mymodel = my_model.MyModel(\n",
    "    model = model_densenet,\n",
    "    loss_fn = None,\n",
    "    device = torch.device('cpu'),\n",
    "    checkpoint_dir= None,\n",
    "    optimizer=None,\n",
    "    model_dir=None\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_mymodel.load_model(path_to_model_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(45000, 40000) 6786\n"
     ]
    }
   ],
   "source": [
    "# test the model real quick to make sure things work\n",
    "from unified_image_reader import Image\n",
    "img_path = \"/workspaces/dev-container/testing/data/whole_slide_images/92321.tif\"\n",
    "img = Image(img_path)\n",
    "print(img.dims, img.number_of_regions())\n",
    "region = img.get_region(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(model_mymodel.diagnose_region(region))\n",
    "# test diagnose_wsi???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wrapper on MyModel for WebApp Compatibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "from model_manager_for_web_app import ManagedModel\n",
    "from filtration import FilterManager, FilterBlackAndWhite, FilterHSV, FilterFocusMeasure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WrappedModel(ManagedModel):\n",
    "    def __init__(self, model, classes = ('Mild', 'Moderate', 'Severe'), aggregation_weights = (0,1,2)):\n",
    "        self.model = model\n",
    "        self.classes = classes\n",
    "        self.aggregation_weights = aggregation_weights\n",
    "        self.filtration = FilterManager([\n",
    "            FilterBlackAndWhite(),\n",
    "            FilterHSV(),\n",
    "            FilterFocusMeasure()\n",
    "        ])\n",
    "        self._device = torch.device('cpu')\n",
    "    def diagnose_region(self, region):\n",
    "        \"\"\" diagnose single region \"\"\"\n",
    "        # first check to see if we can use hardware\n",
    "        print(\"starting region diagnosis\")\n",
    "        print(\"self._device =\", self._device, torch.cuda.is_available())\n",
    "        if self._device is None:\n",
    "            print(\"checking for device to migrate\")\n",
    "            self._device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "            self.model.model.to(self._device)\n",
    "            print(\"finished migrating device: \", self._device)\n",
    "        print(\"device is configured\")\n",
    "        return self.model.diagnose_region(region)\n",
    "    def diagnose(self, region_stream):\n",
    "        \"\"\"\n",
    "            model takes in a stream of regions (numpy arrays) and produces diagnosis\n",
    "\n",
    "            Example:\n",
    "                # diagnosis is whichever category has the most 'votes'\n",
    "                votes = {'positive':0, 'negative':0}\n",
    "                for region in region_stream:\n",
    "                    votes[self.process(region)] += 1\n",
    "                return max(votes, key=votes.get) # key with max value\n",
    "        \"\"\"\n",
    "        # initialize the weights\n",
    "        votes = {i:0 for i in range(len(self.classes))}\n",
    "        # diagnose each region\n",
    "        for region in region_stream:\n",
    "            if self.filtration(region) is True:\n",
    "                region_diagnosis = self.diagnose_region(region)\n",
    "                votes[region_diagnosis] += 1\n",
    "        print(votes)\n",
    "        # aggregate the votes using weights\n",
    "        vote = sum([votes[c]*self.aggregation_weights[c] for c in range(len(votes))]) / sum(list(votes.values()))\n",
    "        vote = round(vote)\n",
    "        return self.classes[vote]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare Model for Saving\n",
    "\n",
    "1. Wrap the model in a ManagedModel class (you will need to create a subclass of ManagedModel just as above)\n",
    "2. Register any dependencies that might not be available to the WebApp when this model is deserialized. \n",
    "    - To identify whether you need to register a dependency, consider the code used to create the serialized object that may not be available to the WebApp when deserializing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_wrapped = WrappedModel(model=model_mymodel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_diagnosis = False\n",
    "if test_diagnosis:\n",
    "    from tqdm import tqdm as loadingbar\n",
    "    model_wrapped.diagnose(loadingbar(img))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "from model_manager_for_web_app import ModelManager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_manager = ModelManager()\n",
    "model_manager.save_model(\n",
    "    model_name = \"kevin_test\",\n",
    "    model = model_wrapped,\n",
    "    model_info = {\n",
    "        \"info\": \"idk man anything you want to record\"\n",
    "    },\n",
    "    overwrite_model=True,\n",
    "    dependency_modules = [\n",
    "        my_model,\n",
    "        utils\n",
    "    ]\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "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.9.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}