Added the file Architectures

.gitignore

@@ -3,6 +3,9 @@ flagged/
 *.png
 *.jpg
 *.jpeg
+*.pyc
 gradio_cache/
 
 venv/
+__pychache__/
+

app.py

@@ -1,7 +1,56 @@
 import gradio as gr
+import torch
+import numpy as np
 
-def greet(name):
-    return "Hello " + name + "!!"
+from model import *
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+def load_cub200_classes():
+    """
+    This function loads the classes from the classes.txt file and returns a dictionary
+    """
+    with open("classes.txt", encoding="utf-8") as f:
+        classes = f.read().splitlines()
+
+    # convert classes to dictionary separating the lines by the first space
+    classes = {int(line.split(" ")[0]) : line.split(" ")[1] for line in classes}
+
+    # return the classes dictionary
+    return classes
+
+def load_model():
+    """
+    This function loads the trained model and returns it
+    """
+
+    # load the resnet model
+    model = resnet50(pretrained=False, stride=[1, 2, 2, 1], num_classes=200)
+    # load the trained weights
+    model.load_state_dict(torch.load("resnet.pt", map_location=torch.device('cpu')))
+    # set the model to evaluation mode
+    model.eval()
+    # return the model
+    return model
+
+def predict_image(image):
+    """
+    This function takes an image as input and returns the class label
+    """
+
+    # load the model
+    model = load_model()
+    # load the classes
+    classes = load_cub200_classes()
+
+    # convert image to tensor
+    tensor = torch.from_numpy(image).permute(2, 0, 1).float().unsqueeze(0)
+    # make prediction
+    prediction = model(tensor).detach().numpy()[0]
+    # convert prediction to probabilities
+    probabilities = np.exp(prediction) / np.sum(np.exp(prediction))
+    # get the class with the highest probability
+    class_idx = np.argmax(probabilities)
+    # return the class label
+    return "Class: " + classes[class_idx]
+
+# create a gradio interface
+gr.Interface(fn=predict_image, inputs="image", outputs="text").launch()

classes.txt

@@ -0,0 +1,200 @@
+1 001.Black_footed_Albatross
+2 002.Laysan_Albatross
+3 003.Sooty_Albatross
+4 004.Groove_billed_Ani
+5 005.Crested_Auklet
+6 006.Least_Auklet
+7 007.Parakeet_Auklet
+8 008.Rhinoceros_Auklet
+9 009.Brewer_Blackbird
+10 010.Red_winged_Blackbird
+11 011.Rusty_Blackbird
+12 012.Yellow_headed_Blackbird
+13 013.Bobolink
+14 014.Indigo_Bunting
+15 015.Lazuli_Bunting
+16 016.Painted_Bunting
+17 017.Cardinal
+18 018.Spotted_Catbird
+19 019.Gray_Catbird
+20 020.Yellow_breasted_Chat
+21 021.Eastern_Towhee
+22 022.Chuck_will_Widow
+23 023.Brandt_Cormorant
+24 024.Red_faced_Cormorant
+25 025.Pelagic_Cormorant
+26 026.Bronzed_Cowbird
+27 027.Shiny_Cowbird
+28 028.Brown_Creeper
+29 029.American_Crow
+30 030.Fish_Crow
+31 031.Black_billed_Cuckoo
+32 032.Mangrove_Cuckoo
+33 033.Yellow_billed_Cuckoo
+34 034.Gray_crowned_Rosy_Finch
+35 035.Purple_Finch
+36 036.Northern_Flicker
+37 037.Acadian_Flycatcher
+38 038.Great_Crested_Flycatcher
+39 039.Least_Flycatcher
+40 040.Olive_sided_Flycatcher
+41 041.Scissor_tailed_Flycatcher
+42 042.Vermilion_Flycatcher
+43 043.Yellow_bellied_Flycatcher
+44 044.Frigatebird
+45 045.Northern_Fulmar
+46 046.Gadwall
+47 047.American_Goldfinch
+48 048.European_Goldfinch
+49 049.Boat_tailed_Grackle
+50 050.Eared_Grebe
+51 051.Horned_Grebe
+52 052.Pied_billed_Grebe
+53 053.Western_Grebe
+54 054.Blue_Grosbeak
+55 055.Evening_Grosbeak
+56 056.Pine_Grosbeak
+57 057.Rose_breasted_Grosbeak
+58 058.Pigeon_Guillemot
+59 059.California_Gull
+60 060.Glaucous_winged_Gull
+61 061.Heermann_Gull
+62 062.Herring_Gull
+63 063.Ivory_Gull
+64 064.Ring_billed_Gull
+65 065.Slaty_backed_Gull
+66 066.Western_Gull
+67 067.Anna_Hummingbird
+68 068.Ruby_throated_Hummingbird
+69 069.Rufous_Hummingbird
+70 070.Green_Violetear
+71 071.Long_tailed_Jaeger
+72 072.Pomarine_Jaeger
+73 073.Blue_Jay
+74 074.Florida_Jay
+75 075.Green_Jay
+76 076.Dark_eyed_Junco
+77 077.Tropical_Kingbird
+78 078.Gray_Kingbird
+79 079.Belted_Kingfisher
+80 080.Green_Kingfisher
+81 081.Pied_Kingfisher
+82 082.Ringed_Kingfisher
+83 083.White_breasted_Kingfisher
+84 084.Red_legged_Kittiwake
+85 085.Horned_Lark
+86 086.Pacific_Loon
+87 087.Mallard
+88 088.Western_Meadowlark
+89 089.Hooded_Merganser
+90 090.Red_breasted_Merganser
+91 091.Mockingbird
+92 092.Nighthawk
+93 093.Clark_Nutcracker
+94 094.White_breasted_Nuthatch
+95 095.Baltimore_Oriole
+96 096.Hooded_Oriole
+97 097.Orchard_Oriole
+98 098.Scott_Oriole
+99 099.Ovenbird
+100 100.Brown_Pelican
+101 101.White_Pelican
+102 102.Western_Wood_Pewee
+103 103.Sayornis
+104 104.American_Pipit
+105 105.Whip_poor_Will
+106 106.Horned_Puffin
+107 107.Common_Raven
+108 108.White_necked_Raven
+109 109.American_Redstart
+110 110.Geococcyx
+111 111.Loggerhead_Shrike
+112 112.Great_Grey_Shrike
+113 113.Baird_Sparrow
+114 114.Black_throated_Sparrow
+115 115.Brewer_Sparrow
+116 116.Chipping_Sparrow
+117 117.Clay_colored_Sparrow
+118 118.House_Sparrow
+119 119.Field_Sparrow
+120 120.Fox_Sparrow
+121 121.Grasshopper_Sparrow
+122 122.Harris_Sparrow
+123 123.Henslow_Sparrow
+124 124.Le_Conte_Sparrow
+125 125.Lincoln_Sparrow
+126 126.Nelson_Sharp_tailed_Sparrow
+127 127.Savannah_Sparrow
+128 128.Seaside_Sparrow
+129 129.Song_Sparrow
+130 130.Tree_Sparrow
+131 131.Vesper_Sparrow
+132 132.White_crowned_Sparrow
+133 133.White_throated_Sparrow
+134 134.Cape_Glossy_Starling
+135 135.Bank_Swallow
+136 136.Barn_Swallow
+137 137.Cliff_Swallow
+138 138.Tree_Swallow
+139 139.Scarlet_Tanager
+140 140.Summer_Tanager
+141 141.Artic_Tern
+142 142.Black_Tern
+143 143.Caspian_Tern
+144 144.Common_Tern
+145 145.Elegant_Tern
+146 146.Forsters_Tern
+147 147.Least_Tern
+148 148.Green_tailed_Towhee
+149 149.Brown_Thrasher
+150 150.Sage_Thrasher
+151 151.Black_capped_Vireo
+152 152.Blue_headed_Vireo
+153 153.Philadelphia_Vireo
+154 154.Red_eyed_Vireo
+155 155.Warbling_Vireo
+156 156.White_eyed_Vireo
+157 157.Yellow_throated_Vireo
+158 158.Bay_breasted_Warbler
+159 159.Black_and_white_Warbler
+160 160.Black_throated_Blue_Warbler
+161 161.Blue_winged_Warbler
+162 162.Canada_Warbler
+163 163.Cape_May_Warbler
+164 164.Cerulean_Warbler
+165 165.Chestnut_sided_Warbler
+166 166.Golden_winged_Warbler
+167 167.Hooded_Warbler
+168 168.Kentucky_Warbler
+169 169.Magnolia_Warbler
+170 170.Mourning_Warbler
+171 171.Myrtle_Warbler
+172 172.Nashville_Warbler
+173 173.Orange_crowned_Warbler
+174 174.Palm_Warbler
+175 175.Pine_Warbler
+176 176.Prairie_Warbler
+177 177.Prothonotary_Warbler
+178 178.Swainson_Warbler
+179 179.Tennessee_Warbler
+180 180.Wilson_Warbler
+181 181.Worm_eating_Warbler
+182 182.Yellow_Warbler
+183 183.Northern_Waterthrush
+184 184.Louisiana_Waterthrush
+185 185.Bohemian_Waxwing
+186 186.Cedar_Waxwing
+187 187.American_Three_toed_Woodpecker
+188 188.Pileated_Woodpecker
+189 189.Red_bellied_Woodpecker
+190 190.Red_cockaded_Woodpecker
+191 191.Red_headed_Woodpecker
+192 192.Downy_Woodpecker
+193 193.Bewick_Wren
+194 194.Cactus_Wren
+195 195.Carolina_Wren
+196 196.House_Wren
+197 197.Marsh_Wren
+198 198.Rock_Wren
+199 199.Winter_Wren
+200 200.Common_Yellowthroat

model.py

@@ -0,0 +1,248 @@
+import math
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+import torch.optim as optim
+from torchvision import transforms
+import time
+import matplotlib.pyplot as plt
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+        'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+        'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+    }
+
+
+
+class BasicBlock(nn.Module):
+    """
+    This is a basic block that contains two convolutional layers followed by
+    a batch normalization layer and a ReLU activation function, where the skip
+    connection is added before the second relu.
+    ---
+
+    - inplanes: { int } - The number of input channels.
+    - planes: { int } - The number of output channels.
+    - stride: { int } - The stride of convolutional layers.
+    - downsample: { nn.Sequential } - A sequential of convolutional layers that fit the
+        identity mapping to the desired output size.
+    """
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        """
+        This is the forward pass of the basic block where the input tensor x is passed
+        through the first convolutional layer, batch normalization layer, and the ReLU
+        activation function. The result is passed through the second convolutional layer,
+        batch normalization layer, and the ReLU activation function. The result is then
+        added to the identity mapping and passed through the ReLU activation function.
+        """
+        residual = x
+
+        # Convolve with a 3X3Xplanes kernel
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        # Convolve with a 3X3Xplanes kernel
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        # If the stride is not 1 or the number of input channels is not equal
+        # to the number of output channels then we need to fit the identity
+        # mapping to the desired output size by applying the downsample.
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        # Add the identity mapping to the output of the second convolutional layer.
+        out += residual
+        # Apply the ReLU activation function after the addition.
+        out = self.relu(out)
+
+        return out
+    
+
+
+class Bottleneck(nn.Module):
+    """
+    This class defines a bottle neck that fits the identity mapping to the desired
+    output size before adding it to the output of the following layers.
+    ---
+    - inplanes: { int } - The number of input channels.
+    - planes: { int } - The number of output channels.
+    - stride: { int } - The stride of the second convolutional layer.
+    - downsample: { nn.Sequential } - A sequential of convolutional layers that fit the
+        identity mapping to the desired output size.
+
+    The following layers are defined:
+        - A 1x1 convolutional layer (self.conv1) with inplanes input channels and planes
+        output channels is defined.
+        - A batch normalization layer (self.bn1) is defined for the output of self.conv1.
+        - A 3x3 convolutional layer (self.conv2) with planes input channels, planes output
+        channels, and stride 'stride' is defined.
+        - A batch normalization layer (self.bn2) is defined for the output of self.conv2.
+        - A 1x1 convolutional layer (self.conv3) with planes input channels
+        and planes * self.expansion output channels is defined.
+        - A batch normalization layer (self.bn3) is defined for the output of self.conv3.
+        - A ReLU activation function (self.relu) is defined.
+    """
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.conv3 = nn.Conv2d(
+            planes, planes * self.expansion, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        """
+            The Forward Pass
+            ----------------
+            Steps:
+
+            - The input tensor x is saved as residual.
+            - x is passed through self.conv1, self.bn1, and self.relu.
+            - The result is passed through self.conv2, self.bn2, and self.relu.
+            - The result is passed through self.conv3 and self.bn3.
+
+            - If self.downsample is not None, residual is passed through self.downsample.
+            - The output of the previous step is added to out.
+            - The result is passed through self.relu.
+            - The result is returned.
+        """
+        residual = x
+        # Convolve with a 1X1Xplanes kernel
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        # Convolve with a 3X3Xplanes kernel
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        # Convolve with a 1X1Xplanes*expansion kernel
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        # If the stride is not 1 or the number of input channels is not equal
+        # to the number of output channels then we need to fit the identity
+        # mapping to the desired output size by applying the downsample.
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        # Apply the ReLU activation function after the addition.
+        out = self.relu(out)
+
+        return out
+    
+
+class ResNet(nn.Module):
+    """
+    This is the ResNet class that is used in ResNet50, ResNet101, and ResNet152.
+    """
+    def __init__(self, block, layers, stride=None):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0], stride=stride[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=stride[1])
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=stride[2])
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=stride[3])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+
+        self.fc = nn.Linear(512 * block.expansion, 1000)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+
+
+
+
+def resnet50(pretrained=False, stride=None, num_classes=200, **kwargs):
+    """Constructs a ResNet-50 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        :param pretrained:
+        :param stride:
+    """
+    if stride is None:
+        stride = [1, 2, 2, 1]
+    model = ResNet(Bottleneck, [3, 4, 6, 3], stride=stride, **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet50']), strict=True)
+    if num_classes != 1000:
+        model.fc = nn.Linear(512 * Bottleneck.expansion, num_classes)
+    return model

requirements.txt

@@ -0,0 +1,86 @@
+absl-py==2.0.0
+aiofiles==23.2.1
+altair==5.1.2
+annotated-types==0.6.0
+anyio==3.7.1
+attrs==23.1.0
+certifi==2023.7.22
+charset-normalizer==3.3.1
+chex==0.1.84
+click==8.1.7
+colorama==0.4.6
+contourpy==1.1.1
+cycler==0.12.1
+etils==1.5.2
+fastapi==0.104.0
+ffmpy==0.3.1
+filelock==3.12.4
+flax==0.7.4
+fonttools==4.43.1
+fsspec==2023.10.0
+gradio==3.50.2
+gradio_client==0.6.1
+h11==0.14.0
+httpcore==0.18.0
+httpx==0.25.0
+huggingface-hub==0.17.3
+idna==3.4
+importlib-resources==6.1.0
+jax==0.4.19
+jaxlib==0.4.19
+Jinja2==3.1.2
+jsonschema==4.19.1
+jsonschema-specifications==2023.7.1
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+matplotlib==3.8.0
+mdurl==0.1.2
+ml-dtypes==0.3.1
+mpmath==1.3.0
+msgpack==1.0.7
+nest-asyncio==1.5.8
+networkx==3.2
+numpy==1.26.1
+opt-einsum==3.3.0
+optax==0.1.7
+orbax-checkpoint==0.4.1
+orjson==3.9.9
+packaging==23.2
+pandas==2.1.1
+Pillow==10.1.0
+protobuf==4.24.4
+pydantic==2.4.2
+pydantic_core==2.10.1
+pydub==0.25.1
+Pygments==2.16.1
+pyparsing==3.1.1
+python-dateutil==2.8.2
+python-multipart==0.0.6
+pytz==2023.3.post1
+PyYAML==6.0.1
+referencing==0.30.2
+regex==2023.10.3
+requests==2.31.0
+rich==13.6.0
+rpds-py==0.10.6
+safetensors==0.4.0
+scipy==1.11.3
+semantic-version==2.10.0
+six==1.16.0
+sniffio==1.3.0
+starlette==0.27.0
+sympy==1.12
+tensorstore==0.1.46
+tokenizers==0.14.1
+toolz==0.12.0
+torch==2.1.0
+torchvision==0.16.0
+tqdm==4.66.1
+transformers==4.34.1
+typing_extensions==4.8.0
+tzdata==2023.3
+urllib3==2.0.7
+uvicorn==0.23.2
+websockets==11.0.3
+zipp==3.17.0