Upload 7 files

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+part_B_pre.pth.tar filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,49 @@
+import numpy
+import torch
+import gradio as gr
+from einops import rearrange
+from  torchvision import transforms
+
+from model import CANNet
+model = CANNet()
+checkpoint = torch.load('part_B_pre.pth.tar',map_location=torch.device('cpu'))
+model.load_state_dict(checkpoint['state_dict'])
+model.eval()
+
+## Defining the transform function
+transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])])
+
+
+def crowd(img):
+    ## Transforming the image
+    img = transform(img)
+    
+    ## Adding batch dimension
+    img = rearrange(img, "c h w -> 1 c h w")
+    
+    ## Slicing the image into four parts
+    h = img.shape[2]
+    w = img.shape[3]
+    h_d = int(h/2)
+    w_d = int(w/2)
+    img_1 = img[:,:,:h_d,:w_d]
+    img_2 = img[:,:,:h_d,w_d:]
+    img_3 = img[:,:,h_d:,:w_d]
+    img_4 = img[:,:,h_d:,w_d:]
+    
+    ## Inputting the 4 images into the model, converting it to numpy array, and summing to get the density
+    with torch.no_grad():
+        density_1 = model(img_1).numpy().sum()
+        density_2 = model(img_2).numpy().sum()
+        density_3 = model(img_3).numpy().sum()
+        density_4 = model(img_4).numpy().sum()
+        
+    ## Summing up the estimated density and rounding the result to get an integer
+    pred = density_1 + density_2 + density_3 + density_4
+    pred = int(pred.round())
+    return pred
+    
+outputs = gr.outputs.Textbox(type="auto", label="Estimated crowd density:")
+inputs = gr.inputs.Image(type="numpy", label="Input the image here:")
+
+gr.Interface(fn=crowd, inputs=inputs, outputs=outputs, allow_flagging="never", examples=["Example_1.jpg", "Example_3.jpg", "Example_2.jpg"], title = "Crowd Counting Model", description = "Interface").launch(inbrowser=True)

model.py

@@ -0,0 +1,81 @@
+import torch.nn as nn
+import torch
+from torch.nn import functional as F
+from torchvision import models
+
+class ContextualModule(nn.Module):
+    def __init__(self, features, out_features=512, sizes=(1, 2, 3, 6)):
+        super(ContextualModule, self).__init__()
+        self.scales = []
+        self.scales = nn.ModuleList([self._make_scale(features, size) for size in sizes])
+        self.bottleneck = nn.Conv2d(features * 2, out_features, kernel_size=1)
+        self.relu = nn.ReLU()
+        self.weight_net = nn.Conv2d(features,features,kernel_size=1)
+
+    def __make_weight(self,feature,scale_feature):
+        weight_feature = feature - scale_feature
+        return F.sigmoid(self.weight_net(weight_feature))
+
+    def _make_scale(self, features, size):
+        prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
+        conv = nn.Conv2d(features, features, kernel_size=1, bias=False)
+        return nn.Sequential(prior, conv)
+
+    def forward(self, feats):
+        h, w = feats.size(2), feats.size(3)
+        multi_scales = [F.upsample(input=stage(feats), size=(h, w), mode='bilinear') for stage in self.scales]
+        weights = [self.__make_weight(feats,scale_feature) for scale_feature in multi_scales]
+        overall_features = [(multi_scales[0]*weights[0]+multi_scales[1]*weights[1]+multi_scales[2]*weights[2]+multi_scales[3]*weights[3])/(weights[0]+weights[1]+weights[2]+weights[3])]+ [feats]
+        bottle = self.bottleneck(torch.cat(overall_features, 1))
+        return self.relu(bottle)
+
+class CANNet(nn.Module):
+    def __init__(self, load_weights=False):
+        super(CANNet, self).__init__()
+        self.seen = 0
+        self.context = ContextualModule(512, 512)
+        self.frontend_feat = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512]
+        self.backend_feat  = [512, 512, 512,256,128,64]
+        self.frontend = make_layers(self.frontend_feat)
+        self.backend = make_layers(self.backend_feat,in_channels = 512,batch_norm=True, dilation = True)
+        self.output_layer = nn.Conv2d(64, 1, kernel_size=1)
+        if not load_weights:
+            mod = models.vgg16(pretrained = True)
+            self._initialize_weights()
+            for i in range(len(self.frontend.state_dict().items())):
+                list(self.frontend.state_dict().items())[i][1].data[:] = list(mod.state_dict().items())[i][1].data[:]
+
+    def forward(self,x):
+        x = self.frontend(x)
+        x = self.context(x)
+        x = self.backend(x)
+        x = self.output_layer(x)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+def make_layers(cfg, in_channels = 3,batch_norm=False,dilation = False):
+    if dilation:
+        d_rate = 2
+    else:
+        d_rate = 1
+    layers = []
+    for v in cfg:
+        if v == 'M':
+            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
+        else:
+            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=d_rate,dilation = d_rate)
+            if batch_norm:
+                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
+            else:
+                layers += [conv2d, nn.ReLU(inplace=True)]
+            in_channels = v
+    return nn.Sequential(*layers)

part_B_pre.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f76422976fabd5524c5d243578b516b8981b8e43e99495ea149f64bac68b779f
+size 72441427

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+torch
+torchvision
+einops
+gradio