最近一直在研究时序动作识别和检测，也一直关注着目前的最新进展，有好的算法，我都会在我自己的数据集上运行看看，一方面是为自己累积相关算法，另一方面也是想看看，目前最新的算法是否可以应用到一些项目上。这次我运行2023年新出来的算法-时序动作检测TriDet。算法的论文地址和github地址如下：
论文地址：https://arxiv.org/pdf/2303.07347.pdf
GitHub地址：https://github.com/dingfengshi/TriDet
算法讲解百度上有，作者自己在bilibil上也有视频讲解，有需要的可以自己去看看。
该作者在算法上测试了epic-kitchens,activityNet和thumos14数据集的slowfast特征和I3D特征，而且在代码里的datasets也对应了每种数据集的加载方式，结合自己的项目，因此我这次选用使用的slowfast特征且用epic_kitchens进行加载和训练自己的数据集。
一、环境配置
1.1、安装slowfast算法环境
这个没啥说的，就是根据github上的SlowFast算法结束的安装环境。
1.2、安装TriDet算法环境
这个也没啥说的，也就是根据 github上的TriDet算法结束的安装环境。可能存在部分安装包冲突，这个就是看哪个包的版本高了就降一点，没啥大的问题。
二、数据准备
根据官网的训练配置文件和其提供的公开数据，需要两个文件，一个是放所有的视频特征文件，一个是数据划分的参数json文件。
这里显示一下json文件的内容格式，基本包含的内容，如下：
"version": "epic-action-noun",
"database": {
"video_A": {
"annotations": [{"label": "1", "label_id": 0,"segment": [0.0,0.3333333333333333]
},{"label": "2","label_id": 1,"segment": [48.4,49.4},"resolution": [800,800],"duration": 49.4,"subset": "training"},....,"video_B": {
"annotations": [{"label": "46", "label_id": 45,"segment": [0.0,0.5]
},{"label": "48","label_id": 47,"segment": [48.4,49.4]},"resolution": [800,800],"duration": 49.4,"subset": "validation"}}
上面的version就是数据格式，database里就包含了每个视频里每个动作的
label(动作名称）,
label_id(分类id),
segment(分割的时间点),
resolution(图像大小),
duration(视频的总时长),
subset(数据类型：训练/验证）
而每个视频通过slowfast运行的特征保存成.npy格式数据。
因此要制作自己的数据集，那就要准备两部分工作，首先是将视频分割成每个子视频，并记录每个子视频在整个视频里的起始时间。而我以前做了slowfast训练自己的数据，因此我的数据都已经分割好了，只是图像而已，因此我的两部分工作是，第一通过分割好的图片生成上面对应的json文件；第二要生成对应的视频，再通过SlowFast提取特征。我的图片数据格式如下：
tridet_data:
----train
-----A1
-------a0_0 ->a0是label,0是label_id，如果label保存在一个文件里，如text，那可直接读取----------0.jpg
----------1.jpg
-------a1_1
----------0.jpg
----------1.jpg
-------------
2.1生成json文件，
我把生成json的代码，有需要的要根据自己的数据目录格式进行修改，运行后，我生成了一个epic_name_none.json文件
import cv2
import os
import json
import re
height=800
width=800
img_size=(width,height)
# print(size)
fps=30
def write_to_json(data,json_path):
with open(json_path, 'a', encoding='utf-8') as json_file:
json.dump(data, json_file, ensure_ascii=False, indent=2)
#读取label
def read_lable(label_path):
with open(label_path,'r',encoding='utf-8') as pbtxt_file:
content = pbtxt_file.read()
pattern = re.compile(r'(\w+)\s*:\s*(\S+)')
matches = pattern.findall(content)
new_content=match_pbtxt(matches)
return new_content
#生成数据格式
def statis_frames(root_path,label_content,all_data):
all_file_list = os.listdir(root_path)
sub_sig=root_path.split('/')[-2]
for file_name in all_file_list:
print('**************process the file is {}********************'.format(file_name))
all_data[file_name]={}
file_path = os.path.join(root_path, file_name)
sub_file_lists = os.listdir(file_path)
sub_files = sorted([int(sub_file_name.split('_')[-1]) for sub_file_name in sub_file_lists])
s,e=0,0
start_time,end_time=0,0
base_data=[]
for i in range(len(sub_files)):
img_base_data = {}
label=str(sub_files[i])#后面与标签文件对应
if label in label_content.keys():
label_name=label_content[label]
label_id=sub_files[i]
sub_file_path=os.path.join(file_path,file_name+'_'+str(sub_files[i]))
img_lists=os.listdir(sub_file_path)
len_img_lists=len(img_lists)-1
#计算分割时间
start_time=s/fps
e=e+len_img_lists
end_time=e/fps
s=e+1
img_base_data["label"]=label_name
img_base_data["label_id"]=label_id-1
img_base_data["segment"]=[start_time,end_time]
base_data.append(img_base_data)
all_data[file_name]["annotations"]=base_data
all_data[file_name]["resolution"]=img_size
all_data[file_name]["duration"] = end_time
if sub_sig=='train':
all_data[file_name]["subset"] = "training"
if sub_sig=='val':
all_data[file_name]["subset"] = "validation"
return all_data
def process_img_to_json(root_path,json_path,json_name,label_path):
sub_setes=["train","val"]
out_json_path = os.path.join(json_path, json_name)
json_data={}
all_data={}
#从原先的slowfast训练集里的pbtxt读取label
label_content = read_lable(label_path)
for sub_set in sub_setes:
# 原先的slowfast训练自己的数据是，frames30包含了每个子视频的所有帧图像
hig_root_path=os.path.join(root_path,sub_set,'frames30')
print("the path runing is {}*************".format(hig_root_path))
content=statis_frames(hig_root_path,label_content,all_data)
all_data=content
json_data['version'] = "epic-name-noun"
json_data["database"] = all_data
write_to_json(json_data, out_json_path)
print('配置文件json已生成************')2.2生成视频，并使用SlowFast算法提取动作特征
我也把生成视频的代码和对SlowFast算法添加的代码也都贴出来，有需要的，可以自己进行修改。
（1）生成fps为30的视频代码。
import cv2
import os
import json
import re
height=800
width=800
img_size=(width,height)
# print(size)
fps=30
#批量处理将图片转换成视频
def img2video(root_path,all_out_video_path):
all_file_list=os.listdir(root_path)
if not os.path.exists(all_out_video_path):
os.makedirs(all_out_video_path)
for file_name in all_file_list:
print('**************process the file is {}********************'.format(file_name))
file_path = os.path.join(root_path, file_name)
out_video_path=os.path.join(all_out_video_path,file_name)
if not os.path.exists(out_video_path):
os.makedirs(out_video_path)
sub_file_lists = os.listdir(file_path)
files = sorted([int(sub_file_name.split('_')[-1]) for sub_file_name in sub_file_lists])
video = cv2.VideoWriter(os.path.join(out_video_path, file_name+'.mp4'), cv2.VideoWriter_fourcc(*"mp4v"), fps,
(width, height))
for i in range(len(files)):#一套动作的所有文件
img_file_name=file_name+'_'+str(files[i])
print('process the file is ',img_file_name)
files_path=os.path.join(file_path,img_file_name)
sub_imgs=os.listdir(files_path)
img_list = sorted([int((file.split('.')[0]).split('_')[-1]) for file in sub_imgs if file.endswith('.jpg')])
for j in range(len(img_list)):
img_name='img_'+'%05d'%img_list[j]+'.jpg'
img_path=os.path.join(files_path,img_name)
img=cv2.imread(img_path)
video.write(img)
video.release()
print('*****************process the file down,and the sum of files is {}***********'.format(len(all_file_list)))
def process_img_to_video(root_path,output_video_path):
sub_setes=["train","val"]
for sub_set in sub_setes:
#原先的slowfast训练自己的数据是，frames30包含了每个子视频的所有帧图像
hig_root_path=os.path.join(root_path,sub_set,'frames30')
print("the path runing is {}*************".format(hig_root_path))
img2video(hig_root_path,output_video_path)
print('视频数据已生成************')（2）SlowFast推理算法
改的地方有点多，可以去github上找到开源的代码，如果自己写的话，那就要读懂slowfast的结构和后面输出的特征，我就不将所有的代码贴出来了，因为那样的话，代码太多了，我就说一下，我修改了哪些地方，仅供大家参考。
①slowfast/visualization/utils.py
在TaskInfo类的后面添加下面代码：
def add_action_preds(self, preds):
"""
Add the corresponding action predictions.
"""
self.action_preds = preds
def add_feats(self, feats):
"""
Add the corresponding action predictions.
"""
self.feats = feats②slowfast/models/head_helper.py
在ResNetBasicHead类的forward
def forward(self, inputs):
assert (
len(inputs) == self.num_pathways
), "Input tensor does not contain {} pathway".format(self.num_pathways)
pool_out = []
for pathway in range(self.num_pathways):
m = getattr(self, "pathway{}_avgpool".format(pathway))
pool_out.append(m(inputs[pathway]))
x = torch.cat(pool_out, 1)
# (N, C, T, H, W) -> (N, T, H, W, C).
x = x.permute((0, 2, 3, 4, 1))
#添加下面两步
#save features
feat = x.clone().detach()
# flatten the features tensor
feat = feat.mean(3).mean(2).reshape(feat.shape[0], -1)
# Perform dropout.
if hasattr(self, "dropout"):
x = self.dropout(x)
x = self.projection(x)
# Performs fully convlutional inference.
if not self.training:
x = self.act(x)
x = x.mean([1, 2, 3])
x = x.view(x.shape[0], -1)
return x,feat③slowfast/visualization/predictor.py
在predictor类后面进行修改下面几处地方的代码
if self.cfg.DETECTION.ENABLE and not bboxes.shape[0]:
preds = torch.tensor([])
else:
#①得到feats
preds,feats = self.model(inputs, bboxes)
if self.cfg.NUM_GPUS:
preds = preds.cpu()
if bboxes is not None:
bboxes = bboxes.detach().cpu()
preds = preds.detach()
task.add_action_preds(preds)
#②将feats添加到task里面
task.add_feats(feats)
if bboxes is not None:
task.add_bboxes(bboxes[:, 1:])
return task④slowfast/models/video_model_builder.py
在ResNet类的forward的后面修改
if self.enable_detection:
x = self.head(x, bboxes)
return x
else:
x,feat= self.head(x)
return x,feat⑤tools/demo_net.py
在demo函数里修改
def demo(cfg):
if cfg.DETECTION.ENABLE and cfg.DEMO.PREDS_BOXES != "":
precomputed_box_vis = AVAVisualizerWithPrecomputedBox(cfg)
precomputed_box_vis()
else:
start = time.time()
if cfg.DEMO.THREAD_ENABLE:
frame_provider = ThreadVideoManager(cfg)
else:
frame_provider = VideoManager(cfg)
feat_arr= None
for task in tqdm.tqdm(run_demo(cfg, frame_provider)):
feat=task.feats
if len(feat)>0:
feat = feat.cpu().numpy()
if feat_arr is None:
feat_arr = feat
else:
feat_arr = np.concatenate((feat_arr, feat), axis=0)
return feat_arr⑥main函数代码，批量生成slowfast特征
def run_inference_batch(cfg, demo):
#这里的DEMO是我自己定义的配置文件，也可以直接输入文件路径，有需要的一定要改一下
input_folder = cfg.DEMO.INPUT_VIDEO
output_folder = cfg.DEMO.OUTPUT_FOLDER
cfg.TRAIN.CHECKPOINT_FILE_PATH = cfg.DEMO.CHECKPOINT1
print("Loading Video List ...")
file_video_list=os.listdir(input_folder)
print("Done")
print("----------------------------------------------------------")
vid_no=0
print("{} videos to be processed...".format(len(file_video_list)))
print("----------------------------------------------------------")
for video_file in file_video_list:
video_file_path=os.path.join(input_folder,video_file)
input_video = os.path.join(input_folder,video_file,video_file+'.mp4')
cfg.DEMO.INPUT_VIDEO = input_video
cfg.DEMO.OUTPUT_FOLDER = output_folder
print("{}. Processing {}...".format(vid_no, video_file))
out_file = video_file + ".npy"
if os.path.exists(os.path.join(video_file_path, out_file)):
print("{}. {} already exists".format(vid_no, out_file))
print("----------------------------------------------------------")
continue
feat_arr = demo(cfg)
feat_data = {}
feat_data['feats'] = feat_arr
os.makedirs(video_file_path, exist_ok=True)
np.save(os.path.join(video_file_path, out_file), feat_data)
vid_no=vid_no+1
print("Done.")
print("----------------------------------------------------------")
if __name__=='__main__':
run_inference_batch(cfg, demo)这样就可以生成每个视频的slowfast特征。
三、训练模型
当需要的数据都生成好了，将epic_slowfast_noun.yaml相关的地方修改成自己的数据地址，然后运行，python train.py ./configs/epic_slowfast_noun.yaml，就可以了，我的训练过程如下。
四、训练时出现的问题
①数据加载错误：提取的slowfast特征需要先转换成list，在使用slowfast提取特征保存时也采用字典形式，但是在TriDet加载时数据报错，需要做转换。
这个需要在libs/datasets/epic_kitchens.py代码的EpicKitchensDataset类里去修改
def __getitem__(self, idx):
# directly return a (truncated) data point (so it is very fast!)
# auto batching will be disabled in the subsequent dataloader
# instead the model will need to decide how to batch / preporcess the data
video_item = self.data_list[idx]
# load features
# print('*************',video_item)
filename = os.path.join(self.feat_folder,self.file_prefix + video_item['id'] + self.file_ext)
# print('the idx is {},and the filename is {}'.format(idx,filename))
#写入下面两行代码
data=np.load(filename)
feats=data.tolist()['feats'].astype(np.float32)
#将下面几行注释掉
# with np.load(filename) as data:
# feats = data['feats'].astype(np.float32)
# deal with downsampling (= increased feat stride)
feats = feats[::self.downsample_rate, :]
feat_stride = self.feat_stride * self.downsample_rate②问题2：提取的slowfast特征有问题，部分数据不是字典格式的，对所有的特征进行检测，发现有4个视频保存的特征是list。
这个需要检测生成的slowfast特征是否有问题，用代码读取一下就可以判断了，这里就不贴代码了。
③问题3，标签数错误,我的数据没有背景项，所有只有45类，但是该算法需要加上背景项，因此yaml文件里的num_class应设置为46。
④问题4、训练参数设置问题，基于算法默认和经验值，对学习率和epoch进行设置，出现两种现象，当lr选择过大，cls_loss会出现NAN值，lr选择默认或者较小会导致loss无法下降，选择中间值，发现训练到后期出现震荡现象。
这个问题我还是没有好的办法解决，但是我将loss设置成0.0005，epoch设置成100、150，测试结果发现使用epic格式的数据准确度在epoch达到30左右分数最高，与论文里的结果差不多。
