hahattpro / crowd_counting_framework (public) (License: Unspecified) (since 2020-12-23) (hash sha1)
backupfrom https://github.com/ttpro1995/crowd_counting_framework
Clone URLs: https://rocketgit.com/user/hahattpro/crowd_counting_framework ssh://rocketgit@ssh.rocketgit.com/user/hahattpro/crowd_counting_framework git://git.rocketgit.com/user/hahattpro/crowd_counting_framework
debug/a-1 develop feature/add_can_adcrowdnet feature/add_context_aware_network feature/attn_can_adcrowd_simple feature/cache_dataloader feature/compact_cnn feature/compare_with_original_count feature/dataloader_not_divide_8 feature/debug_viz feature/documentation feature/improve_density_gen feature/improve_loss_fn feature/loader_full_and_augment feature/refactor-dataflow feature/refactor_ccnn_basecode feature/save_best feature/simple_cometml feature/train_context_aware_network_on_shtA feature/train_dev_test_split hotfix/fix_visualize_data_loader master meow_exp server-training with_apex

/models/compact_cnn.py (3c5e99a67b650e009551a93b327a3a397a9e64dc) (14909 bytes) (mode 100644) (type blob)

import torch.nn as nn
import torch
from torchvision import models
from .deform_conv_v2 import DeformConv2d
import collections
import torch.nn.functional as F


class CompactCNN(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    :deprecated: I think implement incorrectly, please use CompactCNNV2
    """
    def __init__(self, load_weights=False):
        super(CompactCNN, self).__init__()
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = self.max_pooling(F.relu(self.red_cnn(x), inplace=True))
        x_green = self.max_pooling(F.relu(self.green_cnn(x), inplace=True))
        x_blue = self.max_pooling(F.relu(self.blue_cnn(x), inplace=True))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = F.relu(self.c1(x), inplace=True)

        x = F.relu(self.c2(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c3(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c4(x), inplace=True)

        x = self.output(x)
        return x


class CompactCNNV2(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    """
    def __init__(self, load_weights=False):
        super(CompactCNNV2, self).__init__()
        self.model_note = "CCNN without batchnorm"
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)
        self.c0 = nn.Conv2d(40, 40, 3, padding=1)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = self.max_pooling(F.relu(self.red_cnn(x), inplace=True))
        x_green = self.max_pooling(F.relu(self.green_cnn(x), inplace=True))
        x_blue = self.max_pooling(F.relu(self.blue_cnn(x), inplace=True))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = F.relu(self.c0(x), inplace=True)

        x = F.relu(self.c1(x), inplace=True)

        x = F.relu(self.c2(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c3(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c4(x), inplace=True)

        x = self.output(x)
        return x


class CompactCNNV7(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    """
    def __init__(self, load_weights=False):
        super(CompactCNNV7, self).__init__()
        self.model_note = "CCNN without batchnorm, max pooling after cat, does it do any good ?"
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)
        self.c0 = nn.Conv2d(40, 40, 3, padding=1)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = F.relu(self.red_cnn(x), inplace=True)
        x_green = F.relu(self.green_cnn(x), inplace=True)
        x_blue = F.relu(self.blue_cnn(x), inplace=True)

        x = torch.cat((x_red, x_green, x_blue), 1)

        x = self.max_pooling(x)
        x = F.relu(self.c0(x), inplace=True)

        x = F.relu(self.c1(x), inplace=True)

        x = F.relu(self.c2(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c3(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c4(x), inplace=True)

        x = self.output(x)
        return x


class CompactCNNV7i(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    no inplace
    """
    def __init__(self, load_weights=False):
        super(CompactCNNV7i, self).__init__()
        self.model_note = "CCNN without batchnorm, max pooling after cat, does it do any good ?, no inplace relu"
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)
        self.c0 = nn.Conv2d(40, 40, 3, padding=1)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = F.relu(self.red_cnn(x))
        x_green = F.relu(self.green_cnn(x))
        x_blue = F.relu(self.blue_cnn(x))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = self.max_pooling(x)

        x = F.relu(self.c0(x))
        x = F.relu(self.c1(x))
        x = F.relu(self.c2(x))
        x = self.max_pooling(x)

        x = F.relu(self.c3(x))
        x = self.max_pooling(x)

        x = F.relu(self.c4(x))
        x = self.output(x)
        return x

class CompactCNNV9(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    """
    def __init__(self, load_weights=False):
        super(CompactCNNV9, self).__init__()
        self.model_note = "CCNNv7 but use leaky relu"
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)
        self.c0 = nn.Conv2d(40, 40, 3, padding=1)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = F.leaky_relu(self.red_cnn(x), inplace=True)
        x_green = F.leaky_relu(self.green_cnn(x), inplace=True)
        x_blue = F.leaky_relu(self.blue_cnn(x), inplace=True)

        x = torch.cat((x_red, x_green, x_blue), 1)

        x = self.max_pooling(x)
        x = F.leaky_relu(self.c0(x), inplace=True)

        x = F.leaky_relu(self.c1(x), inplace=True)

        x = F.leaky_relu(self.c2(x), inplace=True)
        x = self.max_pooling(x)

        x = F.leaky_relu(self.c3(x), inplace=True)
        x = self.max_pooling(x)

        x = F.leaky_relu(self.c4(x), inplace=True)

        x = self.output(x)
        return x



class CompactCNNV8(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    """
    def __init__(self, load_weights=False):
        super(CompactCNNV8, self).__init__()
        self.model_note = "CCNNv7, now we change c0 to 40-60, see if v8 better than v7"
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)
        self.c0 = nn.Conv2d(40, 60, 3, padding=1)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(60, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = F.relu(self.red_cnn(x), inplace=True)
        x_green = F.relu(self.green_cnn(x), inplace=True)
        x_blue = F.relu(self.blue_cnn(x), inplace=True)

        x = torch.cat((x_red, x_green, x_blue), 1)

        x = self.max_pooling(x)
        x = F.relu(self.c0(x), inplace=True)

        x = F.relu(self.c1(x), inplace=True)

        x = F.relu(self.c2(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c3(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c4(x), inplace=True)

        x = self.output(x)
        return x


class CompactCNNV6(nn.Module):
    """
    A REAL-TIME DEEP NETWORK FOR CROWD COUNTING
    https://arxiv.org/pdf/2002.06515.pdf
    with a bunch of batch norm
    """
    def __init__(self, load_weights=False):
        super(CompactCNNV6, self).__init__()
        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)

        self.red_bn = nn.BatchNorm2d(10)
        self.green_bn = nn.BatchNorm2d(14)
        self.blue_bn = nn.BatchNorm2d(16)


        self.c0 = nn.Conv2d(40, 40, 3, padding=1)
        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)
        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)

        self.bn0 = nn.BatchNorm2d(40)
        self.bn1 = nn.BatchNorm2d(60)
        self.bn2 = nn.BatchNorm2d(40)
        self.bn3 = nn.BatchNorm2d(20)
        self.bn4 = nn.BatchNorm2d(10)

        self.output = nn.Conv2d(10, 1, 1)

    def forward(self, x):
        x_red = self.max_pooling(F.relu(self.red_bn(self.red_cnn(x)), inplace=True))
        x_green = self.max_pooling(F.relu(self.green_bn(self.green_cnn(x)), inplace=True))
        x_blue = self.max_pooling(F.relu(self.blue_bn(self.blue_cnn(x)), inplace=True))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = F.relu(self.bn0(self.c0(x)), inplace=True)

        x = F.relu(self.bn1(self.c1(x)), inplace=True)

        x = F.relu(self.bn2(self.c2(x)), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.bn3(self.c3(x)), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.bn4(self.c4(x)), inplace=True)

        x = self.output(x)
        return x


class CompactDilatedCNN(nn.Module):
    """

    """
    def __init__(self, load_weights=False):
        super(CompactDilatedCNN, self).__init__()
        self.red_cnn = nn.Conv2d(3, 10, 5, dilation=3, padding=6)
        self.green_cnn = nn.Conv2d(3, 14, 5, dilation=2, padding=4)
        self.blue_cnn = nn.Conv2d(3, 16, 5, dilation=1, padding=2)
        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, padding=1)
        self.c2 = nn.Conv2d(60, 40, 3, padding=1)
        self.c3 = nn.Conv2d(40, 20, 3, padding=1)
        self.c4 = nn.Conv2d(20, 10, 3, padding=1)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = self.max_pooling(F.relu(self.red_cnn(x), inplace=True))
        x_green = self.max_pooling(F.relu(self.green_cnn(x), inplace=True))
        x_blue = self.max_pooling(F.relu(self.blue_cnn(x), inplace=True))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = F.relu(self.c1(x), inplace=True)

        x = F.relu(self.c2(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c3(x), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.c4(x), inplace=True)

        x = self.output(x)
        return x


class DefDilatedCCNN(nn.Module):
    """
    fail reason: out of cuda memory at red_cnn
    possible fix: try torchvision deform conv
    """
    def __init__(self, load_weights=False):
        super(DefDilatedCCNN, self).__init__()

        self.red_cnn = DeformConv2d(3, 10, 9, padding=4)
        self.green_cnn = DeformConv2d(3, 14, 7, padding=3)
        self.blue_cnn = DeformConv2d(3, 16, 5, padding=2)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, dilation=2, padding=2, bias=False)
        self.bn1 = nn.BatchNorm2d(60)
        self.c2 = nn.Conv2d(60, 40, 3, dilation=2, padding=2, bias=False)
        self.bn2 = nn.BatchNorm2d(40)
        self.c3 = nn.Conv2d(40, 20, 3, dilation=2, padding=2, bias=False)
        self.bn3 = nn.BatchNorm2d(20)
        self.c4 = nn.Conv2d(20, 10, 3, dilation=2, padding=2, bias=False)
        self.bn4 = nn.BatchNorm2d(10)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = self.max_pooling(F.relu(self.red_cnn(x), inplace=True))
        x_green = self.max_pooling(F.relu(self.green_cnn(x), inplace=True))
        x_blue = self.max_pooling(F.relu(self.blue_cnn(x), inplace=True))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = F.relu(self.bn1(self.c1(x)), inplace=True)

        x = F.relu(self.bn2(self.c2(x)), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.bn3(self.c3(x)), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.bn4(self.c4(x)), inplace=True)

        x = self.output(x)
        return x

class DilatedCCNNv2(nn.Module):
    """

    """
    def __init__(self, load_weights=False):
        super(DilatedCCNNv2, self).__init__()

        self.red_cnn = nn.Conv2d(3, 10, 9, padding=4)
        self.green_cnn = nn.Conv2d(3, 14, 7, padding=3)
        self.blue_cnn = nn.Conv2d(3, 16, 5, padding=2)

        self.max_pooling = nn.MaxPool2d(kernel_size=2, stride=2)

        self.c1 = nn.Conv2d(40, 60, 3, dilation=2, padding=2, bias=False)
        self.bn1 = nn.BatchNorm2d(60)
        self.c2 = nn.Conv2d(60, 40, 3, dilation=2, padding=2, bias=False)
        self.bn2 = nn.BatchNorm2d(40)
        self.c3 = nn.Conv2d(40, 20, 3, dilation=2, padding=2, bias=False)
        self.bn3 = nn.BatchNorm2d(20)
        self.c4 = nn.Conv2d(20, 10, 3, dilation=2, padding=2, bias=False)
        self.bn4 = nn.BatchNorm2d(10)
        self.output = nn.Conv2d(10, 1, 1)

    def forward(self,x):
        x_red = self.max_pooling(F.relu(self.red_cnn(x), inplace=True))
        x_green = self.max_pooling(F.relu(self.green_cnn(x), inplace=True))
        x_blue = self.max_pooling(F.relu(self.blue_cnn(x), inplace=True))

        x = torch.cat((x_red, x_green, x_blue), 1)
        x = F.relu(self.bn1(self.c1(x)), inplace=True)

        x = F.relu(self.bn2(self.c2(x)), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.bn3(self.c3(x)), inplace=True)
        x = self.max_pooling(x)

        x = F.relu(self.bn4(self.c4(x)), inplace=True)

        x = self.output(x)
        return x

Mode Type Size Ref File
100644 blob 82 a70468201005e2eefb48e83a1056bd00c5c1e34a .gitignore
100644 blob 1342 f2eb3073ff4a8536cf4e8104ff942b525e3c7f34 .travis.yml
100644 blob 1255 1dfa426237bc174a2ba2186240191a6b7041bc86 README.md
100644 blob 9201 77806a96d77d0431140f344bfe59168acdbed2c1 args_util.py
040000 tree - 5e9d7f0e1fd3a9e4d5a37f3d6de0c3ecd3125af8 backup_notebook
040000 tree - 55d1d196f5b6ed4bfc1e8a715df1cfff1dd18117 bug
100644 blob 3591 7b4c18e8cf2c0417cd13d3f77ea0571c9e0e493f crowd_counting_error_metrics.py
100644 blob 50380 5fc9b0e05c139967f98c67266f0bce4ac4a856b9 data_flow.py
040000 tree - 7b2560d2cb223bf0574eb278bafeda5a8577c7db data_util
040000 tree - e4cfcbf81993d179063f70f45b58b4e2c49dff4d dataset_script
040000 tree - f6c409a873c6262ffccb5897400f13ac1c33a62d debug
040000 tree - 9862b9cbc6e7a1d43565f12d85d9b17d1bf1814e env_file
100644 blob 4460 9b254c348a3453f4df2c3ccbf21fb175a16852de eval_context_aware_network.py
100644 blob 428 35cc7bfe48a4ed8dc56635fd3a6763612d8af771 evaluator.py
100644 blob 17226 13e67fb1c4e3b67425f5b0fb21edb56524ff2ced experiment_main.py
100644 blob 8876 049432d6bde50245a4acba4e116d59605b5b6315 experiment_meow_main.py
100644 blob 1916 1d228fa4fa2887927db069f0c93c61a920279d1f explore_model_summary.py
100644 blob 2718 b09b84e8b761137654ba6904669799c4866554b3 hard_code_variable.py
040000 tree - b3aa858a157f5e1e22c00fdb6f9dd071f4c6c163 local_train_script
040000 tree - 927d159228536a86499de8a294700f8599b8a60b logs
100644 blob 15300 cb90faba0bd4a45f2606a1e60975ed05bfacdb07 main_pacnn.py
100644 blob 2760 3c2d5ba1c81ef2770ad216c566e268f4ece17262 main_shanghaitech.py
100644 blob 2683 29189260c1a2c03c8e59cd0b4bd61df19d5ce098 main_ucfcc50.py
100644 blob 2794 f37b3bb572c53dd942c51243bd5b0853228c6ddb model_util.py
040000 tree - 3e68f1cb103228fc5e5d22db43874f853152bb39 models
100644 blob 870 8f5ce4f7e0b168add5ff2a363faa973a5b56ca48 mse_l1_loss.py
100644 blob 1066 811554259182e63240d7aa9406f315377b3be1ac mse_ssim_loss.py
040000 tree - 2cc497edce5da8793879cc5e82718d1562ef17e8 playground
040000 tree - c7c295e9e418154ae7c754dc888a77df8f50aa61 pytorch_ssim
100644 blob 1727 1cd14cbff636cb6145c8bacf013e97eb3f7ed578 sanity_check_dataloader.py
040000 tree - a1e8ea43eba8a949288a00fff12974aec8692003 saved_model_best
100644 blob 3525 27067234ad3deddd743dcab0d7b3ba4812902656 train_attn_can_adcrowdnet.py
100644 blob 3488 e47bfc7e91c46ca3c61be0c5258302de4730b06d train_attn_can_adcrowdnet_freeze_vgg.py
100644 blob 5352 3ee3269d6fcc7408901af46bed52b1d86ee9818c train_attn_can_adcrowdnet_simple.py
100644 blob 5728 90b846b68f15bdc58e3fd60b41aa4b5d82864ec4 train_attn_can_adcrowdnet_simple_lrscheduler.py
100644 blob 9081 664051f8838434c386e34e6dd6e6bca862cb3ccd train_compact_cnn.py
100644 blob 5702 fdec7cd1ee062aa4a2182a91e2fb1bd0db3ab35f train_compact_cnn_lrscheduler.py
100644 blob 5611 2a241c876015db34681d73ce534221de482b0b90 train_compact_cnn_sgd.py
100644 blob 3525 eb52f7a4462687c9b2bf1c3a887014c4afefa26d train_context_aware_network.py
100644 blob 5651 48631e36a1fdc063a6d54d9206d2fd45521d8dc8 train_custom_compact_cnn.py
100644 blob 5594 07d6c9c056db36082545b5b60b1c00d9d9f6396d train_custom_compact_cnn_lrscheduler.py
100644 blob 5281 8a92eb87b54f71ad2a799a7e05020344a22e22d3 train_custom_compact_cnn_sgd.py
040000 tree - 4494dd975af19bb39c3e591b2f86717473e847ac train_script
100644 blob 6595 5b8afd4fb322dd7cbffd1a589ff5276b0e3edeb5 visualize_data_loader.py
100644 blob 1146 1b0f845587f0f37166d44fa0c74b51f89cf8b349 visualize_util.py
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/hahattpro/crowd_counting_framework

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/hahattpro/crowd_counting_framework

Clone this repository using git:
git clone git://git.rocketgit.com/user/hahattpro/crowd_counting_framework

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main