Learn everything about Analytics

It’s a Record-Breaking Crowd! A Must-Read Tutorial to Build your First Crowd Counting Model using Deep Learning

Introduction

Artificial Intelligence and Machine Learning is going to be our biggest helper in coming decade!

Today morning, I was reading an article which reported that an AI system won against 20 lawyers and the lawyers were actually happy that AI can take care of repetitive part of their roles and help them work on complex topics. These lawyers were happy that AI will enable them to have more fulfilling roles.

Today, I will be sharing a similar example – How to count number of people in crowd using Deep Learning and Computer Vision? But, before we do that – let us develop a sense of how easy the life is for a Crowd Counting Scientist.

 

Act like a Crowd Counting Scientist

Let’s start!

Can you help me count / estimate number of people in this picture attending this event?

Ok – how about this one?

Crowd image

Source: ShanghaiTech Dataset

You get the hang of it. By end of this tutorial, we will create an algorithm for Crowd Counting with an amazing accuracy (compared to humans like you and me). Will you use such an assistant?

 

P.S. This article assumes that you have a basic knowledge of how convolutional neural networks (CNNs) work. You can refer to the below post to learn about this topic before you proceed further:

 

Table of Contents

  1. What is Crowd Counting?
  2. Why is Crowd Counting required?
  3. Understanding the Different Computer Vision Techniques for Crowd Counting
  4. The Architecture and Training Methods of CSRNet
  5. Building your own Crowd Counting model in Python

This article is highly inspired by the paper – CSRNet : Dilated Convolutional Neural Networks for Understanding the Highly Congested Scenes.

 

What is Crowd Counting?

Crowd Counting is a technique to count or estimate the number of people in an image. Take a moment to analyze the below image:

Crowd image

Source: ShanghaiTech Dataset

Can you give me an approximate number of how many people are in the frame? Yes, including the ones present way in the background. The most direct method is to manually count each person but does that make practical sense? It’s nearly impossible when the crowd is this big!

Crowd scientists (yes, that’s a real job title!) count the number of people in certain parts of an image and then extrapolate to come up with an estimate. More commonly, we have had to rely on crude metrics to estimate this number for decades.

Surely there must be a better, more exact approach?

Yes, there is!

While we don’t yet have algorithms that can give us the EXACT number, most computer vision techniques can produce impressively precise estimates. Let’s first understand why crowd counting is important before diving into the algorithm behind it.

 

Why is Crowd Counting useful?

Let’s understand the usefulness of crowd counting using an example. Picture this – your company just finished hosting a huge data science conference. Plenty of different sessions took place during the event.

You are asked to analyze and estimate the number of people who attended each session. This will help your team understand what kind of sessions attracted the biggest crowds (and which ones failed in that regard). This will shape next year’s conference, so it’s an important task!

Image result for conference

There were hundreds of people at the event – counting them manually will take days! That’s where your data scientist skills kick in. You managed to get photos of the crowd from each session and build a computer vision model to do the rest!

There are plenty of other scenarios where crowd counting algorithms are changing the way industries work:

  • Counting the number of people attending a sporting event
  • Estimating how many people attended an inauguration or a march (political rallies, perhaps)
  • Monitoring of high-traffic areas
  • Helping with staffing allocation and resource allotment

Can you come up with some other use cases? Let me know in the comments section below! We can connect and try to figure out how we can use crowd counting techniques in your scenario.

 

Understanding the Different Computer Vision Techniques for Crowd Counting

Broadly speaking, there are currently four methods we can use for counting the number of people in a crowd:

1. Detection-based methods

Here, we use a moving window-like detector to identify people in an image and count how many there are. The methods used for detection require well trained classifiers that can extract low-level features. Although these methods work well for detecting faces, they do not perform well on crowded images as most of the target objects are not clearly visible.

2. Regression-based methods

We were unable to extract low level features using the above approach. Regression-based methods come up trumps here. We first crop patches from the image and then, for each patch, extract the low level features.

3. Density estimation-based methods

We first create a density map for the objects. Then, the algorithm learn a linear mapping between the extracted features and their object density maps. We can also use random forest regression to learn non-linear mapping.

4. CNN-based methods

Ah, good old reliable convolutional neural networks (CNNs). Instead of looking at the patches of an image, we build an end-to-end regression method using CNNs. This takes the entire image as input and directly generates the crowd count. CNNs work really well with regression or classification tasks, and they have also proved their worth in generating density maps.

CSRNet, a technique we will implement in this article, deploys a deeper CNN for capturing high-level features and generating high-quality density maps without expanding the network complexity. Let’s understand what CSRNet is before jumping to the coding section.

 

Understanding the Architecture and Training Method of CSRNet

CSRNet uses VGG-16 as the front end because of its strong transfer learning ability. The output size from VGG is ⅛th of the original input size. CSRNet also uses dilated convolutional layers in the back end.

But what in the world are dilated convolutions? It’s a fair question to ask. Consider the below image:

Dilated Convolutions

The basic concept of using dilated convolutions is to enlarge the kernel without increasing the parameters. So, if the dilation rate is 1, we take the kernel and convolve it on the entire image. Whereas, if we increase the dilation rate to 2, the kernel extends as shown in the above image (follow the labels below each image). It can be an alternative to pooling layers.

 

Underlying Mathematics (Recommended, but optional)

I’m going to take a moment to explain how the mathematics work. Note that this isn’t mandatory to implement the algorithm in Python, but I highly recommend learning the underlying idea. This will come in handy when you need to tweak or modify your model.

Suppose we have an input x(m,n), a filter w(i,j), and the dilation rate r. The output y(m,n) will be:

Dilation output

We can generalize this equation using a (k*k) kernel with a dilation rate r. The kernel enlarges to:

([k + (k-1)*(r-1)] * [k + (k-1)*(r-1)])

So the ground truth has been generated for each image. Each person’s head in a given image is blurred using a Gaussian kernel. All the images are cropped into 9 patches, and the size of each patch is ¼th of the original size of the image. With me so far?

The first 4 patches are divided into 4 quarters and the other 5 patches are randomly cropped. Finally, the mirror of each patch is taken to double the training set.

That, in a nutshell, are the architecture details behind CSRNet. Next, we’ll look at its training details, including the evaluation metric used.

Stochastic Gradient Descent is used to train the CSRNet as an end-to-end structure. During training, the fixed learning rate is set to 1e-6. The loss function is taken to be the Euclidean distance in order to measure the difference between the ground truth and estimated density map. This is represented as:

Loss function

where N is the size of the training batch. The evaluation metric used in CSRNet is MAE and MSE, i.e., Mean Absolute Error and Mean Square Error. These are given by:

MAE and MSE

Here, Ci is the estimated count:

Estimated count

L and W are the width of the predicted density map.

Our model will first predict the density map for a given image. The pixel value will be 0 if no person is present. A certain pre-defined value will be assigned if that pixel corresponds to a person. So, calculating the total pixel values corresponding to a person will give us the count of people in that image. Awesome, right?

And now, ladies and gentlemen, it’s time to finally build our own crowd counting model!

 

Building your own Crowd Counting model

Ready with your notebook powered up?

We will implement CSRNet on the ShanghaiTech dataset. This contains 1198 annotated images of a combined total of 330,165 people. You can download the dataset from here.

Use the below code block to clone the CSRNet-pytorch repository. This holds the entire code for creating the dataset, training the model and validating the results:

git clone https://github.com/leeyeehoo/CSRNet-pytorch.git

Please install CUDA and PyTorch before you proceed further. These are the backbone behind the code we’ll be using below.

Now, move the dataset into the repository you cloned above and unzip it. We’ll then need to create the ground truth values. The make_dataset.ipynb file is our savior. We just need to make minor changes in that notebook:

 

 

#setting the root to the Shanghai dataset you have downloaded
# change the root path as per your location of dataset
root = '/home/pulkit/CSRNet-pytorch/'

Now, let’s generate the ground truth values for images in part_A and part_B:

 

Generating the density map for each image is a time taking step. So go brew a cup of coffee while the code runs.

So far, we have generated the ground truth values for images in part_A. We will do the same for the part_B images. But before that, let’s see a sample image and plot its ground truth heatmap:

plt.imshow(Image.open(img_paths[0]))

ShanghaiTech part_A train image

Things are getting interesting!

gt_file = h5py.File(img_paths[0].replace('.jpg','.h5').replace('images','ground-truth'),'r')
groundtruth = np.asarray(gt_file['density'])
plt.imshow(groundtruth,cmap=CM.jet)

Let’s count how many people are present in this image:

np.sum(groundtruth)

270.32568

Similarly, we will generate values for part_B:

Now, we have the images as well as their corresponding ground truth values. Time to train our model!

We will use the .json files available in the cloned directory. We just have to change the location of the images in the json files. To do this, open the .json file and replace the current location with the location where your images are located.

Note that all this code is written in Python 2. Make the following changes if you’re using any other Python version:

  1. In model.py, change xrange in line 18 to range
  2. Change line 19 in model.py with: list(self.frontend.state_dict().items())[i][1].data[:] = list(mod.state_dict().items())[i][1].data[:]
  3. In image.py, replace ground_truth with ground-truth

Made the changes? Now, open a new terminal window and type the following commands:

cd CSRNet-pytorch
python train.py part_A_train.json part_A_val.json 0 0

Again, sit back because this will take some time. You can reduce the number of epochs in the train.py file to accelerate the process. A cool alternate option is to download the pre-trained weights from here if you don’t feel like waiting.

Finally, let’s check our model’s performance on unseen data. We will use the val.ipynb file to validate the results. Remember to change the path to the pretrained weights and images.

#defining the image path
img_paths = []
for path in path_sets:
    for img_path in glob.glob(os.path.join(path, '*.jpg')):
       img_paths.append(img_path)

 

model = CSRNet()

 

#defining the model
model = model.cuda()

 

#loading the trained weights
checkpoint = torch.load('part_A/0model_best.pth.tar')
model.load_state_dict(checkpoint['state_dict'])

Check the MAE (Mean Absolute Error) on test images to evaluate our model:

We got an MAE value of 75.69 which is pretty good. Now let’s check the predictions on a single image:

CSRNet outputWow, the original count was 382 and our model estimated there were 384 people in the image. That is a very impressive performance!

Congratulations on building your own crowd counting model!

 

End Notes

I encourage you to try out this approach on different images and share your results in the comments section below. Crowd counting has so many diverse applications and is already seeing adoption by organizations and government bodies.

It is a useful skill to add to your portfolio. Quite a number of industries will be looking for data scientists who can work with crowd counting algorithms. Learn it, experiment with it, and give yourself the gift of deep learning!

Did you find this article useful? Feel free to leave your suggestions and feedback for me below, and I’ll be happy to connect with you.

You should also check out the below resources to learn and explore the wonderful world of computer vision:

You can also read this article on Analytics Vidhya's Android APP Get it on Google Play

52 Comments

  • Saurabh Singh says:

    Nicely explained the complex concept of Crowd counting . And its very helpful.

  • Preeti says:

    Very nicely explained. Good one Pulkit

  • sandesh says:

    Great learning through your article .

  • vivek says:

    The zip file with pre-trained weights is corrupt , https://drive.google.com/file/d/1KY11yLorynba14Sg7whFOfVeh2ja02wm/view?usp=sharing

    Could you provide the correct file please?

    “A cool alternate option is to download the pre-trained weights from here if you don’t feel like waiting.”

  • Mohan says:

    Hi,

    I’m getting an issue, when trying to replicate the concept. I kept the screenshots here about the issue as well as the part of the code where it is occurring.

    https://www.dropbox.com/sh/vkyqzogbhvzdj8s/AABC337K_nUxcA1y78OpCswja?dl=0

  • Yogesh says:

    I thought I won’t be able to deal with computer vision. But after reading this article i am amazed.

  • Nimish says:

    Hi Sir! I tried this method using CPU version of torch, and I modified the code accordingly to make it work. But after one picture has een evaluated, the RAM usage suddenly booms and freezes my system entirely. Is this a memory leak on my part, or does the model require a lot of RAM? (I have 8GB RAM)

    • Pulkit Sharma says:

      Hi Nimish,
      This might be an issue related to RAM. As it is a heavy dataset, you will require more RAM. Instead of training your own model, you can download the trained weights given in the article to make predictions for new images.

  • Aditya Ayyagari says:

    How do we give the path in Windows?
    UNABLE TO GENERATE GROUND TRUTHS!
    Does this code run only on Linux? What changes must be made to replicate this code on Windows considering that the system has Cuda, Anaconda with Python3.7 and PyTorch ?

    • Pulkit Sharma says:

      Hi Aditya,
      These codes will work on windows too. You just have to give the entire path of the images and their corresponding density maps.

  • Anjalina says:

    Any option to bypass this cuda since my machine has nvidea GPU 410M only which is not supporting the cuda9.X

    • Pulkit Sharma says:

      Hi Anjalina,
      You can use cloud services to run these codes. Some of the options could be:
      Google Colab
      Paperspace

      • Anjalina says:

        Hi Pulkit,

        Sorry for disturbing you . I am very new to this field and it would be great if you could give some pointer to find out solutions to the issue that I am facing.

        I was trying to predict the crowed count of a local image(xyz.jpg). I don’t have .mat files of my local image.

        I could see the dataset that you have shared contains images and the corresponding .mat files.

        I just created a predict.py as you mentioned in your code.
        Without training (python train.py part_A_train.json part_A_val.json 0 0) and all, I just added the following code to predict.py(hope this is sufficient for all other steps that you mentioned)

        checkpoint = torch.load(‘part_A/0model_best.pth.tar’)
        model.load_state_dict(checkpoint[‘state_dict’])

        while running the predict.py it was complaining about the “xyv.h5”. Says this file not found in:
        temp = h5py.File(‘part_A/test_data/ground-truth/xyv.h5’, ‘r’)

        Could you please assist me to get an understanding about the .mat, .h5 and its dependency in original count prediction.

        • Esther Mead says:

          This is the same problem that I am having.

          • Pulkit Sharma says:

            Hi,
            For predicting the count of a new image, you can use the first 7 lines of code from the article where I have showed the prediction for a single image, i.e.:

            from matplotlib import cm as c
            img = transform(Image.open(‘part_A/test_data/images/IMG_100.jpg’).convert(‘RGB’)).cuda()

            output = model(img.unsqueeze(0))
            print(“Predicted Count : “,int(output.detach().cpu().sum().numpy()))
            temp = np.asarray(output.detach().cpu().reshape(output.detach().cpu().shape[2],output.detach().cpu().shape[3]))
            plt.imshow(temp,cmap = c.jet)
            plt.show()

            The later part of the code was to compare the result when you know the actual count of the person in the image which in your case seems is not known.

            So, use the above code and just change the path of the image. This will give you the count for new image.

  • yuriy says:

    Hey, thanks for the article
    I’m running CUDA on my laptop with 16gb ram and 2gb video memory but alway caught the “CUDA out of memory. Tried to allocate 86.00 MiB (GPU 0; 2.00 GiB total capacity; 927.71 MiB already allocated; 51.00 MiB free; 355.54 MiB cached)”
    what is the requirements for training? or how can I fix this?

    • Pulkit Sharma says:

      Hi Yuriy,
      I trained the model using very high compute. I had a ram of 128 GB. Generally, it is not easily available. So, you can just download the trained weights which I have shared in the article and use them to get predictions for new images.

  • Mr. T says:

    Hi Pulkit,

    I love the tutorial, but the theory about making ground truth and density map were a bit hard for me. Could you give some sources to find an explanation of how to generate ground truth without counting the number of people in images manually?

    Rgs,
    Mr. T

  • beenu says:

    please correct me if I am wrong. I am very new to this field.This might be a simple question for you.
    From this article what I could understand is evenif I supply any image from my local collection, the prediction.py will provide the crowed count.

    With this assumption when I tried, for example I have added IMG5000.jpg in the images and tried to run prediction.py, its complaining about the h5 and mat files since its not there in the dataset.

    mat = io.loadmat(img_path.replace(‘.jpg’,’.mat’).replace(‘images’,’ground-truth’).replace(‘IMG_’,’GT_IMG_’)) is complaning about this.

    • Pulkit Sharma says:

      Hi,
      For predicting the count of a new image, you can use the first 7 lines of code from the article where I have showed the prediction for a single image, i.e.:

      from matplotlib import cm as c
      img = transform(Image.open(‘part_A/test_data/images/IMG_100.jpg’).convert(‘RGB’)).cuda()

      output = model(img.unsqueeze(0))
      print(“Predicted Count : “,int(output.detach().cpu().sum().numpy()))
      temp = np.asarray(output.detach().cpu().reshape(output.detach().cpu().shape[2],output.detach().cpu().shape[3]))
      plt.imshow(temp,cmap = c.jet)
      plt.show()

      You just have to change the image name with its location in the second line of the code.

  • esther says:

    How do you get the .mat files for each image? Thanks.

    • Pulkit Sharma says:

      Hi esther,
      I took the ShanghaiTech dataset. They have provided the .mat files for those images.

  • Esther Mead says:

    Thank you for this. How can I use it to count the number of people in unlabeled images?

    • Pulkit Sharma says:

      Hi Esther,
      For predicting the count of a new image, you can use the first 7 lines of code from the article where I have showed the prediction for a single image, i.e.:

      from matplotlib import cm as c
      img = transform(Image.open(‘part_A/test_data/images/IMG_100.jpg’).convert(‘RGB’)).cuda()

      output = model(img.unsqueeze(0))
      print(“Predicted Count : “,int(output.detach().cpu().sum().numpy()))
      temp = np.asarray(output.detach().cpu().reshape(output.detach().cpu().shape[2],output.detach().cpu().shape[3]))
      plt.imshow(temp,cmap = c.jet)
      plt.show()

      You just have to change the image name with its location in the second line of the code.

  • Esther Mead says:

    Pulkit, thank you so much for this. I’ve gotten everything to work using google colab with GPU acceleration. Now, how can I use this to test new images? Thanks!

    • Pulkit Sharma says:

      Hi Esther,
      As mentioned in the post as well, you can use the following code to get predictions for the new images:

      from matplotlib import cm as c
      img = transform(Image.open(‘part_A/test_data/images/IMG_100.jpg’).convert(‘RGB’)).cuda()

      output = model(img.unsqueeze(0))
      print(“Predicted Count : “,int(output.detach().cpu().sum().numpy()))
      temp = np.asarray(output.detach().cpu().reshape(output.detach().cpu().shape[2],output.detach().cpu().shape[3]))
      plt.imshow(temp,cmap = c.jet)
      plt.show()

      Here, you just have to give the path to your image.

      • Esther Mead says:

        I got it to work now. I had to change the filenames of my new images to begin with “IMG_”
        Thanks so much!!!

  • Arun says:

    Your article is very helpful. Thanks a lot for explaining this in a better way. But when I tested the “part_B_final/test_data_backup/images/IMG_1.jpg” with the above code(reply to Esther), I could see the count that we are getting is 54 , actual the count is only less than 30. Similarly getting some weird counts if I try images with very less count , say 1, 2 or three. May I know whether this issue is with the the way that I am executing this code or this code is not considering all those cases

    • Pulkit Sharma says:

      Hi Arun,
      This model is trained on images that have large number of people. So, if you test this model on images have more density of people, the model will perform well but on the other hand, if you are using this model for images having only 1,2 or 3 (as you have mentioned) person, the performance of the model might not be very accurate.

  • Aiswarya says:

    Hi Pulkit,

    Awesome doc. Thanks you for posting this. This doc definitely would be helpful to all those who are interested to explore in this area.

    I am facing an issue while running this code. It would be great if you could suggest a solution for the same.

    I have 14GB RAM and the following is the nvidia-smi console output.

    +—————————————————————————–+
    | NVIDIA-SMI 418.56 Driver Version: 418.56 CUDA Version: 10.1 |
    |——————————-+———————-+———————-+
    | GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
    | Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
    |===============================+======================+======================|
    | 0 GeForce MX110 Off | 00000000:01:00.0 Off | N/A |
    | N/A 49C P0 N/A / N/A | 443MiB / 2004MiB | 3% Default |
    +——————————-+———————-+———————-+

    +—————————————————————————–+
    | Processes: GPU Memory |
    | GPU PID Type Process name Usage |
    |=============================================================================|
    | 0 1480 G /usr/lib/xorg/Xorg 172MiB |
    | 0 1651 G /usr/bin/gnome-shell 118MiB |
    | 0 5000 G …quest-channel-token=8194962126415318391 146MiB |
    | 0 6268 G /snap/pycharm-community/123/jre64/bin/java 2MiB |

    I am getting frequent Runtimeerror, even-if I try to predict the crowed count of 150 kb file. The error I am getting is as follows:

    RuntimeError: CUDA out of memory. Tried to allocate 174.38 MiB (GPU 0; 1.96 GiB total capacity; 1.31 GiB already allocated; 65.50 MiB free; 1.12 MiB cached).

    The following the code base that I am running:

    import PIL.Image as Image
    import numpy as np
    from matplotlib import pyplot as plt
    from image import *
    from model import CSRNet
    import torch
    import gc; gc.collect()
    torch.cuda.empty_cache()
    from torchvision import datasets, transforms

    transform=transforms.Compose([
    transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406],
    std=[0.229, 0.224, 0.225]),
    ])

    model = CSRNet()
    model = model.cuda()

    #loading the trained weights
    checkpoint = torch.load(‘/home/abc/Downloads/Shanghai/part_A_final/0model_best.pth.tar’)
    model.load_state_dict(checkpoint[‘state_dict’])

    from matplotlib import cm as c
    img = transform(Image.open(“/home/abc/Downloads/Shanghai/xyz.jpg”).convert(‘RGB’)).cuda()

    output = model(img.unsqueeze(0))
    print(“Predicted Count : “,int(output.detach().cpu().sum().numpy()))
    temp = np.asarray(output.detach().cpu().reshape(output.detach().cpu().shape[2],output.detach().cpu().shape[3]))
    plt.imshow(temp,cmap = c.jet)
    plt.show()

    • Pulkit Sharma says:

      Hi Aiswarya,
      Try to use a GPU to run these codes. As the codes are heavy, they might not run on a cpu. You can try to run these codes on google colab as well which provides free GPU access.

  • Bharth singh says:

    Hi Pulkit,

    The ‘0model_best.pth.tar’ contain the pretrained weight of the 1198 images(ie the train and test images of part_A and part_B) right?

    • Pulkit Sharma says:

      Hi Bharth,
      These pretrained weights only contains the learning from the train images and not the test images.

  • mishal says:

    Hi Pulkit,
    Excellent explanation, keep on the good work!
    I am running the code on Anaconda python 3 on windows and it did not like the following line

    if gt_count > 1:

    in the “# function to create density maps for images” Line 20
    it complained about the semicolon. is there a problem in the syntax ?
    Also I had to install openCV which was not mentioned in the explanation but needed by the code.

    • Pulkit Sharma says:

      Hi Mishal,
      If you are using if statement, you have to give : after the condition.
      And thank you for pointing out about openCV. I will add that in the article.

  • Beenu says:

    Thanks a lot for this doc. For the crowed prediction, DO you think it has some dependency with the image size and pixels. I could see the trian images are with a dimensions of 1024*768 . Do you think if the image size and dimension is bigger then the accuracy will also be more fine tuned.

    • Pulkit Sharma says:

      Hi Beenu,
      It depends. I can not confirm that increasing the shape of image will always give better performance. The performance might improve and you might get a better model. But, as you increase the size of the image, computation cost also increases. You will need more memory to store those images and stronger computation to build your model on larger images. So, you must also try to reduce the computation cost instead of just focusing on improving the model performance.

  • Nihed says:

    Hi! great article!
    I have stumped into a little problem and I do not know how to fix it.
    This is the error I am receiving:

    IndexError Traceback (most recent call last)
    in ()
    1 #now see a sample from ShanghaiA
    —-> 2 plt.imshow(Image.open(img_paths[0]))

    IndexError: list index out of range

    The location of my root is this:
    #set the root to the Shanghai dataset you download
    root = ‘/Desktop/CSRNet-pytorch-master/ShanghaiTech’

    #now generate the ShanghaiA’s ground truth
    part_A_train = os.path.join(root,’part_A/train_data’,’images’)
    part_A_test = os.path.join(root,’part_A/test_data’,’images’)
    part_B_train = os.path.join(root,’part_B/train_data’,’images’)
    part_B_test = os.path.join(root,’part_B/test_data’,’images’)
    path_sets = [part_A_train,part_A_test]

    I do not understand why I am receiving the error
    Could someone help me?

    • Pulkit Sharma says:

      Hi Nihed,
      It seems like you have not given the correct path and hence img_paths is empty. Try to give the exact path of the images and then run this code.

  • Nihed says:

    Hi Pulkit!

    I do not have an GPU processor that works for this.. How do I use Google Colab?
    OR could you maybe send me the right pre weights because your I am unable to open your tar. file..
    I am working on a MacBook Pro

    Kind regards,
    Nihed

    • nihed says:

      I mean that I do not understand how I should use this in Google Colab:
      cd CSRNet-pytorch
      python train.py part_A_train.json part_A_val.json 0 0

      Because I receive this:
      [Errno 2] No such file or directory: ‘CSRNet-pytorch’
      /content/drive/My Drive/CSRNet-pytorch
      [Errno 2] No such file or directory: ‘train.py part_A_train.json part_A_val.json 0 0’
      /content/drive/My Drive/CSRNet-pytorch

      while the file is there in my google drive……



Download Resource



Download Resource