基于C3D网络的视频分析与动作识别

这篇具有很好参考价值的文章主要介绍了基于C3D网络的视频分析与动作识别。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

卷积神经网络(CNN)被广泛应用于计算机视觉中,包括分类、检测、分割等任务。这些任务一般都是针对图像进行的,使用的是二维卷积(即卷积核的维度为二维)。而对于基于视频分析的问题,2D convolution不能很好得捕获时序上的信息,因此3D卷积就被提出来了。

3D卷积 最早应该是在 《3D convolutional neural networks for human action recognition》 这片论文中被提出并用于行为识别的,而C3D是作为一个通用的网络提出的,论文中将其用于行为识别,场景识别,视频相似度分析等领域。
9

3D卷积与2D卷积的区别

首先看一下二维卷积,一个3*3的卷积核,在单通道图像上进行卷积,得到输出。
基于C3D网络的视频分析与动作识别
然后我们再看一下3维卷积,一个3*3*3的卷积核在立方体上进行卷积,得到输出:
基于C3D网络的视频分析与动作识别
多通道卷积不同的通道上的卷积核的参数是不同的,而3D卷积则由于卷积核本身是3D的,所以这个由于“深度”造成的看似不同通道上用的就是同一个卷积,权重共享

总之,多了一个深度通道,这个深度可能是视频上的连续帧,也可能是立体图像中的不同切片。

3D卷积的应用

上面也说了,3D卷积就是多了一个深度通道,而这个深度通道可能是视频上的连续帧,也可能是立体图像中的不同切片,所以从应用上来说,主要就是两大主要方向。

视频分类

相比于2D图像,什么数据多了一个维度呢?当然就是视频了,视频的帧数,就是完美的另一个深度维度,将3D卷积用于视频的分类.

基于C3D网络的视频分析与动作识别
如上图,是一个使用了3D CNN的网络结构,网络很浅,只有3个卷积层和1个全连接层,2个池化层,这里有两个3D卷积层,卷积核大小分别是7x7x3,7x6x3,前两维是空间的卷积,后一维是时间的卷积。

这个网络结构在视频分类数据集UCF-101上的top-1精度为63.3%,别看这个指标不高,其他的比如LSTM,双流网络等也差不太多,而普通的2D卷积或者传统方法则要低于这个指标。

图像分割

既然可以用于分类,自然也可以用于分割。不过对视频使用3D卷积似乎优势并不大,而在医学领域的应用前景更大一些。

医学数据通常都是3D的,比如CT扫描的数据,虽然我们看的片子是2D的,但其实那只是一个切片,真正的扫描数据是3D的。

而如果要分割出一些病变组织,比如肿瘤,也必须是3D的。
基于C3D网络的视频分析与动作识别
具体的网络结构就是将U-Net改为3D的形式。

基于C3D网络的视频分析与动作识别

基于C3D网络视频动作分析

视频分析中,时间序列维度上通过一次输入连续帧到C3D网络中进行分析,注意和图像分析中的batch进行区分,C3D网络输入的维度多了一个时间维度,一次会传入前后多张图像。

C3D 模型

论文链接
论文翻译
该论文发现:

  • 1、3D ConvNets比2D ConvNets更适用于时空特征的学习;
  • 2、对于3D ConvNet而言,在所有层使用3×3×3的小卷积核效果最好;
  • 3、我们通过简单的线性分类器学到的特征名为C3D(Convolutional 3D),在4个不同的基准上优于现有的方法,并在其他2个基准上与目前最好的方法相当。

论文的主要贡献

  • 我们的实验表明3D卷积深度网络是好的学习器,可以对外观和运动同时建模。
  • 我们的经验发现,在有限的探究框架中,所有层使用3×3×3卷积核效果最好。
  • 在4个任务和4个基准上,提出的特征通过简单的线性模型可以超过或接近目前最好的方法(见下表)。这些特征紧凑、计算高效。
    基于C3D网络的视频分析与动作识别
    C3D模型代码
class C3D(nn.Module):
    """
    The C3D network.
    """

    def __init__(self, num_classes):
        super(C3D, self).__init__()

        self.conv1 = nn.Conv3d(3, 64, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.pool1 = nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2))

        self.conv2 = nn.Conv3d(64, 128, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.pool2 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2))

        self.conv3a = nn.Conv3d(128, 256, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.conv3b = nn.Conv3d(256, 256, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.pool3 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2))

        self.conv4a = nn.Conv3d(256, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.conv4b = nn.Conv3d(512, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.pool4 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2))

        self.conv5a = nn.Conv3d(512, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.conv5b = nn.Conv3d(512, 512, kernel_size=(3, 3, 3), padding=(1, 1, 1))
        self.pool5 = nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2), padding=(0, 1, 1))

        self.fc6 = nn.Linear(8192, 4096)
        self.fc7 = nn.Linear(4096, 4096)
        self.fc8 = nn.Linear(4096, num_classes)

        self.dropout = nn.Dropout(p=0.5)

        self.relu = nn.ReLU()

        self.__init_weight()


    def forward(self, x):
        #print ('1:',x.size())
        x = self.relu(self.conv1(x))
        #print ('2:',x.size())
        x = self.pool1(x)
        #print ('3:',x.size())

        x = self.relu(self.conv2(x))
        #print ('4:',x.size())
        x = self.pool2(x)
        #print ('5:',x.size())

        x = self.relu(self.conv3a(x))
        #print ('6:',x.size())
        x = self.relu(self.conv3b(x))
        #print ('7:',x.size())
        x = self.pool3(x)
        #print ('8:',x.size())

        x = self.relu(self.conv4a(x))
        #print ('9:',x.size())
        x = self.relu(self.conv4b(x))
        #print ('10:',x.size())
        x = self.pool4(x)
        #print ('11:',x.size())

        x = self.relu(self.conv5a(x))
        #print ('12:',x.size())
        x = self.relu(self.conv5b(x))
        #print ('13:',x.size())
        x = self.pool5(x)
        #print ('14:',x.size())

        x = x.view(-1, 8192)
        #print ('15:',x.size())
        x = self.relu(self.fc6(x))
        #print ('16:',x.size())
        x = self.dropout(x)
        x = self.relu(self.fc7(x))
        x = self.dropout(x)

        logits = self.fc8(x)
        #print ('17:',logits.size())
        return logits
  • C3D网络架构跟2D网络架构没啥区别,就是多了一个时间维度。它的kernel_size和pading、stride都是对应的三维的,如kernel_size=(3,3,3) 和 padding=(1,2,2),stride=(2,2,2)。其中kernel_size中第一个3表示3帧卷积一次提取特征。
  • 第一次Maxpool3d对应的kernel_size=(1,2,2)和stride_size(1,2,2),其中时间维度对应kernel值为1,w,h对应2,说明经过该Maxpool3d时间维度大小不变,图片宽高的特征变为一半。原作者解释,在做3D卷积时,不希望一开始就压缩时间维度上的特征。
  • 第二次Maxpool3d对应的kernel_size=(2,2,2)和stride_size(2,2,2)都变为2,进行时间维度、w,h方向的特征压缩,同时channel越来越大。
  • 最好通过连接3个连接层,输出最终的结果。

UCF-101 数据集

数据集介绍

UCF101是一个现实动作视频的动作识别数据集,收集自YouTube,提供了来自101个动作类别的13320个视频。
基于C3D网络的视频分析与动作识别

  • 总视频数:13,320个视频
  • 总时长:27个小时
  • 视频来源:YouTube采集
  • 视频类别:101 种
  • 主要包括5大类动作 :人与物体交互,单纯的肢体动作,人与人交互,演奏乐器,体育运动
  • 每个类别(文件夹)分为25组,每组4~7个短视频,每个视频时长不等
    具体类别:涂抹眼妆,涂抹口红,射箭,婴儿爬行,平衡木,乐队游行,棒球场,篮球投篮,篮球扣篮,卧推,骑自行车,台球射击,吹干头发,吹蜡烛,体重蹲,保龄球,拳击沙袋,拳击速度袋,蛙泳,刷牙,清洁和挺举,悬崖跳水,板球保龄球,板球射击,在厨房切割,潜水,打鼓,击剑,曲棍球罚款,地板体操,飞盘接球,前爬网,高尔夫挥杆,理发,链球掷,锤击,倒立俯卧撑,倒立行走,头部按摩,跳高,跑马,骑马,呼啦圈,冰舞,标枪掷,杂耍球,跳绳,跳跃杰克,皮划艇,针织,跳远,刺,阅兵,混合击球手,拖地板,修女夹头,双杠,披萨折腾,弹吉他,弹钢琴,弹塔布拉琴,弹小提琴,弹大提琴,弹Daf,弹Dhol,弹长笛,弹奏锡塔琴,撑竿跳高,鞍马,引体向上,拳打,俯卧撑,漂流,室内攀岩,爬绳,划船,莎莎旋转,剃胡子,铅球,滑板溜冰,滑雪,Skijet,跳伞,足球杂耍,足球罚球,静环,相扑摔跤,冲浪,秋千,乒乓球拍,太极拳,网球秋千,投掷铁饼,蹦床跳跃,打字,高低杠,排球突刺,与狗同行,墙上俯卧撑,在船上写字,溜溜球。剃胡须,铅球,滑冰登机,滑雪,Skijet,跳伞,足球杂耍,足球罚款,静物环,相扑,冲浪,秋千,乒乓球射击,太极拳,网球秋千,掷铁饼,蹦床跳跃,打字,不均匀酒吧,排球突刺,与狗同行,壁式俯卧撑,船上写字,溜溜球。剃胡须,铅球,滑冰登机,滑雪,Skijet,跳伞,足球杂耍,足球罚款,静物环,相扑,冲浪,秋千,乒乓球射击,太极拳,网球秋千,掷铁饼,蹦床跳跃,打字,不均匀酒吧,排球突刺,与狗同行,壁式俯卧撑,船上写字,溜溜球

每种视频类型,包括一系列的视频片段:
基于C3D网络的视频分析与动作识别
数据集下载
UCF101数据下载
官方数据划分下载

数据处理

有了视频之后需要干什么呢?实际在网络输入的时候真能输入一个视频吗?,答案肯定不是的。大家想想我们构造C3D模型进行动作分析,输入3D的卷积中,除了第一个维度batch之外,第二个维度代表是序列的长度,假设序列的长度是16,那么在视频处理时我们需要从中提取出16帧的图像。因此我们需要先对视频数据集做预处理,从每个视频中抽取16帧,16帧组成输入的16个序列。

大家可能会觉得做模型训练过程中,把视频读进来,边抽取数据会比较好,答案是可以的,但相对会比较麻烦,这样会导致每次训练过程,都需要从视频中抽取数据,而且训练过程还需要调参,需要消耗大量的算力。

所以在拿到视频数据后,第一步都需要对视频数据做预处理,把视频数据转换为后续需要用的一帧帧图像数据,并且保存到文件中,这样后续建模中会更加方便。

  • UCF-101视频数据按每类动作视频抽取的图像,并划分训练集、验证集、测试集。提取后的图片数据单独存放在data_process文件夹,data_process下面新建test,train,val文件
    基于C3D网络的视频分析与动作识别
    如果不想从视频中提取划分图片,可以直接下载官方划分好的数据集
  • 对视频每隔EXTRACT_FREQUENCY提取一帧图像,·EXTRACT_FREQUENCY·初始化为4(每隔4帧区一张图像),但由于各个视频长短不一样,为了保证每个视频至少能够提取16张图像,所以针对不同视频调整EXTRACT_FREQUENCY的值。
  • 根据论文,需要将图像的宽高调整到:(171,128),其中代码中self.resize_width=171,self.resize_height=128,另外还需要将得到的图片随机裁剪crop_size=112大小。
  • 提取每个视频16张图片序列,输入到C3D模型中
 def preprocess(self):
        if not os.path.exists(self.output_dir):
            os.mkdir(self.output_dir)
            os.mkdir(os.path.join(self.output_dir, 'train'))
            os.mkdir(os.path.join(self.output_dir, 'val'))
            os.mkdir(os.path.join(self.output_dir, 'test'))

        # Split train/val/test sets
        for file in os.listdir(self.root_dir):
            file_path = os.path.join(self.root_dir, file)
            video_files = [name for name in os.listdir(file_path)]

            train_and_valid, test = train_test_split(video_files, test_size=0.2, random_state=42)
            train, val = train_test_split(train_and_valid, test_size=0.2, random_state=42)

            train_dir = os.path.join(self.output_dir, 'train', file)
            val_dir = os.path.join(self.output_dir, 'val', file)
            test_dir = os.path.join(self.output_dir, 'test', file)

            if not os.path.exists(train_dir):
                os.mkdir(train_dir)
            if not os.path.exists(val_dir):
                os.mkdir(val_dir)
            if not os.path.exists(test_dir):
                os.mkdir(test_dir)

            for video in train:
                self.process_video(video, file, train_dir)

            for video in val:
                self.process_video(video, file, val_dir)

            for video in test:
                self.process_video(video, file, test_dir)

        print('Preprocessing finished.')
        
 def process_video(self, video, action_name, save_dir):
        # Initialize a VideoCapture object to read video data into a numpy array
        video_filename = video.split('.')[0]
        if not os.path.exists(os.path.join(save_dir, video_filename)):
            os.mkdir(os.path.join(save_dir, video_filename))

        capture = cv2.VideoCapture(os.path.join(self.root_dir, action_name, video))

        frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
        frame_width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
        frame_height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))

        # Make sure splited video has at least 16 frames
        EXTRACT_FREQUENCY = 4
        if frame_count // EXTRACT_FREQUENCY <= 16:
            EXTRACT_FREQUENCY -= 1
            if frame_count // EXTRACT_FREQUENCY <= 16:
                EXTRACT_FREQUENCY -= 1
                if frame_count // EXTRACT_FREQUENCY <= 16:
                    EXTRACT_FREQUENCY -= 1

        count = 0
        i = 0
        retaining = True

        while (count < frame_count and retaining):
            retaining, frame = capture.read()
            if frame is None:
                continue

            if count % EXTRACT_FREQUENCY == 0:
                if (frame_height != self.resize_height) or (frame_width != self.resize_width):
                    frame = cv2.resize(frame, (self.resize_width, self.resize_height))
                cv2.imwrite(filename=os.path.join(save_dir, video_filename, '0000{}.jpg'.format(str(i))), img=frame)
                i += 1
            count += 1

        # Release the VideoCapture once it is no longer needed
        capture.release()

def load_frames(self, file_dir):
        frames = sorted([os.path.join(file_dir, img) for img in os.listdir(file_dir)])
        frame_count = len(frames)
        buffer = np.empty((frame_count, self.resize_height, self.resize_width, 3), np.dtype('float32'))
        for i, frame_name in enumerate(frames):
            frame = np.array(cv2.imread(frame_name)).astype(np.float64)
            buffer[i] = frame

        return buffer

def crop(self, buffer, clip_len, crop_size):
     # randomly select time index for temporal jittering
     time_index = np.random.randint(buffer.shape[0] - clip_len)

     # Randomly select start indices in order to crop the video
     height_index = np.random.randint(buffer.shape[1] - crop_size)
     width_index = np.random.randint(buffer.shape[2] - crop_size)

     # Crop and jitter the video using indexing. The spatial crop is performed on
     # the entire array, so each frame is cropped in the same location. The temporal
     # jitter takes place via the selection of consecutive frames
     buffer = buffer[time_index:time_index + clip_len,
              height_index:height_index + crop_size,
              width_index:width_index + crop_size, :]

     return buffer

自定义Dataset

有时候,在处理大数据集时,一次将整个数据加载到内存中变得非常难。因此,唯一的方法是将数据分批加载到内存中进行处理,这需要编写额外的代码来执行此操作。对此,PyTorch 已经提供了 Dataloader 功能。

下面显示了 PyTorch 库中DataLoader函数的语法及其参数信息。

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False)

参见pytorch官方文档,

主要参数:

  • dataset (dataset)—从其中加载数据的数据集。
  • Batch_size (int,可选)-每批加载多少个样本(默认值:1)。
  • shuffle (bool,可选)-设置为True在每个时期重新洗牌数据(默认:False)。
  • sampler (sampler或Iterable,可选)-定义从数据集中抽取样本的策略。可以是任何实现了__len__的可迭代对象。如果指定了,则不能指定shuffle。
  • batch_sampler (Sampler或Iterable,可选)-类似于Sampler,但每次返回一批索引。与batch_size、shuffle、sampler和dro函数互斥
  • Num_workers (int,可选)——用于数据加载的子进程数。0表示数据将在主进程中加载。(默认值:0)
  • collate_fn(可调用,可选)-合并一个样本列表,形成一个张量的小批。当从映射风格的数据集使用批处理加载时使用。
  • pin_memory (bool,可选)-如果为True,数据加载器将在返回张量之前将张量复制到CUDA固定内存中。
  • drop_last (bool,可选)-如果数据集大小不能被批处理大小整除,则设置为True将删除最后一个未完成的批处理。如果为False且数据集的大小不能被批处理大小整除,则最后一批将更小。(默认值:False)
  • Timeout(数值,可选)-如果为正值,则为从workers中收集批处理的超时值。应该总是非负的。(默认值:0)
  • worker_init_fn(可调用,可选)-如果不是None,将在每个worker子进程上调用这个- worker id (int in [0, num_workers - 1])作为输入,在播种之后和数据加载之前。
  • generator(torch.Generator,Generator,可选)-如果不是None,则RandomSampler将使用该RNG生成随机索引,并使用multiprocessing为worker生成base_seed。(默认值:无)
  • prefetch_factor (int,可选,仅关键字arg) -每个worker预先加载的样本数量。2表示在所有workers中总共会预取2 * num_workers样本。(默认值:2)
  • persistent_workers (bool,可选)-如果为True,数据加载器将不会在一个数据集被使用一次后关闭工作进程。这允许保持workers Dataset实例是活的。(默认值:False)

DataLoader支持map-style和可iterable-style数据集,可以单进程或多进程加载、自定义加载顺序和可选的自动批处理(排序)和内存固定。其中map-style类的数据集需要继承Dataset类:
基于C3D网络的视频分析与动作识别
因此通过继承Dataset类自定义数据集。

pytorch自定义数据集,需要继承Dataset类,并改写__init__, len,__getitme__函数。具体结构如下:

class ReadDataset(Dataset):
    def __init__(self, 参数...):

    def __len__(self, 参数...):
        ...
        return 数据长度

    def __getitem__(self, 参数...):
        ...
        return 字典

自定义Dataset的代码如下:

class VideoDataset(Dataset):
    r"""A Dataset for a folder of videos. Expects the directory structure to be
    directory->[train/val/test]->[class labels]->[videos]. Initializes with a list
    of all file names, along with an array of labels, with label being automatically
    inferred from the respective folder names.

        Args:
            dataset (str): Name of dataset. Defaults to 'ucf101'.
            split (str): Determines which folder of the directory the dataset will read from. Defaults to 'train'.
            clip_len (int): Determines how many frames are there in each clip. Defaults to 16.
            preprocess (bool): Determines whether to preprocess dataset. Default is False.
    """
    # 注意第一次要预处理数据的
    def __init__(self, dataset='ucf101', split='train', clip_len=16, preprocess=False):
        self.root_dir, self.output_dir = Path.db_dir(dataset)
        folder = os.path.join(self.output_dir, split)
        self.clip_len = clip_len
        self.split = split

        # The following three parameters are chosen as described in the paper section 4.1
        self.resize_height = 128
        self.resize_width = 171
        self.crop_size = 112

        if not self.check_integrity():
            raise RuntimeError('Dataset not found or corrupted.' +
                               ' You need to download it from official website.')

        if (not self.check_preprocess()) or preprocess:
            print('Preprocessing of {} dataset, this will take long, but it will be done only once.'.format(dataset))
            self.preprocess()

        # Obtain all the filenames of files inside all the class folders
        # Going through each class folder one at a time
        self.fnames, labels = [], []
        for label in sorted(os.listdir(folder)):
            for fname in os.listdir(os.path.join(folder, label)):
                self.fnames.append(os.path.join(folder, label, fname))
                labels.append(label)

        assert len(labels) == len(self.fnames)
        print('Number of {} videos: {:d}'.format(split, len(self.fnames)))

        # Prepare a mapping between the label names (strings) and indices (ints)
        self.label2index = {label: index for index, label in enumerate(sorted(set(labels)))}
        # Convert the list of label names into an array of label indices
        self.label_array = np.array([self.label2index[label] for label in labels], dtype=int)

        if dataset == "ucf101":
            if not os.path.exists('dataloaders/ucf_labels.txt'):
                with open('dataloaders/ucf_labels.txt', 'w') as f:
                    for id, label in enumerate(sorted(self.label2index)):
                        f.writelines(str(id+1) + ' ' + label + '\n')

        elif dataset == 'hmdb51':
            if not os.path.exists('dataloaders/hmdb_labels.txt'):
                with open('dataloaders/hmdb_labels.txt', 'w') as f:
                    for id, label in enumerate(sorted(self.label2index)):
                        f.writelines(str(id+1) + ' ' + label + '\n')


    def __len__(self):
        return len(self.fnames)

    #需要重写__getitem__方法
    def __getitem__(self, index):
        # Loading and preprocessing.
        buffer = self.load_frames(self.fnames[index]) #一共有8460个文件夹
        buffer = self.crop(buffer, self.clip_len, self.crop_size)
        labels = np.array(self.label_array[index])

        if self.split == 'test':
            # Perform data augmentation
            buffer = self.randomflip(buffer)
        buffer = self.normalize(buffer)
        buffer = self.to_tensor(buffer)
        return torch.from_numpy(buffer), torch.from_numpy(labels)
  • self.load_frames(),将每个视频提取后的图片,保存在一个buffer中。
  • self.crop() , 对self.load_frames()保存的buffer数据中,截取clip_len=16张时序图片,并对每张图片在w,h维度上随机裁取crop_size=112大小。
  • 对test数据通过self.randomflip(),水平随机翻转进行数据增强
  • self.normalize() 对图片数据沿着RGB3通道进行去均值的操作,3通道的均值为:
    np.array([[[90.0,98.0,102.0]]]) ,训练集进行去均值处理,同理测试集也需要去均值处理。
  • torch.from_numpy 将nd.array格式的数据,不满足pytorch tensor的数据格式要求,因此通过torch.from_numpy将数据转换为tensor格式
  • __getitem__(self, index)返回对应index索引下的buffer数据和标签labels

创建GPU训练环境

  • 虚拟环境创建
conda create -n C3D_env python=3.8 -y
conda activate C3D_env
  • 安装pytorch_gpu环境

训练脚本介绍

代码结构如下,其中train.py为训练的脚本
基于C3D网络的视频分析与动作识别
设置训练参数:

# Use GPU if available else revert to CPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("Device being used:", device)

nEpochs = 101  # Number of epochs for training
resume_epoch = 0  # Default is 0, change if want to resume
useTest = True # See evolution of the test set when training
nTestInterval = 20 # Run on test set every nTestInterval epochs
snapshot = 25 # Store a model every snapshot epochs
lr = 1e-5 # Learning rate
  • resume_epoch当训练中断时,可以不需要重新开始训练,可以从设置resume_epoch处开始训练,如resume_epoch=30,表示从之前epoch=30的训练结果中开始训练。
  • snapshot=25表示每隔25个epoch保存一次模型
  • lr = 1e-5 ,指定了一个非常小的学习率,因为根据测试指定 ( 10 ) − 3 (10)^{-3} (10)3
    1 0 − 4 10^{-4} 104训练效果不是很好

准备用于训练、验证、测试的dataloader数据

train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train',clip_len=16), batch_size=6, shuffle=True, num_workers=0)
val_dataloader   = DataLoader(VideoDataset(dataset=dataset, split='val',  clip_len=16), batch_size=6, num_workers=0)
test_dataloader  = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=16), batch_size=6, num_workers=0)
  • 其中clip_len=16表示时间序列长度,一次性处理16帧的数据,时间序列维度正是3D卷积相比2D卷积新增加的特性,具有时间特性。
  • batch_size表示批处理的数据。输入网络数据的维度为(batch_size,channel,clip_len,w,h) batch_sizebatch_size越大,一个epoch迭代的次数就越少,因此训练速度就越快。如果你显卡是12G以上,可以尝试设置为24,如果显卡的内存不足可以减少batch_size

训练过程说明

训练过程,每个epoch,通过sceduler.step()更新学习率lr,验证阶段不需要,代码上设置如下:

  if phase == 'train':
                # scheduler.step() is to be called once every epoch during training
                scheduler.step()
                model.train()
            else:
                model.eval()
  • 然后通过dataloader加载数据和标签,将数据带入模型,在训练阶段更新梯度,验证阶段不更新。通过Softmax计算输出的分类概率,去概率最大的索引作为预测的类别索引。
  • 每个epoch结束时计算一次平均损失,以及精度,并将结果保存到tensorboard,方便查看训练过程的损失和精度变化。
    for epoch in range(resume_epoch, num_epochs):
        # each epoch has a training and validation step
        for phase in ['train', 'val']:
            start_time = timeit.default_timer()

            # reset the running loss and corrects
            running_loss = 0.0
            running_corrects = 0.0

            # set model to train() or eval() mode depending on whether it is trained
            # or being validated. Primarily affects layers such as BatchNorm or Dropout.
            if phase == 'train':
                # scheduler.step() is to be called once every epoch during training
                scheduler.step()
                model.train()
            else:
                model.eval()

            for inputs, labels in tqdm(trainval_loaders[phase]):
                # move inputs and labels to the device the training is taking place on
                inputs = Variable(inputs, requires_grad=True).to(device)
                labels = Variable(labels).to(device)
                optimizer.zero_grad()

                if phase == 'train':
                    outputs = model(inputs)
                else:
                    with torch.no_grad():
                        outputs = model(inputs)

                probs = nn.Softmax(dim=1)(outputs)
                preds = torch.max(probs, 1)[1]
                loss = criterion(outputs, labels.long())

                if phase == 'train':
                    loss.backward()
                    optimizer.step()

                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)

            epoch_loss = running_loss / trainval_sizes[phase]
            epoch_acc = running_corrects.double() / trainval_sizes[phase]

            if phase == 'train':
                writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch)
                writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch)
            else:
                writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch)
                writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch)

保存模型

if epoch % save_epoch == (save_epoch - 1):
            torch.save({
                'epoch': epoch + 1,
                'state_dict': model.state_dict(),
                'opt_dict': optimizer.state_dict(),
            }, os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar'))
            print("Save model at {}\n".format(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar')))
  • 每隔 save_epoch保存一次模型,模型保存了当前的epoch,权重state_dict以及 优化器参数opt_dict

tensorboard 查看训练效果

pytorch tensorbard

  • 安装tensorboardX包
pip install tensorboardX
  • 导入
from tensorboardX import SummaryWriter
  • 创建writer对象,并指定logdir路径
log_dir = 'logdir_path_to_define'  # path to define
writer = SummaryWriter(log_dir=log_dir)
  • 将数据写入tensorboard
    比如保存训练和验证过程中的,各个epoch对应的 acc和loss
 if phase == 'train':
     writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch)
     writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch)
 else:
     writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch)
     writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch)
  • 训练完成后,终端利用tensorboard查看结果
tensorboard --logdir='logdir_path_to_define'   --host=localhost

这里的路径与SummaryWriter初始化,设置的logdir路经一样

基于C3D网络的视频分析与动作识别
可以设置更大的epoch,提升训练效果

识别效果
基于C3D网络的视频分析与动作识别
成功识别正在涂抹眼妆这个动作。文章来源地址https://www.toymoban.com/news/detail-402627.html

源码下载

到了这里,关于基于C3D网络的视频分析与动作识别的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 基于深度学习的中文情感分类 - 卷积神经网络 情感分类 情感分析 情感识别 评论情感分类 计算机竞赛

    🔥 优质竞赛项目系列,今天要分享的是 基于深度学习的中文情感分类 该项目较为新颖,适合作为竞赛课题方向,学长非常推荐! 🧿 更多资料, 项目分享: https://gitee.com/dancheng-senior/postgraduate Convolutional Neural Networks for Sentence Classification 模型结构 在短文本分析任务中,由于

    2024年02月07日
    浏览(68)
  • 计算机竞赛 基于深度学习的中文情感分类 - 卷积神经网络 情感分类 情感分析 情感识别 评论情感分类

    🔥 优质竞赛项目系列,今天要分享的是 基于深度学习的中文情感分类 该项目较为新颖,适合作为竞赛课题方向,学长非常推荐! 🧿 更多资料, 项目分享: https://gitee.com/dancheng-senior/postgraduate Convolutional Neural Networks for Sentence Classification 模型结构 在短文本分析任务中,由于

    2024年02月09日
    浏览(57)
  • 基于3D卷积的图像序列特征提取与自注意力的车牌识别方法

    【摘  要】 近年来,基于自注意力机制的神经网络在计算机视觉任务中得到广泛的应用。随着智能交通系统的广泛应用,面对复杂多变的交通场景,车牌识别任务的难度不断提高,准确识别的需求更加迫切。因此提出一个基于自注意力的免矫正的车牌识别方法T-LPR。首先对图

    2023年04月09日
    浏览(32)
  • 手写数字识别-基于卷积神经网络

    🌞欢迎来到机器学习的世界  🌈博客主页:卿云阁  💌欢迎关注🎉点赞👍收藏⭐️留言📝 🌟本文由卿云阁原创! 🌠本阶段属于练气阶段,希望各位仙友顺利完成突破 📆首发时间:🌹2021年6月5日🌹 ✉️希望可以和大家一起完成进阶之路! 🙏作者水平很有限,如果发

    2024年02月10日
    浏览(42)
  • 基于卷积神经网络的种子等级识别

    背影 卷积神经网络CNN的原理 卷积神经网络CNN的定义 卷积神经网络CNN的神经元 卷积神经网络CNN的激活函数 卷积神经网络CNN的传递函数 基于卷积神经网络的花生识别,基于卷积神经网络的种子识别 代码下载链接:基于卷积神经网络的花生识别,基于卷积神经网络的种子识别,

    2024年02月11日
    浏览(38)
  • MATLAB基于卷积神经网络的手势识别

    目录 1. 数据集介绍  2. 训练、保存网络 3. 手势识别 4. 识别结果 5. 总结 本实验所用数据集为从Kaggle平台下载的手语数据集(sign_mnist)中选取的部分数据。 sign_mnist 数据集格式的模式化与经典 MNIST 紧密匹配。每个训练和测试用例表示一个标签 (0-25),作为每个字母 A-Z 的一

    2024年02月06日
    浏览(105)
  • 手势识别系统Python,基于卷积神经网络算法

    手势识别系统,使用Python作为主要开发语言,基于深度学习TensorFlow框架,搭建卷积神经网络算法。并通过对数据集进行训练,最后得到一个识别精度较高的模型。并基于Django框架,开发网页端操作平台,实现用户上传一张图片识别其名称。 视频+代码:https://www.yuque.com/ziwu/

    2024年02月09日
    浏览(64)
  • 基于卷积神经网络VGG的猫狗识别

    !有需要本项目的实验源码的可以私信博主! 摘要: 随着大数据时代的到来,深度学习、数据挖掘、图像处理等已经成为了一个热门研究方向。深度学习是一个复杂的机器学习算法,在语音和图像识别方面取得的效果,远远超过先前相关技术。这也是深度学习在当下备受欢

    2024年02月12日
    浏览(44)
  • 基于卷积神经网络的3D动目标检测方法

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 ` 一种基于雷达的多类移动目标检测方法,该方法利用了目标级的专业知识(精确的二维定位、解决相位模糊),以及来自全三维立体雷达数据。包含的雷达数据可以在任何对象聚类之前对单个移动目标

    2024年02月08日
    浏览(52)
  • 基于pyqt和卷积网络CNN的中文汉字识别

    直接上效果演示图:  通过点击按钮可以实现在画板上写汉字识别和加载图片识别两个功能。 视频演示和demo仓库地址在b站视频001期: 到此一游7758258的个人空间-到此一游7758258个人主页-哔哩哔哩视频 所有代码展示: 十分的简洁,主要是01,02,03.py文件 运行01dataset.py可以将da

    2024年02月13日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包