{

  "nbformat": 4,

  "nbformat_minor": 0,

  "metadata": {

    "colab": {

      "provenance": [],

      "gpuType": "T4"

    },

    "kernelspec": {

      "name": "python3",

      "display_name": "Python 3"

    },

    "language_info": {

      "name": "python"

    },

    "accelerator": "GPU"

  },

  "cells": [

    {

      "cell_type": "code",

      "execution_count": 1,

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "collapsed": true,

        "id": "5MvIute5t3tC",

        "outputId": "e4ed079c-a1bd-454e-d72e-641c8eaa5cb6"

      },

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m102.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",

            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m104.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",

            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m455.8/455.8 kB\u001b[0m \u001b[31m35.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",

            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m60.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",

            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",

            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",

            "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",

            "grpcio-status 1.62.3 requires protobuf>=4.21.6, but you have protobuf 3.20.3 which is incompatible.\u001b[0m\u001b[31m\n",

            "\u001b[0m"

          ]

        }

      ],

      "source": [

        "# Install required libraries\n",

        "!pip install onnx onnxruntime tf2onnx --quiet"

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "import torch\n",

        "import numpy as np\n",

        "import onnx\n",

        "import onnxruntime as ort\n",

        "from torchvision import datasets, transforms, models\n",

        "from torch.utils.data import DataLoader\n",

        "from sklearn.metrics import precision_score, recall_score, f1_score\n",

        "from google.colab import files"

      ],

      "metadata": {

        "id": "0qNaAqdBus3w"

      },

      "execution_count": 2,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Dataset Directories\n",

        "train_dir = '/content/drive/MyDrive/update dataset/New Chest(5 class)/Train'\n",

        "val_dir = '/content/drive/MyDrive/update dataset/New Chest(5 class)/Val'\n",

        "test_dir = '/content/drive/MyDrive/update dataset/New Chest(5 class)/Test'"

      ],

      "metadata": {

        "id": "yAcg0j20us9W"

      },

      "execution_count": 3,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Hyperparameters\n",

        "num_epochs = 30\n",

        "learning_rate = 1e-4\n",

        "batch_size = 32\n",

        "input_size = 224\n",

        "patience = 5\n",

        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"

      ],

      "metadata": {

        "id": "g1QefxvTus_u"

      },

      "execution_count": 4,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Data Augmentation and Transformations\n",

        "transform_train = transforms.Compose([\n",

        "    transforms.Resize((input_size, input_size)),\n",

        "    transforms.RandomHorizontalFlip(),\n",

        "    transforms.RandomRotation(10),\n",

        "    transforms.RandomResizedCrop(input_size),\n",

        "    transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.2),\n",

        "    transforms.ToTensor(),\n",

        "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",

        "])\n",

        "\n",

        "transform_val_test = transforms.Compose([\n",

        "    transforms.Resize((input_size, input_size)),\n",

        "    transforms.ToTensor(),\n",

        "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",

        "])"

      ],

      "metadata": {

        "id": "80Td29j8utCH"

      },

      "execution_count": 5,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Datasets\n",

        "train_dataset = datasets.ImageFolder(train_dir, transform=transform_train)\n",

        "val_dataset = datasets.ImageFolder(val_dir, transform=transform_val_test)\n",

        "test_dataset = datasets.ImageFolder(test_dir, transform=transform_val_test)"

      ],

      "metadata": {

        "id": "lBT2g4xxutEe"

      },

      "execution_count": 6,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Dataloaders\n",

        "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",

        "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",

        "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"

      ],

      "metadata": {

        "id": "EdGkD6sTutGu"

      },

      "execution_count": 7,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Initialize ResNet101 model\n",

        "model = models.resnet101(pretrained=True)\n",

        "num_features = model.fc.in_features\n",

        "model.fc = torch.nn.Linear(num_features, len(train_dataset.classes))\n",

        "model = model.to(device)\n"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "d6_-08SWutLe",

        "outputId": "b69a12fc-8e1e-4821-d350-53d78923a79b"

      },

      "execution_count": 8,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stderr",

          "text": [

            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",

            "  warnings.warn(\n",

            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet101_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet101_Weights.DEFAULT` to get the most up-to-date weights.\n",

            "  warnings.warn(msg)\n",

            "Downloading: \"https://download.pytorch.org/models/resnet101-63fe2227.pth\" to /root/.cache/torch/hub/checkpoints/resnet101-63fe2227.pth\n",

            "100%|██████████| 171M/171M [00:01<00:00, 157MB/s]\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Print class names\n",

        "class_names = train_dataset.classes\n",

        "print(f\"Classes: {class_names}\")"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "Zkby_asSutOG",

        "outputId": "27f39fec-0d0c-4289-b1e8-1dc282f2b082"

      },

      "execution_count": 9,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "Classes: ['Covid-19', 'Emphysema', 'Healthy', 'Pneumonia', 'Tuberculosis', 'random']\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Loss Function with Class Weights\n",

        "class_counts = [0] * len(train_dataset.classes)\n",

        "for _, label in train_dataset:\n",

        "    class_counts[label] += 1\n",

        "class_weights = torch.tensor(1.0 / np.array(class_counts), dtype=torch.float).to(device)\n",

        "criterion = torch.nn.CrossEntropyLoss(weight=class_weights)"

      ],

      "metadata": {

        "id": "uA5JfDwsutQn"

      },

      "execution_count": 10,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Optimizer and Scheduler\n",

        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",

        "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', patience=3, factor=0.1, verbose=True)"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "sg69GD-qutVu",

        "outputId": "0f3708fb-5838-46b7-c9cd-76807a434eb0"

      },

      "execution_count": 11,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stderr",

          "text": [

            "/usr/local/lib/python3.10/dist-packages/torch/optim/lr_scheduler.py:62: UserWarning: The verbose parameter is deprecated. Please use get_last_lr() to access the learning rate.\n",

            "  warnings.warn(\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Training and Validation Loop\n",

        "checkpoint_path = \"best_resnet101_model.pth\"\n",

        "best_val_accuracy = 0.0\n",

        "epochs_no_improve = 0"

      ],

      "metadata": {

        "id": "3LtoehYPutYO"

      },

      "execution_count": 12,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "for epoch in range(num_epochs):\n",

        "    # Training\n",

        "    model.train()\n",

        "    running_loss = 0.0\n",

        "    correct_train = 0\n",

        "    total_train = 0\n",

        "\n",

        "    for images, labels in train_loader:\n",

        "        images, labels = images.to(device), labels.to(device)\n",

        "\n",

        "        optimizer.zero_grad()\n",

        "        outputs = model(images)\n",

        "        loss = criterion(outputs, labels)\n",

        "        loss.backward()\n",

        "        optimizer.step()\n",

        "\n",

        "        running_loss += loss.item() * images.size(0)\n",

        "        _, preds = torch.max(outputs, 1)\n",

        "        correct_train += (preds == labels).sum().item()\n",

        "        total_train += labels.size(0)\n",

        "\n",

        "    # Validation\n",

        "    model.eval()\n",

        "    val_loss = 0.0\n",

        "    correct_val = 0\n",

        "    total_val = 0\n",

        "    all_preds = []\n",

        "    all_labels = []\n",

        "\n",

        "    with torch.no_grad():\n",

        "        for images, labels in val_loader:\n",

        "            images, labels = images.to(device), labels.to(device)\n",

        "            outputs = model(images)\n",

        "            loss = criterion(outputs, labels)\n",

        "            val_loss += loss.item() * images.size(0)\n",

        "            _, preds = torch.max(outputs, 1)\n",

        "            correct_val += (preds == labels).sum().item()\n",

        "            total_val += labels.size(0)\n",

        "\n",

        "            all_preds.extend(preds.cpu().numpy())\n",

        "            all_labels.extend(labels.cpu().numpy())\n",

        "\n",

        "    # Metrics Calculation\n",

        "    precision = precision_score(all_labels, all_preds, average='weighted')\n",

        "    recall = recall_score(all_labels, all_preds, average='weighted')\n",

        "    f1 = f1_score(all_labels, all_preds, average='weighted')\n",

        "\n",

        "    train_loss = running_loss / total_train\n",

        "    val_loss = val_loss / total_val\n",

        "    train_accuracy = 100 * correct_train / total_train\n",

        "    val_accuracy = 100 * correct_val / total_val\n",

        "\n",

        "    scheduler.step(val_accuracy)\n",

        "\n",

        "    # Checkpoint Saving and Early Stopping\n",

        "    if val_accuracy > best_val_accuracy:\n",

        "        best_val_accuracy = val_accuracy\n",

        "        torch.save(model.state_dict(), checkpoint_path)\n",

        "        epochs_no_improve = 0\n",

        "        print(f\"[INFO] Validation accuracy improved to {val_accuracy:.2f}%, saving model...\")\n",

        "    else:\n",

        "        epochs_no_improve += 1\n",

        "\n",

        "    if epochs_no_improve >= patience:\n",

        "        print(\"[INFO] Early stopping triggered.\")\n",

        "        break\n",

        "\n",

        "    # Epoch Summary\n",

        "    print(f\"Epoch [{epoch+1}/{num_epochs}] \"\n",

        "          f\"Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.2f}%, \"\n",

        "          f\"Val Loss: {val_loss:.4f}, Val Accuracy: {val_accuracy:.2f}%, \"\n",

        "          f\"Precision: {precision:.4f}, Recall: {recall:.4f}, F1-Score: {f1:.4f}\")"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "ShZd_TVywrAQ",

        "outputId": "42729e46-08f3-4799-84fe-2962c95fca4e"

      },

      "execution_count": 13,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "[INFO] Validation accuracy improved to 85.42%, saving model...\n",

            "Epoch [1/30] Train Loss: 0.4114, Train Accuracy: 85.55%, Val Loss: 0.3875, Val Accuracy: 85.42%, Precision: 0.8717, Recall: 0.8542, F1-Score: 0.8530\n",

            "[INFO] Validation accuracy improved to 90.08%, saving model...\n",

            "Epoch [2/30] Train Loss: 0.2748, Train Accuracy: 90.27%, Val Loss: 0.2860, Val Accuracy: 90.08%, Precision: 0.9102, Recall: 0.9008, F1-Score: 0.9025\n",

            "Epoch [3/30] Train Loss: 0.2394, Train Accuracy: 91.41%, Val Loss: 0.3527, Val Accuracy: 87.67%, Precision: 0.8897, Recall: 0.8767, F1-Score: 0.8772\n",

            "Epoch [4/30] Train Loss: 0.2209, Train Accuracy: 92.11%, Val Loss: 0.2776, Val Accuracy: 89.58%, Precision: 0.9090, Recall: 0.8958, F1-Score: 0.8965\n",

            "[INFO] Validation accuracy improved to 91.83%, saving model...\n",

            "Epoch [5/30] Train Loss: 0.1964, Train Accuracy: 93.11%, Val Loss: 0.2259, Val Accuracy: 91.83%, Precision: 0.9243, Recall: 0.9183, F1-Score: 0.9194\n",

            "Epoch [6/30] Train Loss: 0.1962, Train Accuracy: 93.02%, Val Loss: 0.2947, Val Accuracy: 90.75%, Precision: 0.9169, Recall: 0.9075, F1-Score: 0.9082\n",

            "Epoch [7/30] Train Loss: 0.1872, Train Accuracy: 93.32%, Val Loss: 0.3128, Val Accuracy: 90.00%, Precision: 0.9115, Recall: 0.9000, F1-Score: 0.8995\n",

            "Epoch [8/30] Train Loss: 0.1740, Train Accuracy: 93.69%, Val Loss: 0.3236, Val Accuracy: 90.25%, Precision: 0.9173, Recall: 0.9025, F1-Score: 0.9033\n",

            "Epoch [9/30] Train Loss: 0.1553, Train Accuracy: 94.46%, Val Loss: 0.2888, Val Accuracy: 90.17%, Precision: 0.9116, Recall: 0.9017, F1-Score: 0.9016\n",

            "[INFO] Validation accuracy improved to 92.08%, saving model...\n",

            "Epoch [10/30] Train Loss: 0.1164, Train Accuracy: 95.91%, Val Loss: 0.2322, Val Accuracy: 92.08%, Precision: 0.9264, Recall: 0.9208, F1-Score: 0.9211\n",

            "[INFO] Validation accuracy improved to 92.58%, saving model...\n",

            "Epoch [11/30] Train Loss: 0.0950, Train Accuracy: 96.73%, Val Loss: 0.2173, Val Accuracy: 92.58%, Precision: 0.9320, Recall: 0.9258, F1-Score: 0.9263\n",

            "[INFO] Validation accuracy improved to 92.75%, saving model...\n",

            "Epoch [12/30] Train Loss: 0.0924, Train Accuracy: 96.67%, Val Loss: 0.2152, Val Accuracy: 92.75%, Precision: 0.9329, Recall: 0.9275, F1-Score: 0.9278\n",

            "[INFO] Validation accuracy improved to 93.17%, saving model...\n",

            "Epoch [13/30] Train Loss: 0.0840, Train Accuracy: 97.15%, Val Loss: 0.1846, Val Accuracy: 93.17%, Precision: 0.9359, Recall: 0.9317, F1-Score: 0.9322\n",

            "[INFO] Validation accuracy improved to 93.50%, saving model...\n",

            "Epoch [14/30] Train Loss: 0.0814, Train Accuracy: 97.31%, Val Loss: 0.1971, Val Accuracy: 93.50%, Precision: 0.9388, Recall: 0.9350, F1-Score: 0.9353\n",

            "[INFO] Validation accuracy improved to 94.08%, saving model...\n",

            "Epoch [15/30] Train Loss: 0.0787, Train Accuracy: 97.36%, Val Loss: 0.1660, Val Accuracy: 94.08%, Precision: 0.9424, Recall: 0.9408, F1-Score: 0.9411\n",

            "Epoch [16/30] Train Loss: 0.0752, Train Accuracy: 97.43%, Val Loss: 0.2176, Val Accuracy: 92.67%, Precision: 0.9302, Recall: 0.9267, F1-Score: 0.9272\n",

            "Epoch [17/30] Train Loss: 0.0746, Train Accuracy: 97.28%, Val Loss: 0.2189, Val Accuracy: 92.08%, Precision: 0.9267, Recall: 0.9208, F1-Score: 0.9217\n",

            "Epoch [18/30] Train Loss: 0.0741, Train Accuracy: 97.50%, Val Loss: 0.2131, Val Accuracy: 92.58%, Precision: 0.9300, Recall: 0.9258, F1-Score: 0.9264\n",

            "Epoch [19/30] Train Loss: 0.0746, Train Accuracy: 97.47%, Val Loss: 0.2179, Val Accuracy: 93.33%, Precision: 0.9371, Recall: 0.9333, F1-Score: 0.9336\n",

            "[INFO] Early stopping triggered.\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Load the best model\n",

        "model.load_state_dict(torch.load(checkpoint_path))\n",

        "model.eval()\n",

        "print(\"Best model loaded from checkpoint\")\n"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "iMTEZ4r8wrC6",

        "outputId": "c6cf6863-d91c-4a0b-d0ac-bdc7adee899d"

      },

      "execution_count": 14,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stderr",

          "text": [

            "<ipython-input-14-978f4fcb01ca>:2: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",

            "  model.load_state_dict(torch.load(checkpoint_path))\n"

          ]

        },

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "Best model loaded from checkpoint\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Save the PyTorch model and state dictionary\n",

        "torch.save(model, '/content/resnet101_full_model.pth')\n",

        "torch.save(model.state_dict(), '/content/resnet101_state_dict.pth')\n"

      ],

      "metadata": {

        "id": "hoNq--sXwrFb"

      },

      "execution_count": 15,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Convert PyTorch Model to ONNX format\n",

        "onnx_path = '/content/resnet101_model.onnx'\n",

        "dummy_input = torch.randn(1, 3, input_size, input_size).to(device)\n",

        "torch.onnx.export(model, dummy_input, onnx_path, verbose=True, input_names=[\"input\"], output_names=[\"output\"])"

      ],

      "metadata": {

        "id": "_V1uY9wvwrHp"

      },

      "execution_count": 16,

      "outputs": []

    },

    {

      "cell_type": "code",

      "source": [

        "# Verify the ONNX model\n",

        "onnx_model = onnx.load(onnx_path)\n",

        "onnx.checker.check_model(onnx_model)\n",

        "print(\"ONNX model is valid.\")\n"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "IlbAheXlwrKB",

        "outputId": "16c0aa95-2e75-432b-d9ce-5238fce92744"

      },

      "execution_count": 17,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "ONNX model is valid.\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Use ONNX Runtime for inference\n",

        "ort_session = ort.InferenceSession(onnx_path)\n",

        "\n",

        "def predict_onnx(ort_session, image):\n",

        "    input_tensor = image.astype(np.float32)\n",

        "    outputs = ort_session.run(None, {\"input\": input_tensor})\n",

        "    return outputs[0]\n",

        "\n",

        "# Example inference\n",

        "for images, labels in test_loader:\n",

        "    images_np = images.numpy()\n",

        "    predictions = []\n",

        "    for img in images_np:\n",

        "        img_np = np.expand_dims(img, axis=0)\n",

        "        preds = predict_onnx(ort_session, img_np)\n",

        "        predictions.append(np.argmax(preds))\n",

        "    print(f\"Predictions: {predictions}\")\n",

        "    break"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/"

        },

        "id": "MdRS709s3Eb4",

        "outputId": "5aa03a76-a2bf-4d90-fa15-2435ff93544f"

      },

      "execution_count": 18,

      "outputs": [

        {

          "output_type": "stream",

          "name": "stdout",

          "text": [

            "Predictions: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n"

          ]

        }

      ]

    },

    {

      "cell_type": "code",

      "source": [

        "# Download models for deployment\n",

        "files.download('/content/resnet101_full_model.pth')\n",

        "files.download('/content/resnet101_state_dict.pth')\n",

        "files.download(onnx_path)"

      ],

      "metadata": {

        "colab": {

          "base_uri": "https://localhost:8080/",

          "height": 17

        },

        "id": "Tu1q_dy8wrVw",

        "outputId": "398cb159-62ee-4800-8878-b0c2a7e9bd37"

      },

      "execution_count": 19,

      "outputs": [

        {

          "data": {

            "application/javascript": [

              "\n",

              "    async function download(id, filename, size) {\n",

              "      if (!google.colab.kernel.accessAllowed) {\n",

              "        return;\n",

              "      }\n",

              "      const div = document.createElement('div');\n",

              "      const label = document.createElement('label');\n",

              "      label.textContent = `Downloading \"${filename}\": `;\n",

              "      div.appendChild(label);\n",

              "      const progress = document.createElement('progress');\n",

              "      progress.max = size;\n",

              "      div.appendChild(progress);\n",

              "      document.body.appendChild(div);\n",

              "\n",

              "      const buffers = [];\n",

              "      let downloaded = 0;\n",

              "\n",

              "      const channel = await google.colab.kernel.comms.open(id);\n",

              "      // Send a message to notify the kernel that we're ready.\n",

              "      channel.send({})\n",

              "\n",

              "      for await (const message of channel.messages) {\n",

              "        // Send a message to notify the kernel that we're ready.\n",

              "        channel.send({})\n",

              "        if (message.buffers) {\n",

              "          for (const buffer of message.buffers) {\n",

              "            buffers.push(buffer);\n",

              "            downloaded += buffer.byteLength;\n",

              "            progress.value = downloaded;\n",

              "          }\n",

              "        }\n",

              "      }\n",

              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",

              "      const a = document.createElement('a');\n",

              "      a.href = window.URL.createObjectURL(blob);\n",

              "      a.download = filename;\n",

              "      div.appendChild(a);\n",

              "      a.click();\n",

              "      div.remove();\n",

              "    }\n",

              "  "

            ],

            "text/plain": [

              "<IPython.core.display.Javascript object>"

            ]

          },

          "metadata": {},

          "output_type": "display_data"

        },

        {

          "data": {

            "application/javascript": [

              "download(\"download_2676e401-61a4-436d-ac9c-a1fc4cb098c4\", \"resnet101_full_model.pth\", 170735052)"

            ],

            "text/plain": [

              "<IPython.core.display.Javascript object>"

            ]

          },

          "metadata": {},

          "output_type": "display_data"

        },

        {

          "data": {

            "application/javascript": [

              "\n",

              "    async function download(id, filename, size) {\n",

              "      if (!google.colab.kernel.accessAllowed) {\n",

              "        return;\n",

              "      }\n",

              "      const div = document.createElement('div');\n",

              "      const label = document.createElement('label');\n",

              "      label.textContent = `Downloading \"${filename}\": `;\n",

              "      div.appendChild(label);\n",

              "      const progress = document.createElement('progress');\n",

              "      progress.max = size;\n",

              "      div.appendChild(progress);\n",

              "      document.body.appendChild(div);\n",

              "\n",

              "      const buffers = [];\n",

              "      let downloaded = 0;\n",

              "\n",

              "      const channel = await google.colab.kernel.comms.open(id);\n",

              "      // Send a message to notify the kernel that we're ready.\n",

              "      channel.send({})\n",

              "\n",

              "      for await (const message of channel.messages) {\n",

              "        // Send a message to notify the kernel that we're ready.\n",

              "        channel.send({})\n",

              "        if (message.buffers) {\n",

              "          for (const buffer of message.buffers) {\n",

              "            buffers.push(buffer);\n",

              "            downloaded += buffer.byteLength;\n",

              "            progress.value = downloaded;\n",

              "          }\n",

              "        }\n",

              "      }\n",

              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",

              "      const a = document.createElement('a');\n",

              "      a.href = window.URL.createObjectURL(blob);\n",

              "      a.download = filename;\n",

              "      div.appendChild(a);\n",

              "      a.click();\n",

              "      div.remove();\n",

              "    }\n",

              "  "

            ],

            "text/plain": [

              "<IPython.core.display.Javascript object>"

            ]

          },

          "metadata": {},

          "output_type": "display_data"

        },

        {

          "data": {

            "application/javascript": [

              "download(\"download_4a55caaf-b2c4-4798-a186-8a4c0958245b\", \"resnet101_state_dict.pth\", 170685004)"

            ],

            "text/plain": [

              "<IPython.core.display.Javascript object>"

            ]

          },

          "metadata": {},

          "output_type": "display_data"

        },

        {

          "data": {

            "application/javascript": [

              "\n",

              "    async function download(id, filename, size) {\n",

              "      if (!google.colab.kernel.accessAllowed) {\n",

              "        return;\n",

              "      }\n",

              "      const div = document.createElement('div');\n",

              "      const label = document.createElement('label');\n",

              "      label.textContent = `Downloading \"${filename}\": `;\n",

              "      div.appendChild(label);\n",

              "      const progress = document.createElement('progress');\n",

              "      progress.max = size;\n",

              "      div.appendChild(progress);\n",

              "      document.body.appendChild(div);\n",

              "\n",

              "      const buffers = [];\n",

              "      let downloaded = 0;\n",

              "\n",

              "      const channel = await google.colab.kernel.comms.open(id);\n",

              "      // Send a message to notify the kernel that we're ready.\n",

              "      channel.send({})\n",

              "\n",

              "      for await (const message of channel.messages) {\n",

              "        // Send a message to notify the kernel that we're ready.\n",

              "        channel.send({})\n",

              "        if (message.buffers) {\n",

              "          for (const buffer of message.buffers) {\n",

              "            buffers.push(buffer);\n",

              "            downloaded += buffer.byteLength;\n",

              "            progress.value = downloaded;\n",

              "          }\n",

              "        }\n",

              "      }\n",

              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",

              "      const a = document.createElement('a');\n",

              "      a.href = window.URL.createObjectURL(blob);\n",

              "      a.download = filename;\n",

              "      div.appendChild(a);\n",

              "      a.click();\n",

              "      div.remove();\n",

              "    }\n",

              "  "

            ],

            "text/plain": [

              "<IPython.core.display.Javascript object>"

            ]

          },

          "metadata": {},

          "output_type": "display_data"

        },

        {

          "data": {

            "application/javascript": [

              "download(\"download_84479e94-0d0c-41e5-bc32-81e18fc96116\", \"resnet101_model.onnx\", 171040381)"

            ],

            "text/plain": [

              "<IPython.core.display.Javascript object>"

            ]

          },

          "metadata": {},

          "output_type": "display_data"

        }

      ]

    }

  ]

}