视频处理：PCANet提取视频空间特征

提取每个视频的关键帧，作为视频空间特征提取的输入。通过操作，会发现每个视频的关键帧数量是不同的，这就意味着如果用深度学习网络对单幅视频帧进行特征提取，每个视频的特征数量是不同的，这样就没有办法放在svr这样的回归器中进行训练。这里我采用的办法是分段处理。

将提取的关键帧按10帧为一段，标签同整个视频的标签处理。在处理过程中会出现剩余得帧数少于10帧，但也有8帧9帧，如果全部丢弃会丢失很多信息，这里将少于5帧的丢弃，超过5帧，就从剩余的帧中随机抽取几帧补全10帧，做为一条数据。

def main():
    c_b_videos = []
    c_d_value = []
    c_s_value = []
    for class_name in os.listdir(path):
        class_path = os.path.join(path, class_name)
        with open(class_path + '/' + class_name + '_DMOS_SD.txt', 'r') as f:  # 读取每个视频分数文件，将每个文件夹下的视频的名称和分数存为一个txt文件
            data_str = f.read()
            datalist = data_str.split('\n')#分出每个视频名字和分数
        b_videos = []
        d_value = []
        s_value = []
        #遍历每个视频
        for i in datalist:
            info = i.split(",")
            video_name = info[0]#视频名字
            DMOS_score = info[1]#视频的the mean of DMOS
            SD_score = info[2]#视频的standrad devi of DMOS
            print("Video Name is ", video_name)
            video_path = os.path.join(class_path,video_name) #获取视频路径
            frame_diffs = []
            frames = []
            i = 1
            cap = cv2.VideoCapture(str(video_path))#读取视频
            ret, frame = cap.read()#读取视频帧
            curr_frame = None
            prev_frame = None
            while (ret):
                luv = cv2.cvtColor(frame, cv2.COLOR_BGR2LUV) #将rgb的图像帧转化为luv格式
                curr_frame = luv
                if curr_frame is not None and prev_frame is not None:
                    diff = cv2.absdiff(curr_frame, prev_frame) #求取每两帧之间每一像素点的差别
                    count = np.sum(diff)#像素差求和
                    frame_diffs.append(count)
                    frame = Frame(i, frame, count)
                    frames.append(frame)
                prev_frame = curr_frame
                i = i + 1
                ret, frame = cap.read()
            cap.release()
            print("Using Local Maxima")
            diff_array = np.array(frame_diffs)
            sm_diff_array = smooth(diff_array, len_window)
            #获取关键帧索引
            frame_indexes = np.asarray(argrelextrema(sm_diff_array, np.greater))[0]
            frames_data = []
            #根据关键帧索引获取关键帧
            for f in frame_indexes:
                image = frames[f - 1].frame[130:158, 200:228, :]
                frames_data.append(image)
            #将关键帧分块，9帧一块，少于4帧丢弃，多于4帧从原有帧中随机取补齐9帧
            while (len(frames_data)>4):
                if len(frames_data)<9:
                    lackNum = 9-len(frames_data)
                    copy_data = copy.deepcopy(frames_data)
                    shuffle(copy_data)
                    lack_frames  = copy_data[0:lackNum]
                    blockVideo = np.concatenate([frames_data, lack_frames], axis=0)
                else:
                    blockVideo = np.array(frames_data[0:9])
                b_videos.append(blockVideo)
                d_value.append(DMOS_score)
                s_value.append(SD_score)
                del frames_data[0:9]
        c_b_videos.append(b_videos)
        c_d_value.append(d_value)
        c_s_value.append(s_value)

经过以上处理之后，一个视频可能会变成好几条包含10帧图像的数据，每一条数据有一个标签。以上是视频数据的处理。下面将处理好的数据放入PCANet中进行训练。一条数据包含10帧图像，将每一个图像放入PCANet中会得到一个有几万个特征值的向量，10帧图像就会有30万左右的特征值。所有的数据训练完毕，将特征值放入svr中进行训练，出现意料之中的内存溢出问题。解决办法：对特征值进行降维。