Pseudo-3D Residual Networks算法的pytorch代码

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u014380165/article/details/78986430

本篇博客是对第三方实现的Pseudo-3D Residual Networks算法的pytorch代码进行介绍,介绍顺序为代码调试顺序,建议先阅读论文或相关博客。
论文:Learning Spatio-Temporal Representation with Pseudo-3D Residual Networks。
代码地址:https://github.com/qijiezhao/pseudo-3d-pytorch

导入必须的模块

from __future__ import print_function
import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torch.autograd import Variable
import math
from functools import partial

__all__ = ['P3D', 'P3D63', 'P3D131','P3D199']

main函数中主要包括导入模型,准备数据,测试数据,打印结果这几个部分,其中导入模型和准备数据最重要。导入模型部分通过调用P3D199得到199层的P3D网络,另外参数pretrained=true表明导入的是预训练的模型,这样模型的参数就可以通过预训练模型的参数来初始化了,另一个参数num_classes=400是类别数。P3D199后面会详细介绍。
data=torch.autograd.Variable(torch.rand(10,3,16,160,160)).cuda()这一行是随机生成输入数据,第一个维度是10说明该输入数据包含10个clip,其中每个clip包含16帧图像,每帧图像是160*160的3通道图像。最后数据输入模型得到结果out。

if __name__ == '__main__':

    model = P3D199(pretrained=True,num_classes=400)
    model = model.cuda()

# if modality=='Flow', please change the 2nd dimension 3==>2
   data=torch.autograd.Variable(torch.rand(10,3,16,160,160)).cuda()
    out=model(data)
    print (out.size(),out)

调用P3D199函数得到199层的P3D网络。如果调用P3D63或P3D131则得到对应层数的P3D网络,不过由于P3D63和P3D131没有预训练模型,所以在实现中只有调用P3D类导入网络结构这一步。model = P3D(Bottleneck, [3, 8, 36, 3], modality=modality,**kwargs) 这一行通过调用P3D类获得网络结构,该函数的第二个参数[3, 8, 36, 3]表明其结构和ResNet-152对应,于是最后得到的就是199层的P3D网络。因为pretrained设置为True,所以pretrained_file就是准备好的预训练模型的压缩文件,通过weights=torch.load(pretrained_file)['state_dict']这一行读取预训练模型的参数,然后model.load_state_dict(weights)这一行将读取到的预训练模型的参数赋值给model这个网络结构,完成赋值。接下来介绍P3D这个类。

def P3D199(pretrained=False,modality='RGB',**kwargs):
    """construct a P3D199 model based on a ResNet-152-3D model.
    """
    model = P3D(Bottleneck, [3, 8, 36, 3], modality=modality,**kwargs)
    if pretrained==True:
        if modality=='RGB':
            pretrained_file='p3d_rgb_199.checkpoint.pth.tar'
        elif modality=='Flow':
            pretrained_file='p3d_flow_199.checkpoint.pth.tar'
        weights=torch.load(pretrained_file)['state_dict']
        model.load_state_dict(weights)
    return model

P3D这个类是构造网络结构的主体,之前介绍过在PyTorch中定义网络结构的时候都要继承基类torch.nn.Module,这里也是这样。先看看__init__,这是因为前面调用P3D类生成对象的时候会先调用__init__进行初始化。 self.input_channel = 3 if modality=='RGB' else 2这一行表示如果输入是视频帧(也就是图像),那么输入channel就是3,如果输入是optical flow,那么输入channel就是2。self.conv1_custom是网络的第一个卷积层,原来在ResNet中是2D的7*7大小的卷积核。self.maxpool是对最后3维都做了pooling,也就是对这3维都做了减半。self.maxpool_2是对倒数第3维度做了pooling,也就是对该维度做了减半。self.layer1到self.layer4是P3D网络的4个block,这个和ResNet网络中的conv2_x到conv5_x对应,以self.layer1 = self._make_layer(block, 64, layers[0], shortcut_type)为例,通过调用P3D类的make_layer方法来得到该block的层(后面会详细介绍_make_layer方法),一般函数名前面加上表示类内部函数,或者叫私有函数。几个输入的含义如下:block是Bottleneck,layers是一个列表(长度就是block的数量,这里就是4),其中的每个值表示对应的那个block包含多少个重复的residual结构,shortcut_type是residual采取的形式,默认是’B’,指明了ResNet中residual的具体类型。self.avgpool和ResNet网络中最后的7*7的均值池化一样,只不过这里采用的是5*5,主要是因为输入帧的大小是160*160,和ResNet中224*224大小的图像不同。self.layer1和其他3个layer不同的是输入中没有stride=2,这是因为在self.layer1之前已经进行过一次pool操作了,所以这里不需要stride,这和ResNet中每个block的feature map尺寸缩减策略是一致的。for m in self.modules():这个循环是用来对构造好的网络结构进行参数初始化,这里只对卷积层和BN层进行初始化。__init__的最后三行先是指定了网络输入数据的尺寸,这里16表示16帧图像,然后指定了均值和标准差用于数据归一化。接下来介绍P3D类的_make_layer方法。

class P3D(nn.Module):

    def __init__(self, block, layers, modality='RGB',
        shortcut_type='B', num_classes=400,dropout=0.5,ST_struc=('A','B','C')):
        self.inplanes = 64
        super(P3D, self).__init__()
        # self.conv1 = nn.Conv3d(3, 64, kernel_size=7, stride=(1, 2, 2),
        #                        padding=(3, 3, 3), bias=False)
        self.input_channel = 3 if modality=='RGB' else 2  # 2 is for flow 
        self.ST_struc=ST_struc

        self.conv1_custom = nn.Conv3d(self.input_channel, 64, kernel_size=(1,7,7), stride=(1,2,2),
                                padding=(0,3,3), bias=False)

        self.depth_3d=sum(layers[:3])# C3D layers are only (res2,res3,res4),  res5 is C2D

        self.bn1 = nn.BatchNorm3d(64) # bn1 is followed by conv1
        self.cnt=0
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool3d(kernel_size=(2, 3, 3), stride=2, padding=0)       # pooling layer for conv1.
        self.maxpool_2 = nn.MaxPool3d(kernel_size=(2,1,1),padding=0,stride=(2,1,1))   # pooling layer for res2, 3, 4.

        self.layer1 = self._make_layer(block, 64, layers[0], shortcut_type)
        self.layer2 = self._make_layer(block, 128, layers[1], shortcut_type, stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], shortcut_type, stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], shortcut_type, stride=2)

        self.avgpool = nn.AvgPool2d(kernel_size=(5, 5), stride=1)                              # pooling layer for res5.
        self.dropout=nn.Dropout(p=dropout)
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv3d):
                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.BatchNorm3d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

        # some private attribute
        self.input_size=(self.input_channel,16,160,160)       # input of the network
        self.input_mean = [0.485, 0.456, 0.406] if modality=='RGB' else [0.5]
        self.input_std = [0.229, 0.224, 0.225] if modality=='RGB' else [np.mean([0.229, 0.224, 0.225])]

__init__中提到构建网络的block时采用P3D类自定义的_make_layer方法,该方法用来定义网络结构中90%的层和先后顺序,也就是定义了4个block的内容。if self.cnt==0: stride_p=1 else: stride_p=(1,2,2) 这部分是用来区别layer1和layer2至layer4调用_make_layer时候的不同参数,在layer2到layer4中,用stride_p=(1,2,2)来对feature map的尺寸做缩减。因为shortcut_type是’B’,所以这里是通过else语句中的 downsample = nn.Sequential( nn.Conv3d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride_p, bias=False), nn.BatchNorm3d(planes *block.expansion))来得到downsample的。torch.nn.Sequential这个类是用来封装多个网络层的,并且封装的顺序就是数据流的顺序,就像这里是先进行一个卷积层,再进行一个BN层。 生成downsample层后,这一行layers.append(block(self.inplanes, planes, stride, downsample,n_s=self.cnt,depth_3d=self.depth_3d,ST_struc=self.ST_struc))主要是调用了Bottleneck类将一个block的第一个residual添加到layer列表中(关于Bottleneck的详细内容后面有介绍)。 for i in range(1, blocks)这个循环则是将该block的剩余residual结构添加到网络中,从而完成该block的所有层构造,因此对于layer1而言,这个输入blocks就是3,对于layer2而言,这个输入blocks就是8,range的起始是1正是跳过了前面单独添加的那个downsample层。最后将列表layers用torch.nn.Sequential类进行封装,成为一个网络子结构。

def _make_layer(self, block, planes, blocks, shortcut_type, stride=1):
        downsample = None
        stride_p=stride #especially for downsample branch.

        if self.cnt<self.depth_3d:
            if self.cnt==0:
                stride_p=1
            else:
                stride_p=(1,2,2)
            if stride != 1 or self.inplanes != planes * block.expansion:
                if shortcut_type == 'A':
                    downsample = partial(downsample_basic_block,
                                         planes=planes * block.expansion, stride=stride)
                else:
                    downsample = nn.Sequential(
                        nn.Conv3d(self.inplanes, planes * block.expansion,
                                  kernel_size=1, stride=stride_p, bias=False),
                        nn.BatchNorm3d(planes * block.expansion)
                    )

        else:
            if stride != 1 or self.inplanes != planes * block.expansion:
                if shortcut_type == 'A':
                    downsample = partial(downsample_basic_block,
                                         planes=planes * block.expansion, stride=stride)
                else:
                    downsample = nn.Sequential(
                        nn.Conv2d(self.inplanes, planes * block.expansion,
                                  kernel_size=1, stride=2, bias=False),
                        nn.BatchNorm2d(planes * block.expansion)
                    )
        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample,n_s=self.cnt,depth_3d=self.depth_3d,ST_struc=self.ST_struc))
        self.cnt+=1

        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes,n_s=self.cnt,depth_3d=self.depth_3d,ST_struc=self.ST_struc))
            self.cnt+=1

        return nn.Sequential(*layers)

Bottleneck类的定义,从命名也可以看出是和ResNet中的bottleneck对应,也就是在residule子结构中的那三层卷积(卷积核大小分别是1*1,3*3,1*1,第一个1*1卷积用来缩减维度,这样3*3卷积的计算量就会下降,最后一个卷积用来恢复维度)。同样的,网络的定义还是继承torch.nn.Module这个基类。因此在__init__中的3个主要的if语句就是用来完成bottleneck中的3层卷积的定义。至于为什么有if和else,主要是为了区别layer1至layer3和layer4的区别,因为前面3个layer都是用3D卷积(if部分),而layer4是采用2D卷积(else部分)。
1、if n_s<self.depth_3d是第一个卷积层相关的定义。这里主要就是一个1*1*1的卷积(用来缩减channel数)和一个BN层。else语句中就是2D的1*1卷积。
2、if self.id<self.depth_3d是第二个卷积层相关的定义。首先self.ST=list(self.ST_struc)[self.id%self.len_ST]这一行就是用来确定采用的是’A’、’B’、’C’中的哪种P3D子结构。接下来的 if self.id<self.depth_3d条件语句就是完成具体的P3D子结构定义,具体而言就是确定了self.conv2和self.conv3的形式。同样,if部分是针对layer1到layer3,else部分是针对layer4。在if部分调用的conv_S卷积正是论文中介绍的1*3*3卷积,conv_T卷积正是论文中介绍的3*1*1卷积。因此self.conv2和self.conv3的不同组装顺序就构成了论文中的P3D的3种不同子结构,后面会详细介绍。
3、最后这个if n_s<self.depth_3d语句是定义self.conv4,也就是bottleneck中第三个卷积层(卷积核大小为1*1*1,用来恢复被缩减的channel数)。同样else部分是2D的1*1卷积。

class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None,n_s=0,depth_3d=47,ST_struc=('A','B','C')):
        super(Bottleneck, self).__init__()
        self.downsample = downsample
        self.depth_3d=depth_3d
        self.ST_struc=ST_struc
        self.len_ST=len(self.ST_struc)

        stride_p=stride
        if not self.downsample ==None:
            stride_p=(1,2,2)
        if n_s<self.depth_3d:
            if n_s==0:
                stride_p=1
            self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False,stride=stride_p)
            self.bn1 = nn.BatchNorm3d(planes)
        else:
            if n_s==self.depth_3d:
                stride_p=2
            else:
                stride_p=1
            self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False,stride=stride_p)
            self.bn1 = nn.BatchNorm2d(planes)
        # self.conv2 = nn.Conv3d(planes, planes, kernel_size=3, stride=stride,
        #                        padding=1, bias=False)
        self.id=n_s
        self.ST=list(self.ST_struc)[self.id%self.len_ST]
        if self.id<self.depth_3d:
            self.conv2 = conv_S(planes,planes, stride=1,padding=(0,1,1))
            self.bn2 = nn.BatchNorm3d(planes)
            #
            self.conv3 = conv_T(planes,planes, stride=1,padding=(1,0,0))
            self.bn3 = nn.BatchNorm3d(planes)
        else:
            self.conv_normal = nn.Conv2d(planes, planes, kernel_size=3, stride=1,padding=1,bias=False)
            self.bn_normal = nn.BatchNorm2d(planes)

        if n_s<self.depth_3d:
            self.conv4 = nn.Conv3d(planes, planes * 4, kernel_size=1, bias=False)
            self.bn4 = nn.BatchNorm3d(planes * 4)
        else:
            self.conv4 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
            self.bn4 = nn.BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)

        self.stride = stride

conv_S和conv_T的定义如下:

def conv_S(in_planes,out_planes,stride=1,padding=1):
    # as is descriped, conv S is 1x3x3
    return nn.Conv3d(in_planes,out_planes,kernel_size=(1,3,3),stride=1,
                     padding=padding,bias=False)

def conv_T(in_planes,out_planes,stride=1,padding=1):
    # conv T is 3x1x1
    return nn.Conv3d(in_planes,out_planes,kernel_size=(3,1,1),stride=1,
                     padding=padding,bias=False)

接下来介绍P3D类中的forward方法。前面介绍的P3D类或Bottleneck类的__init__只是定义了网络的层,但是层与层之间的连接关系一般是类中的forward方法来控制的。这里先介绍P3D类中的forward方法。P3D类中的forward方法是在main函数中运行out=model(data)时调用的。forward方法比较清晰,先是1*7*7的卷积这部分,这个卷积会将10*3*16*160*160的输入变成10*64*16*80*80的输出,随后的x=self.maxpool(x)进一步将输入x变成10*64*8*39*39大小。然后是4个layer,每个layer其实是一个block,里面包含多个layer的叠加,叠加的先后逻辑关系已经在__init__函数中通过调用self._make_layer方法确定了。当然这里当执行到layer内部的时候,以self.layer1(x)为例,会调用Bottleneck类的forward方法(这个在后面会详细介绍)。
介绍下forward方法中数据的维度变化,数据都是Variable类型。forward方法的输入x维度是10*3*16*160*160,10是表示10个clip,3是3通道彩色,16表示帧数,160*160是每一帧图像的大小。x = self.conv1_custom(x)后x的维度是10*64*16*80*80。x = self.maxpool(x)后x的维度是10*64*8*39*39。self.layer1(x)后的维度是10*256*8*39*39。x = self.maxpool_2(self.layer1(x))后x的尺寸是10*256*4*39*39,可以看出self.maxpool_2是对倒数第3个维度做了减半。self.layer2(x)后的维度是10*512*4*20*20。x = self.maxpool_2(self.layer2(x))后x的尺寸是10*512*2*20*20。self.layer3(x)后的维度是10*1024*2*10*10。x = self.maxpool_2(self.layer3(x))后x的尺寸是10*1024*1*10*10。可以看出输入之所以采用16帧,是和网络的4次对该维度的减半对应。x.view是一个reshape操作,将5维的1*1024*1*10*10变成4维的10*1024*10*10。x = self.layer4(x)后x的维度是10*2048*5*5,因此self.layer4中的卷积都是二维卷积。x = self.avgpool(x)后x的维度是10*2048*1*1。x = x.view(-1,self.fc.in_features)中的self.fc.in_features是指定义的全连接层的输入channel数量,所以得到的x维度就是10*2048。再经过dropout层,最后经过全连接层:x = self.fc(self.dropout(x)),因为全连接层的输出channel设置为400,这是因为kinetics数据集的类别数是400,所以最后输出维度是10*400,如果数据集是sports-1M,那么类别数就是487。

def forward(self, x):
        x = self.conv1_custom(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.maxpool_2(self.layer1(x))  #  Part Res2
        x = self.maxpool_2(self.layer2(x))  #  Part Res3
        x = self.maxpool_2(self.layer3(x))  #  Part Res4

        sizes=x.size()
        x = x.view(-1,sizes[1],sizes[3],sizes[4])  #  Part Res5
        x = self.layer4(x)
        x = self.avgpool(x)

        x = x.view(-1,self.fc.in_features)
        x = self.fc(self.dropout(x))

        return x

接下来介绍Bottleneck类中的forward方法,这是在P3D类的forward方法中进行到类似self.layer1(x)这一步的时候会调用的(之所以用类似这个词是因为self.layer2(x)、self.layer3(x)等也会调用)。self.conv1就是channel缩减的卷积层。然后就根据self.ST的不同值来选择不同的P3D子结构(分别调用self.ST_A、self.ST_B、self.ST_C方法,这些方法也是定义在Bottleneck类中,后面有列出代码)。最后的self.conv4就是channel增加的卷积层。out += residual就是ResNet中skip connection的支路合并部分。

 def forward(self, x):
        residual = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        # out = self.conv2(out)
        # out = self.bn2(out)
        # out = self.relu(out)
        if self.id<self.depth_3d: # C3D parts: 

            if self.ST=='A':
                out=self.ST_A(out)
            elif self.ST=='B':
                out=self.ST_B(out)
            elif self.ST=='C':
                out=self.ST_C(out)
        else:
            out = self.conv_normal(out)   # normal is res5 part, C2D all.
            out = self.bn_normal(out)
            out = self.relu(out)

        out = self.conv4(out)
        out = self.bn4(out)

        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out

ST_A、ST_B和ST_C是论文中重要的子结构,和论文对应,比较容易理解。

def ST_A(self,x):
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu(x)

        x = self.conv3(x)
        x = self.bn3(x)
        x = self.relu(x)

        return x

    def ST_B(self,x):
        tmp_x = self.conv2(x)
        tmp_x = self.bn2(tmp_x)
        tmp_x = self.relu(tmp_x)

        x = self.conv3(x)
        x = self.bn3(x)
        x = self.relu(x)

        return x+tmp_x

    def ST_C(self,x):
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu(x)

        tmp_x = self.conv3(x)
        tmp_x = self.bn3(tmp_x)
        tmp_x = self.relu(tmp_x)

        return x+tmp_x
展开阅读全文

没有更多推荐了,返回首页