Video_based_ReID_RNN

Préface

Examinons ensuite l'une des méthodes d'agrégation temporelle du modèle de formation à la reconnaissance vidéo des piétons: RNN.
Il s'agit d'un modèle couramment utilisé dans la formation de modèles de séquence. RNN peut extraire les informations contenues dans des images continues. La structure RNN la plus simple est utilisée ici.
Les résultats des tests actuels de cette méthode ne sont pas aussi bons que ceux d'autres types, tels que la partie B:

Modèle d'entrée

La différence entre l'entrée et la précédente se situe uniquement dans le réseau de passage:

• imgs
  • imgs.size () = [b, s, c, h, w]
  • Au niveau de la formation, b est un lot et généralement défini sur 32, seq_len est défini sur 4, c est le nombre de canaux est 3, h est la hauteur de l'image, w est la largeur de l'image

Paramètres d'initialisation du modèle

        model = models.init_model(name=args.arch, num_classes=dataset.num_train_pids, loss={
    
    'xent', 'htri'})

• name Le nom du modèle utilisé
• dataset.num_train_pids Le nombre de classifications pendant la classification
• perte xent = perte d'entropie croisée htri = Tripletloss

Réalisation du modèle

class ResNet50RNN(nn.Module):
    def __init__(self, num_classes, loss={
    
    'xent'}, **kwargs):
        super(ResNet50RNN, self).__init__()
        self.loss = loss
        resnet50 = torchvision.models.resnet50(pretrained=True)
        self.base = nn.Sequential(*list(resnet50.children())[:-2])
        self.hidden_dim = 512
        self.feat_dim = 2048
        self.classifier = nn.Linear(self.hidden_dim, num_classes)
        #                   输入特征维数2048              LSTM中隐层的维度              循环神经网络的层数
        #输入的数据shape=(batch_size,seq_length,embedding_dim),而batch_first默认是False,所以我们的输入数据最好送进LSTM之前将batch_size与seq_length这两个维度调换？
        self.lstm = nn.LSTM(input_size=self.feat_dim, hidden_size=self.hidden_dim, num_layers=1, batch_first=True)

	# x = [32,4,3,224,112] [b,s,c,h,w]
    def forward(self, x):
        # b=32
        b = x.size(0)
        # t= 4
        t = x.size(1)
        # x = [128,3,224,112]
        x = x.view(b*t,x.size(2), x.size(3), x.size(4))
		# x = [128,2048,7,4]
        x = self.base(x)
		# [128,2048,1,1]
        x = F.avg_pool2d(x, x.size()[2:])
        x = x.view(b,t,-1)
        # x = [32,2048,4]
        # 使用RNN直接获取特征
        # output = [32,4,512]?
        output, (h_n, c_n) = self.lstm(x)
        # output = [32,512,4]
        output = output.permute(0, 2, 1)
        # f = [32,512]
        f = F.avg_pool1d(output, t)
        f = f.view(b, self.hidden_dim)
        
        if not self.training:
            return f
        y = self.classifier(f)

        if self.loss == {
    
    'xent'}:
            return y
        elif self.loss == {
    
    'xent', 'htri'}:
            return y, f
        elif self.loss == {
    
    'cent'}:
            return y, f
        else:
            raise KeyError("Unsupported loss: {}".format(self.loss))