JimmyChin1998/Pytorch-Learning-File

1{2 "cells": [3  {4   "cell_type": "code",5   "execution_count": 1,6   "id": "3b6cf083-3c0e-4e09-8c59-33898cf02a56",7   "metadata": {},8   "outputs": [9    {10     "name": "stdout",11     "output_type": "stream",12     "text": [13      "torch version: 2.5.1+cu118\n",14      "torchvision version: 0.20.1+cu118\n"15     ]16    }17   ],18   "source": [19    "# For this notebook to run with updated APIs, we need torch 1.12+ and torchvision 0.13+\n",20    "try:\n",21    "    import torch\n",22    "    import torchvision\n",23    "    print(f\"torch version: {torch.__version__}\")\n",24    "    print(f\"torchvision version: {torchvision.__version__}\")\n",25    "except:\n",26    "    print(f\"[INFO] torch/torchvision versions is not available\")"27   ]28  },29  {30   "cell_type": "code",31   "execution_count": 29,32   "id": "7a6f0792-583a-4184-b562-4e2018cd0248",33   "metadata": {},34   "outputs": [],35   "source": [36    "# Continue with regular imports\n",37    "import matplotlib.pyplot as plt\n",38    "import torch\n",39    "import torchvision\n",40    "\n",41    "from torch import nn\n",42    "from torchvision import transforms\n",43    "\n",44    "# Try to get torchinfo, install it if it doesn't work\n",45    "try:\n",46    "    from torchinfo import summary\n",47    "except:\n",48    "    print(\"[INFO] Couldn't find torchinfo... installing it.\")\n",49    "    !pip install -q torchinfo\n",50    "    from torchinfo import summary\n",51    "\n",52    "# Try to import the going_modular directory, download it from GitHub if it doesn't work\n",53    "try:\n",54    "    from going_modular import data_setup, engine\n",55    "    from helper_functions import download_data, set_seeds, plot_loss_curves\n",56    "except:\n",57    "    # Get the going_modular scripts\n",58    "    print(\"[INFO] Couldn't find going_modular or helper_functions scripts... downloading them from GitHub.\")\n",59    "    !git clone https://github.com/mrdbourke/pytorch-deep-learning\n",60    "    !mv pytorch-deep-learning/going_modular .\n",61    "    !mv pytorch-deep-learning/helper_functions.py . # get the helper_functions.py script\n",62    "    !rm -rf pytorch-deep-learning\n",63    "    from going_modular.going_modular import data_setup, engine\n",64    "    from helper_functions import download_data, set_seeds, plot_loss_curves"65   ]66  },67  {68   "cell_type": "code",69   "execution_count": 17,70   "id": "374e0096-9231-4ae9-80f0-4697ddea6042",71   "metadata": {},72   "outputs": [73    {74     "data": {75      "text/plain": [76       "'cuda'"77      ]78     },79     "execution_count": 17,80     "metadata": {},81     "output_type": "execute_result"82    }83   ],84   "source": [85    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",86    "device"87   ]88  },89  {90   "cell_type": "code",91   "execution_count": 5,92   "id": "2ea81a7e-ab88-4841-aa54-1bd234545c20",93   "metadata": {},94   "outputs": [95    {96     "name": "stdout",97     "output_type": "stream",98     "text": [99      "Writing demos/foodvision_EfficientNet_B4/model.py\n"100     ]101    }102   ],103   "source": [104    "%%writefile demos/foodvision_EfficientNet_B4/model.py\n",105    "import torch\n",106    "import torchvision\n",107    "\n",108    "from torch import nn\n",109    "\n",110    "def create_effnetb4_model(num_classes: int = 3, \n",111    "                          seed: int = 42):\n",112    "    \"\"\"Creates an EfficientNetB4 feature extractor model and transforms.\n",113    "\n",114    "    Args:\n",115    "        num_classes (int, optional): number of classes in the classifier head. \n",116    "            Defaults to 3.\n",117    "        seed (int, optional): random seed value. Defaults to 42.\n",118    "\n",119    "    Returns:\n",120    "        model (torch.nn.Module): EffNetB4 feature extractor model. \n",121    "        transforms (torchvision.transforms): EffNetB4 image transforms.\n",122    "    \"\"\"\n",123    "    # Create EffNetB4 pretrained weights, transforms and model\n",124    "    weights = torchvision.models.EfficientNet_B4_Weights.DEFAULT\n",125    "    transforms = weights.transforms()\n",126    "    model = torchvision.models.efficientnet_b4(weights=weights)\n",127    "\n",128    "    # Freeze all layers in base model\n",129    "    for param in model.parameters():\n",130    "        param.requires_grad = False\n",131    "\n",132    "    # Change classifier head with random seed for reproducibility\n",133    "    torch.manual_seed(seed)\n",134    "    model.classifier = nn.Sequential(\n",135    "        nn.Dropout(p=0.3, inplace=True),\n",136    "        nn.Linear(in_features=1792, out_features=num_classes),  # EfficientNetB4 uses 1792 features\n",137    "    )\n",138    "    \n",139    "    return model, transforms\n"140   ]141  },142  {143   "cell_type": "code",144   "execution_count": 6,145   "id": "3239b575-9069-4e21-a45a-42cb2d841e28",146   "metadata": {},147   "outputs": [148    {149     "name": "stderr",150     "output_type": "stream",151     "text": [152      "Downloading: \"https://download.pytorch.org/models/efficientnet_b4_rwightman-23ab8bcd.pth\" to C:\\Users\\User/.cache\\torch\\hub\\checkpoints\\efficientnet_b4_rwightman-23ab8bcd.pth\n",153      "100%|█████████████████████████████████████████████████████████████████████████████| 74.5M/74.5M [00:06<00:00, 11.7MB/s]\n"154     ]155    }156   ],157   "source": [158    "effnetb4_food101, effnetb4_transforms = create_effnetb4_model(num_classes=101)"159   ]160  },161  {162   "cell_type": "code",163   "execution_count": 7,164   "id": "2da37181-179b-46fc-8f16-05b4705103c1",165   "metadata": {166    "scrolled": true167   },168   "outputs": [169    {170     "data": {171      "text/plain": [172       "============================================================================================================================================\n",173       "Layer (type (var_name))                                      Input Shape          Output Shape         Param #              Trainable\n",174       "============================================================================================================================================\n",175       "EfficientNet (EfficientNet)                                  [1, 3, 224, 224]     [1, 101]             --                   Partial\n",176       "├─Sequential (features)                                      [1, 3, 224, 224]     [1, 1792, 7, 7]      --                   False\n",177       "│    └─Conv2dNormActivation (0)                              [1, 3, 224, 224]     [1, 48, 112, 112]    --                   False\n",178       "│    │    └─Conv2d (0)                                       [1, 3, 224, 224]     [1, 48, 112, 112]    (1,296)              False\n",179       "│    │    └─BatchNorm2d (1)                                  [1, 48, 112, 112]    [1, 48, 112, 112]    (96)                 False\n",180       "│    │    └─SiLU (2)                                         [1, 48, 112, 112]    [1, 48, 112, 112]    --                   --\n",181       "│    └─Sequential (1)                                        [1, 48, 112, 112]    [1, 24, 112, 112]    --                   False\n",182       "│    │    └─MBConv (0)                                       [1, 48, 112, 112]    [1, 24, 112, 112]    (2,940)              False\n",183       "│    │    └─MBConv (1)                                       [1, 24, 112, 112]    [1, 24, 112, 112]    (1,206)              False\n",184       "│    └─Sequential (2)                                        [1, 24, 112, 112]    [1, 32, 56, 56]      --                   False\n",185       "│    │    └─MBConv (0)                                       [1, 24, 112, 112]    [1, 32, 56, 56]      (11,878)             False\n",186       "│    │    └─MBConv (1)                                       [1, 32, 56, 56]      [1, 32, 56, 56]      (18,120)             False\n",187       "│    │    └─MBConv (2)                                       [1, 32, 56, 56]      [1, 32, 56, 56]      (18,120)             False\n",188       "│    │    └─MBConv (3)                                       [1, 32, 56, 56]      [1, 32, 56, 56]      (18,120)             False\n",189       "│    └─Sequential (3)                                        [1, 32, 56, 56]      [1, 56, 28, 28]      --                   False\n",190       "│    │    └─MBConv (0)                                       [1, 32, 56, 56]      [1, 56, 28, 28]      (25,848)             False\n",191       "│    │    └─MBConv (1)                                       [1, 56, 28, 28]      [1, 56, 28, 28]      (57,246)             False\n",192       "│    │    └─MBConv (2)                                       [1, 56, 28, 28]      [1, 56, 28, 28]      (57,246)             False\n",193       "│    │    └─MBConv (3)                                       [1, 56, 28, 28]      [1, 56, 28, 28]      (57,246)             False\n",194       "│    └─Sequential (4)                                        [1, 56, 28, 28]      [1, 112, 14, 14]     --                   False\n",195       "│    │    └─MBConv (0)                                       [1, 56, 28, 28]      [1, 112, 14, 14]     (70,798)             False\n",196       "│    │    └─MBConv (1)                                       [1, 112, 14, 14]     [1, 112, 14, 14]     (197,820)            False\n",197       "│    │    └─MBConv (2)                                       [1, 112, 14, 14]     [1, 112, 14, 14]     (197,820)            False\n",198       "│    │    └─MBConv (3)                                       [1, 112, 14, 14]     [1, 112, 14, 14]     (197,820)            False\n",199       "│    │    └─MBConv (4)                                       [1, 112, 14, 14]     [1, 112, 14, 14]     (197,820)            False\n",200       "│    │    └─MBConv (5)                                       [1, 112, 14, 14]     [1, 112, 14, 14]     (197,820)            False\n",201       "│    └─Sequential (5)                                        [1, 112, 14, 14]     [1, 160, 14, 14]     --                   False\n",202       "│    │    └─MBConv (0)                                       [1, 112, 14, 14]     [1, 160, 14, 14]     (240,924)            False\n",203       "│    │    └─MBConv (1)                                       [1, 160, 14, 14]     [1, 160, 14, 14]     (413,160)            False\n",204       "│    │    └─MBConv (2)                                       [1, 160, 14, 14]     [1, 160, 14, 14]     (413,160)            False\n",205       "│    │    └─MBConv (3)                                       [1, 160, 14, 14]     [1, 160, 14, 14]     (413,160)            False\n",206       "│    │    └─MBConv (4)                                       [1, 160, 14, 14]     [1, 160, 14, 14]     (413,160)            False\n",207       "│    │    └─MBConv (5)                                       [1, 160, 14, 14]     [1, 160, 14, 14]     (413,160)            False\n",208       "│    └─Sequential (6)                                        [1, 160, 14, 14]     [1, 272, 7, 7]       --                   False\n",209       "│    │    └─MBConv (0)                                       [1, 160, 14, 14]     [1, 272, 7, 7]       (520,904)            False\n",210       "│    │    └─MBConv (1)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",211       "│    │    └─MBConv (2)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",212       "│    │    └─MBConv (3)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",213       "│    │    └─MBConv (4)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",214       "│    │    └─MBConv (5)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",215       "│    │    └─MBConv (6)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",216       "│    │    └─MBConv (7)                                       [1, 272, 7, 7]       [1, 272, 7, 7]       (1,159,332)          False\n",217       "│    └─Sequential (7)                                        [1, 272, 7, 7]       [1, 448, 7, 7]       --                   False\n",218       "│    │    └─MBConv (0)                                       [1, 272, 7, 7]       [1, 448, 7, 7]       (1,420,804)          False\n",219       "│    │    └─MBConv (1)                                       [1, 448, 7, 7]       [1, 448, 7, 7]       (3,049,200)          False\n",220       "│    └─Conv2dNormActivation (8)                              [1, 448, 7, 7]       [1, 1792, 7, 7]      --                   False\n",221       "│    │    └─Conv2d (0)                                       [1, 448, 7, 7]       [1, 1792, 7, 7]      (802,816)            False\n",222       "│    │    └─BatchNorm2d (1)                                  [1, 1792, 7, 7]      [1, 1792, 7, 7]      (3,584)              False\n",223       "│    │    └─SiLU (2)                                         [1, 1792, 7, 7]      [1, 1792, 7, 7]      --                   --\n",224       "├─AdaptiveAvgPool2d (avgpool)                                [1, 1792, 7, 7]      [1, 1792, 1, 1]      --                   --\n",225       "├─Sequential (classifier)                                    [1, 1792]            [1, 101]             --                   True\n",226       "│    └─Dropout (0)                                           [1, 1792]            [1, 1792]            --                   --\n",227       "│    └─Linear (1)                                            [1, 1792]            [1, 101]             181,093              True\n",228       "============================================================================================================================================\n",229       "Total params: 17,729,709\n",230       "Trainable params: 181,093\n",231       "Non-trainable params: 17,548,616\n",232       "Total mult-adds (Units.GIGABYTES): 1.50\n",233       "============================================================================================================================================\n",234       "Input size (MB): 0.60\n",235       "Forward/backward pass size (MB): 272.49\n",236       "Params size (MB): 70.92\n",237       "Estimated Total Size (MB): 344.01\n",238       "============================================================================================================================================"239      ]240     },241     "execution_count": 7,242     "metadata": {},243     "output_type": "execute_result"244    }245   ],246   "source": [247    "from torchinfo import summary\n",248    "\n",249    "# # Get a summary of EffNetB2 feature extractor for Food101 with 101 output classes (uncomment for full output)\n",250    "summary(effnetb4_food101, \n",251    "        input_size=(1, 3, 224, 224),\n",252    "        col_names=[\"input_size\", \"output_size\", \"num_params\", \"trainable\"],\n",253    "        col_width=20,\n",254    "        row_settings=[\"var_names\"])"255   ]256  },257  {258   "cell_type": "code",259   "execution_count": 8,260   "id": "23bd126b-fc5a-497d-bb92-abbf7bb1ef29",261   "metadata": {},262   "outputs": [],263   "source": [264    "# Create Food101 training data transforms (only perform data augmentation on the training images)\n",265    "food101_train_transforms = torchvision.transforms.Compose([\n",266    "    torchvision.transforms.TrivialAugmentWide(),\n",267    "    effnetb4_transforms,\n",268    "])"269   ]270  },271  {272   "cell_type": "code",273   "execution_count": 9,274   "id": "10142abc-6621-4845-a257-5a257748d58a",275   "metadata": {},276   "outputs": [277    {278     "name": "stdout",279     "output_type": "stream",280     "text": [281      "Training transforms:\n",282      "Compose(\n",283      "    TrivialAugmentWide(num_magnitude_bins=31, interpolation=InterpolationMode.NEAREST, fill=None)\n",284      "    ImageClassification(\n",285      "    crop_size=[380]\n",286      "    resize_size=[384]\n",287      "    mean=[0.485, 0.456, 0.406]\n",288      "    std=[0.229, 0.224, 0.225]\n",289      "    interpolation=InterpolationMode.BICUBIC\n",290      ")\n",291      ")\n",292      "\n",293      "Testing transforms:\n",294      "ImageClassification(\n",295      "    crop_size=[380]\n",296      "    resize_size=[384]\n",297      "    mean=[0.485, 0.456, 0.406]\n",298      "    std=[0.229, 0.224, 0.225]\n",299      "    interpolation=InterpolationMode.BICUBIC\n",300      ")\n"301     ]302    }303   ],304   "source": [305    "print(f\"Training transforms:\\n{food101_train_transforms}\\n\") \n",306    "print(f\"Testing transforms:\\n{effnetb4_transforms}\")"307   ]308  },309  {310   "cell_type": "code",311   "execution_count": 11,312   "id": "9ddd0099-b96d-4dca-af1f-e8659fc1572b",313   "metadata": {},314   "outputs": [],315   "source": [316    "from torchvision import datasets\n",317    "\n",318    "# Setup data directory\n",319    "from pathlib import Path\n",320    "data_dir = Path(\"data\")\n",321    "\n",322    "# Get training data (~750 images x 101 food classes)\n",323    "train_data = datasets.Food101(root=data_dir, # path to download data to\n",324    "                              split=\"train\", # dataset split to get\n",325    "                              transform=food101_train_transforms, # perform data augmentation on training data\n",326    "                              download=True) # want to download?\n",327    "\n",328    "# Get testing data (~250 images x 101 food classes)\n",329    "test_data = datasets.Food101(root=data_dir,\n",330    "                             split=\"test\",\n",331    "                             transform=effnetb4_transforms, # perform normal EffNetB2 transforms on test data\n",332    "                             download=True)"333   ]334  },335  {336   "cell_type": "code",337   "execution_count": 12,338   "id": "9db8b0fd-6274-4e38-bb83-24d34afaa109",339   "metadata": {},340   "outputs": [341    {342     "data": {343      "text/plain": [344       "['apple_pie',\n",345       " 'baby_back_ribs',\n",346       " 'baklava',\n",347       " 'beef_carpaccio',\n",348       " 'beef_tartare',\n",349       " 'beet_salad',\n",350       " 'beignets',\n",351       " 'bibimbap',\n",352       " 'bread_pudding',\n",353       " 'breakfast_burrito']"354      ]355     },356     "execution_count": 12,357     "metadata": {},358     "output_type": "execute_result"359    }360   ],361   "source": [362    "# Get Food101 class names\n",363    "food101_class_names = train_data.classes\n",364    "\n",365    "# View the first 10\n",366    "food101_class_names[:10]"367   ]368  },369  {370   "cell_type": "code",371   "execution_count": 13,372   "id": "dc65c3c6-341b-491b-a338-6afff4deb6b2",373   "metadata": {},374   "outputs": [375    {376     "data": {377      "text/plain": [378       "(75750, 25250)"379      ]380     },381     "execution_count": 13,382     "metadata": {},383     "output_type": "execute_result"384    }385   ],386   "source": [387    "len(train_data), len(test_data)"388   ]389  },390  {391   "cell_type": "code",392   "execution_count": 15,393   "id": "e92762a7-a2ae-4321-be8d-f3a4e72d8c47",394   "metadata": {},395   "outputs": [],396   "source": [397    "import os\n",398    "import torch\n",399    "\n",400    "BATCH_SIZE = 24 # 從32調整至24減少顯存壓力\n",401    "NUM_WORKERS = 2 if os.cpu_count() <= 4 else 4 # this value is very experimental and will depend on the hardware you have available, Google Colab generally provides 2x CPUs\n",402    "\n",403    "# Create Food101 20 percent training DataLoader\n",404    "train_dataloader_food101 = torch.utils.data.DataLoader(train_data,\n",405    "                                                                  batch_size=BATCH_SIZE,\n",406    "                                                                  shuffle=True,\n",407    "                                                                  num_workers=NUM_WORKERS)\n",408    "# Create Food101 20 percent testing DataLoader\n",409    "test_dataloader_food101 = torch.utils.data.DataLoader(test_data,\n",410    "                                                                 batch_size=BATCH_SIZE,\n",411    "                                                                 shuffle=False,\n",412    "                                                                 num_workers=NUM_WORKERS)"413   ]414  },415  {416   "cell_type": "code",417   "execution_count": 18,418   "id": "5f6c3a8b-2e77-4632-9ed8-996cef860ac8",419   "metadata": {},420   "outputs": [421    {422     "data": {423      "application/vnd.jupyter.widget-view+json": {424       "model_id": "a0297f87af20472786ebcec49ac131cc",425       "version_major": 2,426       "version_minor": 0427      },428      "text/plain": [429       "  0%|          | 0/10 [00:00<?, ?it/s]"430      ]431     },432     "metadata": {},433     "output_type": "display_data"434    },435    {436     "name": "stdout",437     "output_type": "stream",438     "text": [439      "Epoch: 1 | train_loss: 3.2011 | train_acc: 0.4200 | test_loss: 2.2722 | test_acc: 0.6196\n",440      "Epoch: 2 | train_loss: 2.5285 | train_acc: 0.5287 | test_loss: 2.0222 | test_acc: 0.6650\n",441      "Epoch: 3 | train_loss: 2.3976 | train_acc: 0.5560 | test_loss: 1.9475 | test_acc: 0.6832\n",442      "Epoch: 4 | train_loss: 2.3361 | train_acc: 0.5714 | test_loss: 1.9010 | test_acc: 0.6973\n",443      "Epoch: 5 | train_loss: 2.2962 | train_acc: 0.5794 | test_loss: 1.8641 | test_acc: 0.7063\n",444      "Epoch: 6 | train_loss: 2.2765 | train_acc: 0.5869 | test_loss: 1.8417 | test_acc: 0.7118\n",445      "Epoch: 7 | train_loss: 2.2565 | train_acc: 0.5926 | test_loss: 1.8357 | test_acc: 0.7143\n",446      "Epoch: 8 | train_loss: 2.2419 | train_acc: 0.5956 | test_loss: 1.8266 | test_acc: 0.7160\n",447      "Epoch: 9 | train_loss: 2.2266 | train_acc: 0.6016 | test_loss: 1.8114 | test_acc: 0.7202\n",448      "Epoch: 10 | train_loss: 2.2186 | train_acc: 0.6019 | test_loss: 1.8057 | test_acc: 0.7243\n"449     ]450    }451   ],452   "source": [453    "from going_modular import engine\n",454    "\n",455    "# Adjust learning rate for new batch size\n",456    "new_lr = 1e-3 * (24 / 32)  # 0.75e-3\n",457    "\n",458    "# Setup optimizer\n",459    "optimizer = torch.optim.Adam(params=effnetb4_food101.parameters(),\n",460    "                             lr=new_lr)\n",461    "# Setup loss function\n",462    "loss_fn = torch.nn.CrossEntropyLoss(label_smoothing=0.1) # throw in a little label smoothing because so many classes\n",463    "\n",464    "set_seeds()    \n",465    "effnetb4_food101_results = engine.train(model=effnetb4_food101,\n",466    "                                        train_dataloader=train_dataloader_food101,\n",467    "                                        test_dataloader=test_dataloader_food101,\n",468    "                                        optimizer=optimizer,\n",469    "                                        loss_fn=loss_fn,\n",470    "                                        epochs=10,\n",471    "                                        device=device)"472   ]473  },474  {475   "cell_type": "code",476   "execution_count": 19,477   "id": "7fdeebae-966b-42ca-bc19-3e12995946ac",478   "metadata": {},479   "outputs": [480    {481     "data": {482      "image/png": "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",483      "text/plain": [484       "<Figure size 1500x700 with 2 Axes>"485      ]486     },487     "metadata": {},488     "output_type": "display_data"489    }490   ],491   "source": [492    "from helper_functions import plot_loss_curves\n",493    "\n",494    "# Check out the loss curves for FoodVision Big\n",495    "plot_loss_curves(effnetb4_food101_results)"496   ]497  },498  {499   "cell_type": "code",500   "execution_count": 20,501   "id": "c7ce3e64-0587-46e6-8006-2fbb3b4a7ba5",502   "metadata": {},503   "outputs": [504    {505     "name": "stdout",506     "output_type": "stream",507     "text": [508      "[INFO] Saving model to: models\\effnetb4_food101.pth\n"509     ]510    }511   ],512   "source": [513    "from going_modular import utils\n",514    "\n",515    "# Create a model path\n",516    "effnetb4_food101_model_path = \"effnetb4_food101.pth\" \n",517    "\n",518    "# Save FoodVision Big model\n",519    "utils.save_model(model=effnetb4_food101,\n",520    "                 target_dir=\"models\",\n",521    "                 model_name=effnetb4_food101_model_path)"522   ]523  },524  {525   "cell_type": "code",526   "execution_count": 21,527   "id": "ab324b7c-e71b-4203-a6b4-8b42d7d7c7d8",528   "metadata": {},529   "outputs": [530    {531     "name": "stdout",532     "output_type": "stream",533     "text": [534      "Pretrained EffNetB2 feature extractor Food101 model size: 68 MB\n"535     ]536    }537   ],538   "source": [539    "from pathlib import Path\n",540    "\n",541    "# Get the model size in bytes then convert to megabytes\n",542    "pretrained_effnetb4_food101_model_size = Path(\"models\", effnetb4_food101_model_path).stat().st_size // (1024*1024) # division converts bytes to megabytes (roughly) \n",543    "print(f\"Pretrained EffNetB2 feature extractor Food101 model size: {pretrained_effnetb4_food101_model_size} MB\")"544   ]545  },546  {547   "cell_type": "code",548   "execution_count": 24,549   "id": "8ba7d7ad-1484-472e-bce7-1d86aa1ae555",550   "metadata": {},551   "outputs": [],552   "source": [553    "from pathlib import Path\n",554    "\n",555    "# Create FoodVision Big demo path\n",556    "foodvision_big_demo_path = Path(\"demos/foodvision_EfficientNet_B4/\")\n",557    "\n",558    "# Make FoodVision Big demo examples directory\n",559    "(foodvision_big_demo_path / \"examples\").mkdir(parents=True, exist_ok=True)"560   ]561  },562  {563   "cell_type": "code",564   "execution_count": 25,565   "id": "226455a4-abc1-4296-8d47-c9dfff99d0b2",566   "metadata": {},567   "outputs": [568    {569     "data": {570      "text/plain": [571       "['apple_pie',\n",572       " 'baby_back_ribs',\n",573       " 'baklava',\n",574       " 'beef_carpaccio',\n",575       " 'beef_tartare',\n",576       " 'beet_salad',\n",577       " 'beignets',\n",578       " 'bibimbap',\n",579       " 'bread_pudding',\n",580       " 'breakfast_burrito']"581      ]582     },583     "execution_count": 25,584     "metadata": {},585     "output_type": "execute_result"586    }587   ],588   "source": [589    "# Check out the first 10 Food101 class names\n",590    "food101_class_names[:10]"591   ]592  },593  {594   "cell_type": "code",595   "execution_count": 26,596   "id": "5f69e1a6-d00f-43f9-a9b8-23663b0fd6d9",597   "metadata": {},598   "outputs": [599    {600     "name": "stdout",601     "output_type": "stream",602     "text": [603      "[INFO] Saving Food101 class names to demos\\foodvision_EfficientNet_B4\\class_names.txt\n"604     ]605    }606   ],607   "source": [608    "# Create path to Food101 class names\n",609    "foodvision_big_class_names_path = foodvision_big_demo_path / \"class_names.txt\"\n",610    "\n",611    "# Write Food101 class names list to file\n",612    "with open(foodvision_big_class_names_path, \"w\") as f:\n",613    "    print(f\"[INFO] Saving Food101 class names to {foodvision_big_class_names_path}\")\n",614    "    f.write(\"\\n\".join(food101_class_names)) # leave a new line between each class"615   ]616  },617  {618   "cell_type": "code",619   "execution_count": 27,620   "id": "2d1819cc-aeea-4c45-a85f-a0f6d900e527",621   "metadata": {},622   "outputs": [623    {624     "data": {625      "text/plain": [626       "['apple_pie', 'baby_back_ribs', 'baklava', 'beef_carpaccio', 'beef_tartare']"627      ]628     },629     "execution_count": 27,630     "metadata": {},631     "output_type": "execute_result"632    }633   ],634   "source": [635    "# Open Food101 class names file and read each line into a list\n",636    "with open(foodvision_big_class_names_path, \"r\") as f:\n",637    "    food101_class_names_loaded = [food.strip() for food in  f.readlines()]\n",638    "    \n",639    "# View the first 5 class names loaded back in\n",640    "food101_class_names_loaded[:5]"641   ]642  },643  {644   "cell_type": "code",645   "execution_count": 28,646   "id": "9e492162-6b11-4362-9278-cad3562ba33e",647   "metadata": {},648   "outputs": [649    {650     "name": "stdout",651     "output_type": "stream",652     "text": [653      "Writing demos/foodvision_EfficientNet_B4/app.py\n"654     ]655    }656   ],657   "source": [658    "%%writefile demos/foodvision_EfficientNet_B4/app.py\n",659    "### 1. Imports and class names setup ### \n",660    "import gradio as gr\n",661    "import os\n",662    "import torch\n",663    "\n",664    "from model import create_effnetb2_model\n",665    "from timeit import default_timer as timer\n",666    "from typing import Tuple, Dict\n",667    "\n",668    "# Setup class names\n",669    "with open(\"class_names.txt\", \"r\") as f: # reading them in from class_names.txt\n",670    "    class_names = [food_name.strip() for food_name in  f.readlines()]\n",671    "    \n",672    "### 2. Model and transforms preparation ###    \n",673    "\n",674    "# Create model\n",675    "effnetb4, effnetb4_transforms = create_effnetb4_model(\n",676    "    num_classes=101, # could also use len(class_names)\n",677    ")\n",678    "\n",679    "# Load saved weights\n",680    "effnetb4.load_state_dict(\n",681    "    torch.load(\n",682    "        f=\"effnetb4_food101.pth\",\n",683    "        map_location=torch.device(\"cpu\"),  # load to CPU\n",684    "    )\n",685    ")\n",686    "\n",687    "### 3. Predict function ###\n",688    "\n",689    "# Create predict function\n",690    "def predict(img) -> Tuple[Dict, float]:\n",691    "    \"\"\"Transforms and performs a prediction on img and returns prediction and time taken.\n",692    "    \"\"\"\n",693    "    # Start the timer\n",694    "    start_time = timer()\n",695    "    \n",696    "    # Transform the target image and add a batch dimension\n",697    "    img = effnetb4_transforms(img).unsqueeze(0)\n",698    "    \n",699    "    # Put model into evaluation mode and turn on inference mode\n",700    "    effnetb4.eval()\n",701    "    with torch.inference_mode():\n",702    "        # Pass the transformed image through the model and turn the prediction logits into prediction probabilities\n",703    "        pred_probs = torch.softmax(effnetb4(img), dim=1)\n",704    "    \n",705    "    # Create a prediction label and prediction probability dictionary for each prediction class (this is the required format for Gradio's output parameter)\n",706    "    pred_labels_and_probs = {class_names[i]: float(pred_probs[0][i]) for i in range(len(class_names))}\n",707    "    \n",708    "    # Calculate the prediction time\n",709    "    pred_time = round(timer() - start_time, 5)\n",710    "    \n",711    "    # Return the prediction dictionary and prediction time \n",712    "    return pred_labels_and_probs, pred_time\n",713    "\n",714    "### 4. Gradio app ###\n",715    "\n",716    "# Create title, description and article strings\n",717    "title = \"Food101Vision 🍔\"\n",718    "description = \"An EfficientNetB4 feature extractor computer vision model to classify images of food into 101 different classes (Food101)\"\n",719    "# Create examples list from \"examples/\" directory\n",720    "example_list = [[\"examples/\" + example] for example in os.listdir(\"examples\")]\n",721    "\n",722    "# Create Gradio interface \n",723    "demo = gr.Interface(\n",724    "    fn=predict,\n",725    "    inputs=gr.Image(type=\"pil\"),\n",726    "    outputs=[\n",727    "        gr.Label(num_top_classes=5, label=\"Predictions\"),\n",728    "        gr.Number(label=\"Prediction time (s)\"),\n",729    "    ],\n",730    "    examples=example_list,\n",731    "    title=title,\n",732    "    description=description\n",733    ")\n",734    "\n",735    "# Launch the app!\n",736    "demo.launch(debug=False) # Don't need share=True in Hugging Face"737   ]738  },739  {740   "cell_type": "code",741   "execution_count": null,742   "id": "ec37a50e-163e-464b-beca-74ffe72517d5",743   "metadata": {},744   "outputs": [],745   "source": [746    "%%writefile demos/foodvision_EfficientNet_B4/requirements.txt\n",747    "torch==1.12.0\n",748    "torchvision==0.13.0\n",749    "gradio==3.1.4"750   ]751  }752 ],753 "metadata": {754  "kernelspec": {755   "display_name": "Python 3 (ipykernel)",756   "language": "python",757   "name": "python3"758  },759  "language_info": {760   "codemirror_mode": {761    "name": "ipython",762    "version": 3763   },764   "file_extension": ".py",765   "mimetype": "text/x-python",766   "name": "python",767   "nbconvert_exporter": "python",768   "pygments_lexer": "ipython3",769   "version": "3.12.7"770  }771 },772 "nbformat": 4,773 "nbformat_minor": 5774}775