generate_pkl_data.py

Go to the documentation of this file.

import pickle
import numpy as np
import copy
import os
 
from smdataset.gen_data.cvt_labelmap import *
from smdataset.AnnotationDataManager import AnnotationDataManager
 
from smutils.utils_os import search_file, create_directory
from smutils.utils_data import save_pkl_data
 
 
def make_dummy_list(anno, num):
    """
    어노테이션 데이터를 복제해서 더미데이터 리스트를 생성하는 기능
    args:
        anno (dict): 복재하기 위한 어노테이션 데이터
        num (int): 복제 수량
    return (list[dict]): 더미데이터 리스트
    """
 
    #복사
    tmp_anno = copy.deepcopy(anno)
 
    #복사한 데이터의 키포인트 스코어를 0으로 셋팅함
    for i in range(len(tmp_anno['keypoints'])):
        tmp_anno['keypoints'][i][-1] = 0
 
    tmp_anno['action_id']['action'] = -1 #더미데이터의 행동 설정
    tmp_anno['valid'] = 0 #유효성 셋팅
 
    dummy_list = []
    for i in range(num):
        dummy_list.append(copy.deepcopy(tmp_anno))
    return dummy_list
 
def check_invaild(anno_list, ratio):
    """
    데이터의 유효성 확인 기능
    args:
        anno_list (list[dict]): 확인하려는 데이터
            valid : 유효성 파라미터, 1 or 0, 1이면 유효한 데이터, 0이면 유효하지 않는 데이터
        ratio (float): 유효하지 않는 데이터 비율, 해당 비율보다 작으면 유효성 확인을 통과하지 못함
    return (bool): 유효성 확인 결과, 유효성 확인을 통과하지 못하면 True, 통과하면 False
    """
    sum_valid = 0
    for anno in anno_list:
        sum_valid += anno['valid']
 
    return sum_valid < len(anno_list)*ratio
 
def calc_label(anno_list, ratio=0.3, valid_ratio=0.5):
    """
    데이터의 클래스를 결정하는 기능
    args:
        anno_list (list[dict]): 데이터
            필수 데이터 : action_id에 action 키가 존재 해야함, 해당 키에 해당 프레임에서의 클래스 정보가 입력되어 있어야함            
        ratio (float): 라벨 결정을 위한 데이터의 시작 위치(%), 클래스를 결정하는데 사용하는 전체 범위는 데이터 중앙의 (1-2*ratio) *100 %가 됨
        valid_ratio (float): 유효하지 않는 데이터 비율, 해당 비율보다 작으면 유효성 확인을 통과하지 못함, 클래스 결정을 위한 구간에서 유효성 검사
    return (int): 데이터의 클래스, 유효성 검사나 클래스 확인이 어려운 경우 None을 반환함
    """
    l = len(anno_list) #데이터 전체 길이
    start_idx = int(l*ratio) #클래스를 결정할 구간의 시작 위치
    end_idx = l-start_idx #클래스를 결정할 구간의 끝 위치
 
    #설정구간에 대한 클래스 리스트를 생성함, 빈도수 확인을 위함
    label_list = []
    for i in range(start_idx, end_idx):
        anno = anno_list[i]
        
        #유효성 확인, 0보다 작으면 해당 정보는 사용하지 않는다는 의미임
        if anno['action_id']['action'] < 0:
            continue
 
        #유효성 확인, valid가 0이면 복사한 데이터라는 의미임
        if anno['valid'] == 0:
            continue
        
        label_list.append(anno['action_id']['action'])
 
    #유효성 확인
    if len(label_list) < (end_idx - start_idx)*valid_ratio:
        return None
    
    #빈도수 확인
    values, counts = np.unique(np.array(label_list), return_counts=True)
    max_count = np.max(counts) #최대 빈도수
    labels = values[counts == max_count] #최대 빈도수 클래스
    labels = labels.tolist()
    
    #최대 빈도수에 해당하는 클래스가 2개 이상이면 해당 샘플은 사용하지 않음
    if len(labels) > 1:
        return None
    
    return labels[0]
 
def gen_pkl_data(anno_list, h, w, image_folder):
    """
    학습을 위한 데이터 1개를 생성하는 기능
    데이터의 최근 3개의 프레임으로 클래스를 결정함 
    args:
        anno_list (list[dict]): 데이터
        h (int): 원본 영상의 높이
        w (int): 원본 영상의 너비
        image_folder (str): 영상 폴더
    return (dict): 학습데이터
        keypoint (np.array): 스켈레톤 좌표
        keypoint_score (np.array): 스켈레톤 스코어
        frame_dir (str): 영상 폴더
        img_shape (tuple): 원본 영상의 크기
        original_shape (tuple): 원본 영상의 크기
        total_frames (int): 데이터의 프레임 수
        label (int): 샘플의 클래스 번호
    """
 
    #가장 마지막 데이터 확인, 가장 최근 데이터가 
    label = anno_list[-1]['action_id']['action']
 
    #가장 마지막 데이터 유효성 확인
    if label == -1:
        return None
    
    #마지막(최근) 3개 프레임이 동일한지 체크
    len_data = len(anno_list)
    for i in range(1, 3):
        if anno_list[len_data-i-1]['action_id']['action'] != label:
            return None
 
    #유효성 검사
    if check_invaild(anno_list, 0.5):
        return None
 
    #데이터 생성
    pkl_data = dict()    
    
    kps = []
    for anno in anno_list:
        kps.append(anno['keypoints'])
    
    kps = np.array([kps])    
    pkl_data['keypoint'] = kps[..., :2]
    pkl_data['keypoint_score'] = kps[..., 2]
    pkl_data['frame_dir'] = image_folder
    pkl_data['img_shape'] = (h, w)
    pkl_data['original_shape'] = (h, w)
    pkl_data['total_frames'] = kps.shape[1]
    pkl_data['label'] = anno_list[-1]['action_id']['action']
    
    return pkl_data
 
def gen_pkl_data_ver2(anno_list, h, w, image_folder):
    """
    학습을 위한 데이터 1개를 생성하는 기능
    데이터의 중심 40% 구간에서 클래스를 결정함 
    args:
        anno_list (list[dict]): 데이터
        h (int): 원본 영상의 높이
        w (int): 원본 영상의 너비
        image_folder (str): 영상 폴더
    return (dict): 학습데이터
        keypoint (np.array): 스켈레톤 좌표
        keypoint_score (np.array): 스켈레톤 스코어
        frame_dir (str): 영상 폴더
        img_shape (tuple): 원본 영상의 크기
        original_shape (tuple): 원본 영상의 크기
        total_frames (int): 데이터의 프레임 수
        label (int): 샘플의 클래스 번호
    """
 
    #유효성 체크
    if check_invaild(anno_list, 0.5):
        return None
    
    #클래스 결정, 데이터의 중심 구간에서 클래스를 결정함
    label = calc_label(anno_list, 0.3)
    
    #결정된 클래스의 유효성 체크
    if label is None:
        return None
    
    #데이터 생성
    pkl_data = dict()
    
    kps = []
    for anno in anno_list:
        kps.append(anno['keypoints'])
    
    kps = np.array([kps])    
    pkl_data['keypoint'] = kps[..., :2]
    pkl_data['keypoint_score'] = kps[..., 2]
    pkl_data['frame_dir'] = image_folder
    pkl_data['img_shape'] = (h, w)
    pkl_data['original_shape'] = (h, w)
    pkl_data['total_frames'] = kps.shape[1]
    pkl_data['label'] = label
    
    return pkl_data
 
def gen_pkl_data_ver3(anno_list, h, w, image_folder):
    """
    학습을 위한 데이터 1개를 생성하는 기능
    행동 클래스와, 포즈 클래스를 설정함
    행동 클래스는 데이터의 중심 40% 구간에서 클래스를 결정함 
    포즈 클래스는 데이터의 마지막 프레임으로 결정함
    args:
        anno_list (list[dict]): 데이터
        h (int): 원본 영상의 높이
        w (int): 원본 영상의 너비
        image_folder (str): 영상 폴더
    return (dict): 학습데이터
        keypoint (np.array): 스켈레톤 좌표
        keypoint_score (np.array): 스켈레톤 스코어
        frame_dir (str): 영상 폴더
        img_shape (tuple): 원본 영상의 크기
        original_shape (tuple): 원본 영상의 크기
        total_frames (int): 데이터의 프레임 수
        label_action (int): 샘플의 행동 클래스 번호
        label_pose (int): 샘플의 포즈 클래스 번호
    """
 
    #유효성 체크
    if check_invaild(anno_list, 0.5):
        return None
 
    #마지막(최근) 3프레임에 대한 유효성 체크
    len_data = len(anno_list)
    for i in range(0, 3):
        if anno_list[len_data-i-1]['valid'] == 0:
            return None
 
    #행동 라벨 결정
    action_label = calc_label(anno_list, 0.3)
 
    #행동 라벨 유효성 체크
    if action_label is None:
        return None
 
    #포즈 라벨 결정
    pose_label = anno_list[-1]['action_id']['pose']
 
    #데이터 생성
    pkl_data = dict()
    
    kps = []
    for anno in anno_list:
        kps.append(anno['keypoints'])
    
    kps = np.array([kps])    
    pkl_data['keypoint'] = kps[..., :2]
    pkl_data['keypoint_score'] = kps[..., 2]
    pkl_data['frame_dir'] = image_folder
    pkl_data['img_shape'] = (h, w)
    pkl_data['original_shape'] = (h, w)
    pkl_data['total_frames'] = kps.shape[1]
    pkl_data['label_action'] = action_label
    pkl_data['label_pose'] = pose_label
    
    return pkl_data   
 
def gen_pkl_data_dual(anno_list, h, w, image_folder, data_manager):
 
    label = anno_list[-1]['action_id']['action']
    if label == -1:
        return None
        
    len_data = len(anno_list)
    for i in range(1, 3):
        if anno_list[len_data-i-1]['action_id']['action'] != label:
            return None
 
    if check_invaild(anno_list, 0.5):
        return None
 
    pkl_data = dict()    
    
    kps = []
    for anno in anno_list:
        kps.append(anno['keypoints'])
 
    bboxes = []
    for anno in anno_list:
        bboxes.append(anno['bbox'])
 
    filename_list = []
    for anno in anno_list:
        file_name = data_manager.get_image_name(anno['image_id'])
        filename_list.append(file_name)
    
    kps = np.array([kps])
    bboxes = np.array([bboxes])
    pkl_data['keypoint'] = kps[..., :2]
    pkl_data['keypoint_score'] = kps[..., 2]
    pkl_data['frame_dir'] = image_folder
    pkl_data['img_shape'] = (h, w)
    pkl_data['original_shape'] = (h, w)
    pkl_data['total_frames'] = kps.shape[1]
    pkl_data['label'] = anno_list[-1]['action_id']['action']
    pkl_data['start_index']=0
    pkl_data['modality']='RGB'
    pkl_data['keypoint_img_shape'] = (h, w)
    pkl_data['filename_tmpl'] = filename_list
    pkl_data['bbox'] = bboxes
    
    return pkl_data
 
def make_action_pkl_file(data_manager, k, mode=None):
    """
    하나의 클립에서 학습 데이터를 생성하는 기능
    args:
        data_manager: AnnotationDataManager 객체, 어노테이션 데이터파일로 초기화까지 진행
        k (int): 하나의 데이터를 만드는데 사용하는 프레임 숫자
        mode (str): 단일 라벨 데이터인지 다중 라벨 데이터인지 설정하는 파라미터
            'sc' : 단일 라벨 데이터
            'mc' : 다중 라벨 데이터
    return (dict): 하나의 클립에 대한 학습 데이터 리스트, 학습 데이터는 추적 아이디별로 저장됨, 추적 아이디의 학습 데이터는 list[dict]의 구조임
    """
 
    pkl_datas = {}
    
    # h, w = data_manager.read_image().shape[:2]
    h = 1080
    w = 1920
    image_folder = data_manager.get_image_folder()    
    
    #시작 프레임, 종료 프레임 설정
    frames = data_manager.get_number_of_image()
    start_frame = 0
    end_frame = frames
    
    #추적 아이디를 기준으로 데이터 형태 변환
    track_data = data_manager.get_track_anno_data(filter=True, start_frame=start_frame, end_frame=end_frame)
 
    #데이터 생성, 추적 아이디마다 생성함
    for track_id, anno_list in track_data.items():
        
        frame_no = len(anno_list)
 
        image_idx_1st = data_manager.image_ids.index(anno_list[0]['image_id']) #시작 프레임
        image_idx_end = data_manager.image_ids.index(anno_list[-1]['image_id']) #끝 프레임
        interval = image_idx_end - image_idx_1st #데이터 길이
 
        #유효성 체크, 데이터의 길이가 설정한 학습데이터의 길이보다 작을 경우 사용하지 않음
        if interval < k:
            continue
        
        #라벨 변환
        if mode == 'sc':
            simple_anno_list = cvt_labelmap_v21(anno_list, cvt_labelmap_v21_action_to_simple_ver, cvt_labelmap_v21_pose_to_simple_ver)
        elif mode == 'mc':
            simple_anno_list = cvt_labelmap_v21_pose_and_action(anno_list, cvt_labelmap_v21_action_to_simple_ver2, cvt_labelmap_v21_pose_to_simple_ver2)
        
        #유효성 셋팅
        for i in range(0, frame_no):
            simple_anno_list[i]['valid'] = 1
 
        #추적 아이디의 데이터를 저장할 리스트 생성
        pkl_datas[track_id] = []
 
        #pkl data 생성
        anno_q = [simple_anno_list[0]]
        for i in range(1, frame_no):
            #인접한 데이터의 프레임 확인
            image_idx_end = data_manager.image_ids.index(simple_anno_list[i]['image_id'])
            image_idx_end_m1 = data_manager.image_ids.index(anno_q[-1]['image_id'])
 
            #인접한 데이터의 프레임 간격에 따라서 데이터 처리
            interval = image_idx_end - image_idx_end_m1
            if interval > k: #k보다 클경우 다른 클립으로 분리함
                anno_q = []
            elif interval > 1: #k보다 작고 1보다 클경우 더미 데이터를 넣어줌
                anno_q.extend(make_dummy_list(anno_q[-1], interval-1))
 
            #큐에 데이터 붙여줌
            anno_q.append(simple_anno_list[i])
            
            #큐의 데이터가 k개 이상인 경우만 학습 데이터 생성 프로세스를 진행함
            frame_num = len(anno_q)
            if frame_num < k: 
                continue
 
            #모드에 따라 학습 데이터 생성
            if mode == 'sc':
                pkl_data = gen_pkl_data_ver2(anno_q[frame_num-k:], h, w, image_folder)
            elif mode == 'mc':
                pkl_data = gen_pkl_data_ver3(anno_q[frame_num-k:], h, w, image_folder)
            #pkl_data = gen_pkl_data(simple_anno_list[i-(k-1):i+1], h, w, image_folder)
 
            #데이터가 생성되지 않았을 경우
            if pkl_data is None:
                continue
            
            #추적 아이디의 키에 피클 데이터 저장
            pkl_datas[track_id].append(pkl_data)
        
        #추적 아이디의 학습 데이터가 생성되지 않을 경우 키 제거
        if len(pkl_datas[track_id]) == 0:
            del pkl_datas[track_id]
 
    return pkl_datas
 
def make_action_pkl_file_dual(data_manager, k):
    # k : 하나의 데이터를 만드는데 드는 프레임 숫자
    pkl_datas = []
    
    h, w = data_manager.read_image().shape[:2]
    image_folder = data_manager.get_image_folder()    
    
    frames = data_manager.get_number_of_image()
    
    track_data = data_manager.get_track_anno_data(filter=True, start_frame=start_frame, end_frame=end_frame)
    for track_id, anno_list in track_data.items():
        frame_no = len(anno_list)
 
        image_idx_1st = data_manager.image_ids.index(anno_list[0]['image_id'])
        image_idx_end = data_manager.image_ids.index(anno_list[-1]['image_id'])
        interval = image_idx_end - image_idx_1st
        if interval < k:
            continue
        
        simple_anno_list = cvt_labelmap_v21(anno_list, cvt_labelmap_v21_action_to_simple_ver, cvt_labelmap_v21_pose_to_simple_ver)
        
        for i in range(0, frame_no):
            simple_anno_list[i]['valid'] = 1
 
        anno_q = [simple_anno_list[0]]
 
        #file_list = os.listdir(image_folder)
        #file_list = sorted(file_list)
 
        for i in range(1, frame_no):
            image_idx_end = data_manager.image_ids.index(simple_anno_list[i]['image_id'])
            image_idx_end_m1 = data_manager.image_ids.index(anno_q[-1]['image_id'])
 
            interval = image_idx_end - image_idx_end_m1
            if interval > 30:
                anno_q = []
            elif interval > 1:
                anno_q.extend(make_dummy_list(anno_q[-1], interval-1))
            anno_q.append(simple_anno_list[i])
            
            frame_num = len(anno_q)
            if frame_num < k:
                continue
 
            pkl_data = gen_pkl_data_dual(anno_q[frame_num-k:], h, w, image_folder, data_manager)
            #pkl_data = gen_pkl_data(simple_anno_list[i-(k-1):i+1], h, w, image_folder)
            if pkl_data is None:
                continue
 
            pkl_datas.append(pkl_data)
            
    return pkl_datas
 
def split_from_action(data_list):
    """
    학습 데이터를 행동 클래스에 따라서 분리하는 기능
    args:
        data_list (list[dict]): 학습 데이터 리스트, 데이터에는 label or label_action 키에 대한 값이 존재해야함
    return (list[dict]) : 행동 클래스를 기준으로 분리된 학습 데이터
    """
    split_data = {}
    for data in data_list:
        if 'label' in data:
            label = data['label']
        else:
            label = data['label_action']
 
        if label not in split_data:
            split_data[label] = []
        split_data[label].append(data)
    return split_data
 
def split_from_pose(data_list):
    """
    학습 데이터를 포즈 클래스에 따라서 분리하는 기능
    args:
        data_list (list[dict]): 학습 데이터 리스트, 데이터에는 label_pose 키에 대한 값이 존재해야함
    return (list[dict]) : 포즈 클래스를 기준으로 분리된 학습 데이터
    """
    split_data = {}
    for data in data_list:
        label = data['label_pose']
            
        if label not in split_data:
            split_data[label] = []
        split_data[label].append(data)
    return split_data
 
 
def run_generate_pkl_data_from_json(args):
    """
    클립 정보를 담고있는 어노테이션 파일들을 사용해서 학습데이터를 만드는 기능
    args:
        pkl_root (str): 학습데이터를 저장할 폴더
        dataset_folder (str): 클립 정보를 담고있는 어노테이션 파일들이 저장된 폴더
        k (int): 학습데이터를 생성하는 프레임 수
        mode (str): 단일 라벨 데이터인지 다중 라벨 데이터인지 설정하는 파라미터
            'sc' : 단일 라벨 데이터
            'mc' : 다중 라벨 데이터
    """
    data_manager = AnnotationDataManager()
 
    create_directory(args.pkl_root)
 
    json_name_list, json_path_list = search_file(args.dataset_folder, '.json')
    file_num = len(json_name_list)
    
    for i, (json_path, json_name) in enumerate(zip(json_path_list, json_name_list)):
        data_manager.load_annotation(json_path)
        data_manager.init_annotation()
 
        pkl_datas = make_action_pkl_file(data_manager, args.k, args.mode)
        #pkl_datas = make_action_pkl_file_dual(data_manager, args.k)
 
        for track_id, datas in pkl_datas.items():
            split_data = split_from_action(datas)
 
            for action_label, data in split_data.items():
                pkl_name = json_name.replace('json', 'pkl') #name 변경
                name, ext = pkl_name.split('.') #name 분리 name = P001C021A0302R001, ext = pkl
                if args.mode == 'mc':
                    s_data = split_from_pose(data)
                    for pose_label, d in s_data.items():
                        new_pkl_name = f'{name}_{track_id:02d}_{action_label:03d}_{pose_label:03d}.{ext}' #pkl_name 재설정
                        save_pkl_path = os.path.join(args.pkl_root, new_pkl_name) # 저장경로 설정
                        save_pkl_data(d, save_pkl_path) #저장
                        
                        #저장 데이터 출력
                        print(f"[mc][ {i+1} / {file_num} ] {save_pkl_path} : {len(d)}")
 
                elif args.mode == 'sc':
                    new_pkl_name = f'{name}_{track_id:02d}_{action_label:03d}.{ext}' #pkl_name 재설정
                    save_pkl_path = os.path.join(args.pkl_root, new_pkl_name) # 저장경로 설정
                    save_pkl_data(data, save_pkl_path) #저장
 
                    #저장 데이터 출력
                    print(f"[sc][ {i+1} / {file_num} ] {save_pkl_path} : {len(datas)}")
                else:
                    print('error')
                    
        
def merge_pkl(folder, file_path_list=None ):
    """
    학습데이터 파일들을 하나로 합치는 기능
    args:
        folder (str): 학습데이터가 저장된 폴더
        file_path_list (list[str]) : 학습데이터 경로 리스트, 설정하지 않으면 folder에서 찾음
    return (list[dict]): 합쳐진 학습 데이터
    """
    if file_path_list == None:
        file_name_list, file_path_list = search_file(folder, fileEx='.pkl')
 
    merged_pkl_datas = []
    for path in file_path_list:
        with open(path, 'rb') as f:
            pkl_data = pickle.load(f)
            merged_pkl_datas += pkl_data
            print(f"{path} : {len(pkl_data)}")
            
    return merged_pkl_datas
 
def run_merge_pkl(args):
    """
    학습데이터 파일들을 하나로 합치고 저장하는 기능
    args:
        pkl_root (str): 학습데이터가 저장된 폴더
        merge_pkl_path (str): 합쳐진 데이터를 하나의 파일로 저장하는 경로
    """
    merged_pkl_datas = merge_pkl(args.pkl_root)
    print(f"total {args.merge_pkl_path} : {len(merged_pkl_datas)}")
    save_pkl_data(merged_pkl_datas, args.merge_pkl_path)
 
 
def check_label_v22(anno_list, category, target_label, ratio=0.3):
    """
    데이터에 특정 카테고리의 특정 클래스가 존재하는지 확인하는 기능
    args:
        anno_list (list[dict]): 데이터
            필수 데이터 : action_id에 라벨 이름(category)에 대한 키가 존재 해야함, 해당 키에 해당 프레임에서의 클래스 정보가 입력되어 있어야함         
        category (str): 데이터에서 확인하려는 카테고리
        target_label (int): 데이터에서 확인하려는 클래스
        ratio (float): 라벨 확인을 위한 데이터의 시작 위치(%), 클래스를 확인하는데 사용하는 전체 범위는 데이터 중앙의 (1-2*ratio) *100 %가 됨
        
    return (bool): 원하는 클래스 존재 유무
    """
    
    #확인 구간 설정
    l = len(anno_list)
    start_idx = int(l*ratio)
    end_idx = l-start_idx
 
    #확인 구간의 클래스 라벨 리스트 생성, 빈도수를 확인하고 
    label_list = []
    for i in range(start_idx, end_idx):
        anno = anno_list[i]
        
        #유효성 체크, 0 이하로 클래스가 저장되어 있으면 해당 프레임은 사용하지 않는 다는 의미임
        if anno['action_id'][category] < 0:
            continue
 
        #유효성 체크, valid가 0이면 더미데이터를 의미함
        if anno['valid'] == 0:
            continue
        
        label_list.append(anno['action_id'][category])
 
    return target_label in label_list
    
    #빈도수 기반으로 라벨 체크
    # values, counts = np.unique(np.array(label_list), return_counts=True)
    # if target_label not in list(values):
    #     return False
    # return True
    
def gen_pkl_data_v22(anno_list, category, target_label, h, w, image_folder):
    """
    학습을 위한 데이터 1개를 생성하는 기능
    특정 카테고리의 특정 클래스에 해당하는 데이터를 생성함
    데이터의 중심 40% 구간을 확인해서 클래스를 설정함 
    args:
        anno_list (list[dict]): 데이터
        category (str): 데이터에서 확인하려는 카테고리
        target_label (int): 데이터에서 확인하려는 클래스
        h (int): 원본 영상의 높이
        w (int): 원본 영상의 너비
        image_folder (str): 영상 폴더
    return (dict): 학습데이터
        keypoint (np.array): 스켈레톤 좌표
        keypoint_score (np.array): 스켈레톤 스코어
        frame_dir (str): 영상 폴더
        img_shape (tuple): 원본 영상의 크기
        original_shape (tuple): 원본 영상의 크기
        total_frames (int): 데이터의 프레임 수
        category (str): 샘플의 카테고리
        label (int): 샘플의 클래스 번호
    """
 
    #유효성 체크
    if check_invaild(anno_list, 0.5):
        return None
 
    #카테고리의 클래스 체크, 클래스가 중심 40% 구간에 존재하지 않으면 학습 데이터를 생성하지 않음
    if check_label_v22(anno_list, category, target_label, 0.3):
        label = target_label
    else:
        return None
    
    #데이터 생성
    pkl_data = dict()
    
    kps = []
    for anno in anno_list:
        kps.append(anno['keypoints'])
    
    kps = np.array([kps])    
    pkl_data['keypoint'] = kps[..., :2]
    pkl_data['keypoint_score'] = kps[..., 2]
    pkl_data['frame_dir'] = image_folder
    pkl_data['img_shape'] = (h, w)
    pkl_data['original_shape'] = (h, w)
    pkl_data['total_frames'] = kps.shape[1]
    pkl_data['category'] = category
    pkl_data['label'] = label
 
    return pkl_data   
 
def make_action_pkl_file_v22(data_manager, category, target_label, k):
    """
    하나의 클립에서 학습 데이터를 생성하는 기능
    카테고리의 특정 클래스에 대한 데이터를 생성함
    args:
        data_manager: AnnotationDataManager 객체, 어노테이션 데이터파일로 초기화까지 진행
        category (str): 데이터에서 확인하려는 카테고리
        target_label (int): 데이터에서 확인하려는 클래스
        k (int): 하나의 데이터를 만드는데 사용하는 프레임 숫자
    return (dict): 하나의 클립에 대한 학습 데이터 리스트, 학습 데이터는 추적 아이디별로 저장됨, 추적 아이디의 학습 데이터는 list[dict]의 구조임
    """
    
    #이미지 크기 및 폴더 셋팅
    # h, w = data_manager.read_image().shape[:2]
    h = 1080
    w = 1920
    image_folder = data_manager.get_image_folder()
    
    #클립의 시작, 끝 프레임 설정
    start_frame = data_manager.dataset['info']['start']
    end_frame = data_manager.dataset['info']['end']
 
    #추적 아이디를 기준으로 데이터 형태 변환
    track_data = data_manager.get_track_anno_data(filter=True, start_frame=start_frame, end_frame=end_frame)
 
    #학습 데이터 생성, 추적 아이디별로 생성함
    pkl_datas = {}
    for track_id, anno_list in track_data.items():
        
        frame_no = len(anno_list)
 
        image_idx_1st = data_manager.image_ids.index(anno_list[0]['image_id']) #시작 프레임
        image_idx_end = data_manager.image_ids.index(anno_list[-1]['image_id']) #끝 프레임
 
        #유효성 체크, 데이터의 길이가 설정한 학습데이터의 길이보다 작을 경우 사용하지 않음
        interval = image_idx_end - image_idx_1st
        if interval < k:
            continue
        
        #학습 클래스 변환, 라벨링된 데이터를 학습을 위한 데이터로 변환 
        simple_anno_list = cvt_labelmap_v22(anno_list)
 
        #유효성 셋팅
        for i in range(0, frame_no):
            simple_anno_list[i]['valid'] = 1
 
        #추적 아이디의 데이터를 저장할 리스트 생성
        pkl_datas[track_id] = []
 
        #pkl data 생성
        anno_q = [simple_anno_list[0]]
        for i in range(1, frame_no):
 
            #인접한 데이터의 프레임 확인
            image_idx_end = data_manager.image_ids.index(simple_anno_list[i]['image_id'])
            image_idx_end_m1 = data_manager.image_ids.index(anno_q[-1]['image_id'])
 
            #인접한 데이터의 프레임 간격에 따라서 데이터 처리
            interval = image_idx_end - image_idx_end_m1
            if interval > k: #k보다 클경우 다른 클립으로 분리함
                anno_q = []
            elif interval > 1: #k보다 작고 1보다 클경우 더미 데이터를 넣어줌
                anno_q.extend(make_dummy_list(anno_q[-1], interval-1))
 
            #큐에 데이터를 붙여줌
            anno_q.append(simple_anno_list[i])
 
            #큐의 데이터가 k개 이상인 경우만 학습 데이터 생성 프로세스를 진행함
            frame_num = len(anno_q)
            if frame_num < k:
                continue
            
            #학습 데이터 생성
            pkl_data = gen_pkl_data_v22(anno_q[frame_num-k:], category, target_label, h, w, image_folder)
 
            #학습 데이터가 생성되지 않았을 경우
            if pkl_data is None:
                continue
            
            #추적 아이디의 키에 피클 데이터 저장
            pkl_datas[track_id].append(pkl_data)
        
        #추적 아이디의 학습 데이터가 없을 경우 키 제거
        if len(pkl_datas[track_id]) == 0:
            del pkl_datas[track_id]
 
    return pkl_datas
 
 
def run_generate_pkl_data_from_json_v22(args):
    """
    클립 정보를 담고있는 어노테이션 파일들을 사용해서 학습데이터를 만드는 기능
    args:
        category_k (dict): 카테고리별 학습데이터를 생성하는 프레임 수
        data_root (str): 클립 정보를 담고있는 어노테이션 파일들이 저장된 폴더
        pkl_root (str): 학습데이터를 저장할 폴더
    """
 
    #어노테이션 관리자 설정
    data_manager = AnnotationDataManager()
 
    #학습데이터 생성을 위한 카테고리별 프레임 수
    category_k = args.category_k
 
    data_root = args.data_root #클립 저장 폴더
    for category, k in category_k.items():
        #클립 리스트
        dataset_folder = os.path.join(data_root, category)
        json_name_list, json_path_list = search_file(dataset_folder, '.json')
 
        #카테고리 별 저장 폴더 생성
        save_folder = os.path.join(args.pkl_root, category)
        for i, (json_path, json_name) in enumerate(zip(json_path_list, json_name_list)):
            target_label = json_path.split('/')[-2]
            cat_label = os.path.join(save_folder, target_label)
            create_directory(cat_label)
 
        file_num = len(json_name_list) #클립 수량, 콘솔 출력용
        total_data = 0 #학습 데이터 수량, 콘솔 출력용
        for i, (json_path, json_name) in enumerate(zip(json_path_list, json_name_list)):
            # print(f"{category} -> [ {i+1} / {file_num} ] {json_name}")
 
            #어노테이션 로드
            data_manager.load_annotation(json_path)
            data_manager.init_annotation()
 
            #타겟 라벨 -> 어노테이션 하나에 하나의 클래스에 대해서만 학습데이터를 생성함
            target_label = int(json_path.split('/')[-2])
 
            #학습 데이터 생성
            pkl_datas = make_action_pkl_file_v22(data_manager, category, target_label, k)
            
            #학습 데이터 저장
            for track_id, datas in pkl_datas.items():
                pkl_name = json_name.replace('json', 'pkl')
                save_pkl_path = os.path.join(save_folder, f'{target_label:02d}', pkl_name)
                save_pkl_data(datas, save_pkl_path)
                total_data += len(datas)
                print(f"{category} -> [ {i+1} / {file_num} ] {save_pkl_path} : {len(datas):5d}/{total_data:}")