utils_data Namespace Reference

Functions
	check_json_format (path_format, json_file_name)
	check_json_version (json_file_name)
	join (path_list)
	make_dataset_folder_path (json_file_name, ret_img_folder=False, json_version=None)
	make_image_base_path (json_version, anno_path)
	make_image_folder (json_version, anno_path)
	load_annotation (anno_path)
	save_json (path, dataset)
	load_json (path)
	check_and_init_dataset (dataset, check_list, default_value)
	check_and_init_dictionary (dictionary, check_list, default_value)
	make_dummy_annotation (anno_id, image_id, track_id=0)
	load_scenario (json_version, scenario_num)
	load_label_map (label_map_ver, label_key)
	search_json_by_path_format (folder, data_root=None)
	load_pkl_data (pkl_path)
	save_pkl_data (pkl_data, save_path)
	dataset_class_filtering (pkl_datas, active_class)
	print_data_num_per_class (data_list, labelmap)
	split_train_and_val (datas, class_num, max_train_data_num, max_val_data_num)
	remove_items (original_list, remove_items)
	make_pkl_info (pkl_name_list, pkl_path_list, key='label')
	split_train_and_val_v22 (data_folder, save_folder, category_info, total_data_num=100, ratio=0.8)
	load_labelmap (path)

Function Documentation

check_and_init_dataset()

utils_data.check_and_init_dataset	(		dataset,
			check_list,
			default_value )

어노테이션 데이터를 확인해서 필요한 정보를 초기화 하는 기능
args:
    dataset (dict): 어노테이션 데이터
    check_list (list[str]): 확인하는 정보, 어노테이션 데이터에 해당 키가 없으면 default_value로 초기화 시켜줌
    default_value : 초기화 값
return (dict): 어노테이션 데이터

Definition at line 201 of file utils_data.py.

def check_and_init_dataset(dataset, check_list, default_value):
    """
    어노테이션 데이터를 확인해서 필요한 정보를 초기화 하는 기능
    args:
        dataset (dict): 어노테이션 데이터
        check_list (list[str]): 확인하는 정보, 어노테이션 데이터에 해당 키가 없으면 default_value로 초기화 시켜줌
        default_value : 초기화 값
    return (dict): 어노테이션 데이터
    """
    for idx, anno in enumerate(dataset['annotations']):
        for check_key, init_val in zip(check_list, default_value):
            if not (check_key in anno):
                dataset['annotations'][idx][check_key] = init_val
    return dataset
 

check_and_init_dictionary()

utils_data.check_and_init_dictionary	(		dictionary,
			check_list,
			default_value )

데이터를 확인해서 필요한 정보를 초기화 하는 기능
args:
    dictionary (dict): 데이터
    check_list (list[str]): 확인하는 정보, 데이터에 해당 키가 없으면 default_value로 초기화 시켜줌
    default_value : 초기화 값
return (dict): 데이터

Definition at line 216 of file utils_data.py.

def check_and_init_dictionary(dictionary, check_list, default_value): 
    """
    데이터를 확인해서 필요한 정보를 초기화 하는 기능
    args:
        dictionary (dict): 데이터
        check_list (list[str]): 확인하는 정보, 데이터에 해당 키가 없으면 default_value로 초기화 시켜줌
        default_value : 초기화 값
    return (dict): 데이터
    """   
    for key, val in zip(check_list, default_value):
        if not key in dictionary:
            dictionary[key] = val
    return dictionary
 

check_json_format()

utils_data.check_json_format	(		path_format,
			json_file_name )

json 파일 이름이 해당 포맷에 부합하는지 확인하는 기능
args:
    path_format : 확인하려는 포맷
    json_file_name : 확인하려는 파일 이름
return (bool): 부합여부

Definition at line 11 of file utils_data.py.

def check_json_format(path_format, json_file_name):
    """
    json 파일 이름이 해당 포맷에 부합하는지 확인하는 기능
    args:
        path_format : 확인하려는 포맷
        json_file_name : 확인하려는 파일 이름
    return (bool): 부합여부
    """
    try :
        for pf in path_format:
            filename_re = re.compile(pf)
            str_format = filename_re.search(json_file_name).group()
    except:
        return False
    
    return True
 

check_json_version()

utils_data.check_json_version

(

json_file_name

)

json_file_name 이름으로 버전을 확인하는 기능
return (int): json 파일의 버전

Definition at line 28 of file utils_data.py.

def check_json_version(json_file_name):
    """
    json_file_name 이름으로 버전을 확인하는 기능
    return (int): json 파일의 버전
    """
    for key, path_format in PATH_FORMAT.items():
        if check_json_format(path_format, json_file_name):
            return key        
    return None
 

dataset_class_filtering()

utils_data.dataset_class_filtering	(		pkl_datas,
			active_class )

특정 클래스의 데이터만 남기고 제거하는 기능
args:
    pkl_datas (list[dict] or str): 입력 데이터 리스트 또는 데이터의 경로, 데이터에는 'label' 항목이 포함되어 있어야함
    active_class (list) : 남기고 싶은 데이터
return (list[dict]): 필터링된 데이터

Definition at line 32 of file utils_data.py.

def dataset_class_filtering(pkl_datas, active_class):
    """
    특정 클래스의 데이터만 남기고 제거하는 기능
    args:
        pkl_datas (list[dict] or str): 입력 데이터 리스트 또는 데이터의 경로, 데이터에는 'label' 항목이 포함되어 있어야함
        active_class (list) : 남기고 싶은 데이터
    return (list[dict]): 필터링된 데이터
    """
 
    if isinstance(pkl_datas, str): #pkl_datas가 문자열이면 데이터 로드
        with open(pkl_datas, 'rb') as f:
            pkl_datas = pickle.load(f)
 
    #데이터 필터링
    filtered_datas = []
    for data in pkl_datas:
        if data['label'] in active_class: #남길 데이터인지 확인
            filtered_datas.append(data)
    return filtered_datas
 

join()

utils_data.join

(

path_list

)

os.path.join 기능 커스텀, 플랫폼에 따라 다르게 동작함
args:
    path_list (list): 이어붙이려는 폴더 및 경로 리스트
return (str) : path_list를 결합한 경로

Definition at line 38 of file utils_data.py.

def join(path_list):
    """
    os.path.join 기능 커스텀, 플랫폼에 따라 다르게 동작함
    args:
        path_list (list): 이어붙이려는 폴더 및 경로 리스트
    return (str) : path_list를 결합한 경로
    """
    if platform.system().lower() == 'windows':
        return "/".join(path_list)
    else:
        path_list_tmp = [path_list[0]]
        for p in path_list[1:]:
            p_list = p.split('/')
            if '' in p_list:
                p_list.remove('')
            path_list_tmp.extend(p_list)
        return os.path.join(*path_list_tmp)
 

load_annotation()

utils_data.load_annotation

(

anno_path

)

어노테이션 파일을 로드해서 기본 정보를 반환하는 기능
args:
    anno_path (str): json 파일 경로
return:
    json_version (int): json 파일 버전
    label_map_version  (int): 레이블맵 버전
    base_path (str): 데이터가 저장된 기본 경로
    image_base_path (str): 이미지가 저장된 기본 경로
    dataset (dict): 어노테이션 데이터

Definition at line 151 of file utils_data.py.

def load_annotation(anno_path):
    """
    어노테이션 파일을 로드해서 기본 정보를 반환하는 기능
    args:
        anno_path (str): json 파일 경로
    return:
        json_version (int): json 파일 버전
        label_map_version  (int): 레이블맵 버전
        base_path (str): 데이터가 저장된 기본 경로
        image_base_path (str): 이미지가 저장된 기본 경로
        dataset (dict): 어노테이션 데이터
    """
    with open(anno_path, "r") as json_file:
        dataset = json.load(json_file)
 
    json_version = int(float(dataset["info"]["version"])*10)
    label_map_version = int(float(dataset["info"]["label_map_version"])*10)
    base_path, image_base_path = make_image_base_path(json_version, anno_path)
    dataset = check_and_init_dataset(dataset, CHECK_LIST[json_version]["keys"], CHECK_LIST[json_version]["default_value"])
 
    return json_version, label_map_version, base_path, image_base_path, dataset
 

load_json()

utils_data.load_json

(

path

)

어노테이션 데이터를 로드하는 기능
args:
    path (str): 어노테이션 경로
return (dict): 어노테이션 데이터

Definition at line 186 of file utils_data.py.

def load_json(path):
    """
    어노테이션 데이터를 로드하는 기능
    args:
        path (str): 어노테이션 경로
    return (dict): 어노테이션 데이터
    """
    try:
        with open(path, "r") as json_file:
            data = json.load(json_file)
    except Exception  as e:
        data = None
 
    return data
    

load_label_map()

utils_data.load_label_map	(		label_map_ver,
			label_key )

Definition at line 298 of file utils_data.py.

def load_label_map(label_map_ver, label_key):
    file_name = LABEL_FILE_INFO[label_map_ver][label_key]['file_name']
    splitStr = LABEL_FILE_INFO[label_map_ver][label_key]['keys']
    path = os.path.join(LABEL_BASE, file_name)
 
    labels = dict.fromkeys(splitStr)
    with open(path, "r", encoding='UTF-8') as txt_file:
        lines = txt_file.readlines()
 
        key = splitStr[0]
 
        for line in lines:
            line = line.strip()
            if len(line) < 1:
                continue
 
            if line in splitStr:
                key = line
                labels[key] = []
                continue
            
            labels[key].append(line)
 
    return labels, splitStr
 
 

load_labelmap()

utils_data.load_labelmap

(

path

)

레이블 맵을 로드하는 기능
args:
    path (str): 레이블 맵이 저장된 경로, 레이블 맵 파일은 1라인에 클래스 명이 기록되어 있어야함
return (list[str]): 레이블 맵

Definition at line 260 of file utils_data.py.

def load_labelmap(path):
    """
    레이블 맵을 로드하는 기능
    args:
        path (str): 레이블 맵이 저장된 경로, 레이블 맵 파일은 1라인에 클래스 명이 기록되어 있어야함
    return (list[str]): 레이블 맵
    """
    label_map = [x.strip() for x in open(path).readlines()]
    return label_map

load_pkl_data()

utils_data.load_pkl_data

(

pkl_path

)

pkl 데이터를 로드하는 기능
args:
    pkl_path (str): pkl 데이터가 저장된 경로
return: pkl 데이터

Definition at line 11 of file utils_data.py.

def load_pkl_data(pkl_path):
    """
    pkl 데이터를 로드하는 기능
    args:
        pkl_path (str): pkl 데이터가 저장된 경로
    return: pkl 데이터
    """
    with open(pkl_path, 'rb') as f:
        pkl_datas = pickle.load(f)
    return pkl_datas
 

load_scenario()

utils_data.load_scenario	(		json_version,
			scenario_num )

Definition at line 285 of file utils_data.py.

def load_scenario(json_version, scenario_num):
    path = os.path.join(SCENARIO_FILE_BASE, SCENARIO_FILE[json_version])
    with open(path, "r", encoding="UTF8") as file:
        lines = file.readlines()
        lines = [line.rstrip() for line in lines]
 
    sceneLine = []
    for i in lines:
        tmp_i = i.split(".")
        if tmp_i[0] == scenario_num:
            sceneLine.append(tmp_i[1])
    return sceneLine
 

make_dataset_folder_path()

utils_data.make_dataset_folder_path	(		json_file_name,
			ret_img_folder = False,
			json_version = None )

json파일 이름으로 json 파일이 저장된 폴더와 이미지 폴더를 만드는 기능
args:
    json_file_name (str): json 파일 이름 
    ret_img_folder (bool): 이미지 폴더 반환 여부
    json_version (bool): json 파일 버전, 설정하지 않으면 json 파일 이름으로 json 파일 버전을 확인함
return (str): json 파일이 저장된 폴더경로, 이미지 경로

Definition at line 56 of file utils_data.py.

def make_dataset_folder_path(json_file_name, ret_img_folder=False, json_version=None):
    """
    json파일 이름으로 json 파일이 저장된 폴더와 이미지 폴더를 만드는 기능
    args:
        json_file_name (str): json 파일 이름 
        ret_img_folder (bool): 이미지 폴더 반환 여부
        json_version (bool): json 파일 버전, 설정하지 않으면 json 파일 이름으로 json 파일 버전을 확인함
    return (str): json 파일이 저장된 폴더경로, 이미지 경로
    """
    if json_version is None:
        json_version = check_json_version(json_file_name)
        
    path_format = PATH_FORMAT[json_version]
    dataset_path_list = []
    for pf in path_format:
        filename_re = re.compile(pf)
        str_format = filename_re.search(json_file_name).group()
        dataset_path_list.append(str_format)
        
    json_path_list = dataset_path_list[:2]
    json_folder = join(json_path_list)
    image_folder = join(dataset_path_list)
    
    
    if ret_img_folder:
        return json_folder, image_folder
    else:
        return json_folder
    

make_dummy_annotation()

utils_data.make_dummy_annotation	(		anno_id,
			image_id,
			track_id = 0 )

더미데이터를 생성하는 기능
args:
    anno_id (int): 어노테이션 아이디
    image_id (int): 이미지 아이디
    track_id (int): 추적 아이디
return (dict): 더미 데이터

Definition at line 230 of file utils_data.py.

def make_dummy_annotation(anno_id, image_id, track_id=0):
    """
    더미데이터를 생성하는 기능
    args:
        anno_id (int): 어노테이션 아이디
        image_id (int): 이미지 아이디
        track_id (int): 추적 아이디
    return (dict): 더미 데이터
    """
    tmp_annotation = {
        "id": anno_id,
        "image_id": image_id,
        "category_id": 1,
        "iscrowd": 0,
        "keypoints": [
            [178.87325418994442, 168.6456005586591, 1.0],
            [197.7807262569836, 135.67562849162016, 1.0],
            [149.12639664804487, 140.08938547486025, 1.0],
            [241.84322625698292, 161.00872905027938, 1.0],
            [121.84322625698292, 161.00872905027938, 1.0],
            [218.3100558659221, 205.59811452513907, 1.0],
            [151.26187150837973, 209.51885474860308, 1.0],
            [274.60125698323964, 257.7213687150835, 1.0],
            [112.21508379888269, 268.0677374301673, 1.0],
            [320.4018854748606, 337.25139664804476, 1.0],
            [87.6002094972066, 346.36592178770945, 1.0],
            [246.41445530726241, 379.5006983240222, 1.0],
            [175.2807262569836, 380.26012569832403, 1.0],
            [283.3463687150843, 503.20949720670353, 1.0],
            [168.83449720670387, 514.8495111731842, 1.0],
            [316.25453910614533, 637.7988826815641, 1.0],
            [157.21508379888246, 641.4738128491614, 1.0],
        ],
        "area": 903482.25,
        "bbox": [32.3882681564246, 17.625698324022324, 391.0, 710.0],
        "ageclass": 0,
        "genderclass": 0,
        "upperclass": 0,
        "uppercolor": [255.0, 255.0, 255.0],
        "lowerclass": 0,
        "lowercolor": [255.0, 255.0, 255.0],
        "hatvisible": 0,
        "hatcolor": [-1.0, -1.0, -1.0],
        "bagvisible": 0,
        "bagcolor": [-1.0, -1.0, -1.0],
        "action_id": {'action': 0, 'pose':0, 'hand':0, 'foot':0},
        "mutual_action": 0,
        "mutual_action_target": [],
        "abnormal_id": 0,
        "dangerzone": [0, 0, 0, 0, 0, 0, 0, 0],
        "track_id": track_id,
        "ismodify": 0,
    }
    return tmp_annotation
 

make_image_base_path()

utils_data.make_image_base_path	(		json_version,
			anno_path )

데이터셋이 저장된 기본 경로를 생성하는 기능
ver 11
    json 파일 저장 경로 : base_path/annotation/P/C/json_name
    이미지 파일 저장 경로 : base_path/images/P/C/A/R/img_name
args:
    json_version (int): json 파일 버전
    anno_path (str): json 파일 경로
return:
    base_path : 데이터(json, 이미지)가 저장된 폴더
    image_base_path : 이미지가 저장된 기본 경로(base_path/images)

Definition at line 85 of file utils_data.py.

def make_image_base_path(json_version, anno_path):
    """
    데이터셋이 저장된 기본 경로를 생성하는 기능
    ver 11
        json 파일 저장 경로 : base_path/annotation/P/C/json_name
        이미지 파일 저장 경로 : base_path/images/P/C/A/R/img_name
    args:
        json_version (int): json 파일 버전
        anno_path (str): json 파일 경로
    return:
        base_path : 데이터(json, 이미지)가 저장된 폴더
        image_base_path : 이미지가 저장된 기본 경로(base_path/images)
    """
    split_dataset = anno_path.split("/")
    json_file_name = split_dataset[-1]
    if json_version == 10:
        base_path_list = split_dataset[:-3]
        image_base_path_list = copy.deepcopy(base_path_list)
    elif json_version == 11:        
        base_path_list = split_dataset[:-4]
        image_base_path_list = copy.deepcopy(base_path_list)
        image_base_path_list.append('images')
 
    path_format = PATH_FORMAT[json_version]
    for pf in path_format:
        filename_re = re.compile(pf)
        str_format = filename_re.search(json_file_name).group()
        image_base_path_list.append(str_format)
    
    if platform.system().lower() == 'windows':
        image_base_path = "/".join(image_base_path_list)
        base_path = "/".join(base_path_list)
    else:
        image_base_path = os.path.join("/", *image_base_path_list)
        base_path = os.path.join("/", *base_path_list)
 
    return base_path, image_base_path
 

make_image_folder()

utils_data.make_image_folder	(		json_version,
			anno_path )

어노테이션 파일에 대응하는 이미지가 저장된 경로를 생성하는 기능
image_base_path 뒤에 붙는 폴더
args:
    json_version (int): json 파일 버전
    anno_path (str): json 파일 경로
return:
    image_folder_path : 이미지가 저장된 폴더

Definition at line 123 of file utils_data.py.

def make_image_folder(json_version, anno_path):
    """
    어노테이션 파일에 대응하는 이미지가 저장된 경로를 생성하는 기능
    image_base_path 뒤에 붙는 폴더
    args:
        json_version (int): json 파일 버전
        anno_path (str): json 파일 경로
    return:
        image_folder_path : 이미지가 저장된 폴더
    """
    split_dataset = anno_path.split("/")
    json_file_name = split_dataset[-1]
 
    image_folder_path_list = []
    path_format = PATH_FORMAT[json_version]
    for pf in path_format:
        filename_re = re.compile(pf)
        str_format = filename_re.search(json_file_name).group()
        image_folder_path_list.append(str_format)
 
    if platform.system().lower() == 'windows':
        image_folder_path = "/".join(image_folder_path_list)
    else:
        image_folder_path = os.path.join(*image_folder_path_list)
 
    return image_folder_path
 
 

make_pkl_info()

utils_data.make_pkl_info	(		pkl_name_list,
			pkl_path_list,
			key = 'label' )

피클 파일의 정보를 생성, 입력한 키의 원소별 파일 수량과 피클 파일에 포함된 키의 원소를 생성하는 기능
args:
    pkl_name_list (list[str]): 피클 데이터 파일의 이름 리스트
    pkl_path_list (list[str]): 피클 데이터 파일 경로 리스트

Definition at line 129 of file utils_data.py.

def make_pkl_info(pkl_name_list, pkl_path_list, key='label'):
    """
    피클 파일의 정보를 생성, 입력한 키의 원소별 파일 수량과 피클 파일에 포함된 키의 원소를 생성하는 기능
    args:
        pkl_name_list (list[str]): 피클 데이터 파일의 이름 리스트
        pkl_path_list (list[str]): 피클 데이터 파일 경로 리스트
    """
    data_info_dict = dict()
    file_info_dict = dict()
    for name, path in zip(pkl_name_list, pkl_path_list):
        pkl_list = load_pkl_data(path) #피클 파일 로드
        file_info_dict[name] = [] #파일에 포함된 키 데이터 초기화
 
        #정보 생성
        for pkl in pkl_list:
            item = pkl[key] #키의 원소
 
            #원소별 파일 초기화
            if item not in data_info_dict:
                data_info_dict[item] = []
            
            #파일에 포함된 원소 추가
            if item not in file_info_dict[name]:
                file_info_dict[name].append(item)
            
            #원소별 파일 추가
            if name not in data_info_dict[item]:
                data_info_dict[item].append(name)
                
    #정렬
    data_info_dict = dict(sorted(data_info_dict.items()))
    return data_info_dict, file_info_dict
 
 
# def select_items(pkl_folder, ratio=0.2):
#     #하나에 클립에 여러개의 라벨이 있을 수 있음
#     #최소한의 클립으로 여러 라벨이 골고루 커버가능하도록 함
#     pkl_name_list, pkl_path_list = search_file(pkl_folder, '.pkl')
#     label_info, file_info = make_pkl_info(pkl_name_list, pkl_path_list)
 
#     # 클립 수로 오름차순으로 정렬
#     sorted_data = copy.deepcopy(dict(sorted(label_info.items(), key=lambda item: len(item[1]))))
#     item_dict = {}
#     select_item_list = []
#     for key in label_info.keys():
#         item_dict[key] = []
    
#     while True:
#         #클립 수가 가장 적은 라벨 선택
#         label = list(sorted_data.keys())[0]
#         clip_list = sorted_data[label]
 
#         #선택할 클립의 수 결정
#         sample_size = max(1, int(len(clip_list)*ratio)) # 선택해야하는 클립 수
#         sample_size = max(0, sample_size - len(item_dict[label])) # 선택해야하는 클립 수에 이미 선택된 클립수를 뺌
        
#         #클립 선택
#         selected_clip = random.sample(clip_list, sample_size)
#         select_item_list.extend(selected_clip)
#         for clip in selected_clip:
#             l_list = file_info[clip]
#             for l in l_list:
#                 item_dict[l].append(clip)
        
#         #선택된 클립 제거
#         for key, value_list in sorted_data.items():
#             sorted_data[key] = [val for val in value_list if val not in selected_clip]
        
#         del sorted_data[label]
        
#         if not sorted_data:
#             break
        
#         # 클립 수로 오름차순으로 정렬
#         sorted_data = dict(sorted(sorted_data.items(), key=lambda item: len(item[1])))
    
#     remain_item_list = remove_items(pkl_name_list, select_item_list)
 
#     return select_item_list, remain_item_list
 
 

print_data_num_per_class()

utils_data.print_data_num_per_class	(		data_list,
			labelmap )

클래스별 데이터 수량을 출력하는 기능
args:
    data_list (list[dict]): 데이터 리스트, 데이터에는 클래스 정보를 담고있는 'label'을 포함하고 있어야함
    labelmap (dict): 클래스 정보를 담고있는 변수, key는 클래스 번호이고 value는 클래스 이름임

Definition at line 52 of file utils_data.py.

def print_data_num_per_class(data_list, labelmap):
    """
    클래스별 데이터 수량을 출력하는 기능
    args:
        data_list (list[dict]): 데이터 리스트, 데이터에는 클래스 정보를 담고있는 'label'을 포함하고 있어야함
        labelmap (dict): 클래스 정보를 담고있는 변수, key는 클래스 번호이고 value는 클래스 이름임
    """
    if isinstance(data_list, str):
        with open(data_list, 'rb') as f:
            data_list = pickle.load(f)
            
    bins_data = dict()
    for i in range(len(labelmap.keys())):
        bins_data[i] = 0
        
    for data in data_list:    
        bins_data[data['label']] += 1
    
    for label, cnt in bins_data.items():
        print(f"{labelmap[label]} : {cnt}")
    
 

remove_items()

utils_data.remove_items	(		original_list,
			remove_items )

리스트에서 특정 원소를 제거하는 기능
args:
    original_list (list): 입력 데이터
    remove_items (list): 제거하려는 원소
return (list): 특정 원소가 제거된 리스트

Definition at line 119 of file utils_data.py.

def remove_items(original_list, remove_items):
    """
    리스트에서 특정 원소를 제거하는 기능
    args:
        original_list (list): 입력 데이터
        remove_items (list): 제거하려는 원소
    return (list): 특정 원소가 제거된 리스트
    """
    return [item for item in original_list if item not in remove_items]
    

save_json()

utils_data.save_json	(		path,
			dataset )

어노테이션 데이터를 저장하는 기능
args:
    path (str): 저장 경로
    dataset (dict): 저장하는 데이터

Definition at line 173 of file utils_data.py.

def save_json(path, dataset):
    """
    어노테이션 데이터를 저장하는 기능
    args:
        path (str): 저장 경로
        dataset (dict): 저장하는 데이터
    """
    try:
        with open(path, "w") as json_file:
            json.dump(dataset, json_file)
    except Exception  as e:
        print(e)
 

save_pkl_data()

utils_data.save_pkl_data	(		pkl_data,
			save_path )

pkl 데이터를 저장하는 기능
args:
    pkl_data : 저장할 데이터
    save_path (str): pkl 데이터를 저장할 경로

Definition at line 22 of file utils_data.py.

def save_pkl_data(pkl_data, save_path):
    """
    pkl 데이터를 저장하는 기능
    args:
        pkl_data : 저장할 데이터
        save_path (str): pkl 데이터를 저장할 경로
    """
    with open(save_path, 'wb') as f:  
        pickle.dump(pkl_data, f)
 

search_json_by_path_format()

utils_data.search_json_by_path_format	(		folder,
			data_root = None )

Definition at line 324 of file utils_data.py.

def search_json_by_path_format(folder, data_root = None):
    if data_root is None:
        data_root = folder
        
    fileEx = '.json'
 
    json_list = []
    for path, dirs, files in os.walk(folder):
        if path.split('/')[-1].startswith('.'):
            continue
        json_list.extend([ file for file in files if file.endswith(fileEx)])
 
    json_list.sort()
 
    json_path = []
    for file in json_list:            
        json_path.append(join( [data_root, make_dataset_folder_path(file), file] ))
 
    return json_list, json_path

split_train_and_val()

utils_data.split_train_and_val	(		datas,
			class_num,
			max_train_data_num,
			max_val_data_num )

데이터를 훈련용과 평가용으로 분리하는 기능
args:
    datas (list[dict]): 데이터 리스트
    class_num (int): 총 클래스 수
    max_train_data_num (int): 훈련 데이터셋 최대 수량
    max_val_data_num (int): 평가 데이터셋 최대 수량
return:
    train_list (list[dict]): 훈련용 데이터셋
    val_list (list[dict]): 평가용 데이터셋

Definition at line 74 of file utils_data.py.

def split_train_and_val(datas, class_num, max_train_data_num, max_val_data_num):
    """
    데이터를 훈련용과 평가용으로 분리하는 기능
    args:
        datas (list[dict]): 데이터 리스트
        class_num (int): 총 클래스 수
        max_train_data_num (int): 훈련 데이터셋 최대 수량
        max_val_data_num (int): 평가 데이터셋 최대 수량
    return:
        train_list (list[dict]): 훈련용 데이터셋
        val_list (list[dict]): 평가용 데이터셋
    """
 
    #클래스별 데이터 분리
    data_dict = dict()
    for i in range(class_num):
        data_dict[i] = [] #초기화
    
    #분리
    for data in datas:
        data_dict[data['label']].append(data)    
    
    #훈련 및 평가용 데이터 분리
    train_list = []
    val_list = []
    for key, data_list in data_dict.items(): #클래스별 데이터 리스트
        data_num = len(data_list) #데이터 수량
        train_data_num = max_train_data_num #훈련용 데이터 수량
        if data_num < max_train_data_num: #데이터 수량이 부족할 경우, 95%를 학습용으로 사용
            train_data_num = int(data_num * 0.95)
        
        #평가용 데이터 끝 인덱스
        val_data_idx = min(data_num, train_data_num+max_val_data_num)
        
        #분리
        random.shuffle(data_list) #섞기
        train_list.extend(copy.deepcopy(data_list[:train_data_num])) #훈련용 데이터
        val_list.extend(copy.deepcopy(data_list[train_data_num:val_data_idx])) #평가용 데이터
    
    #섞기
    random.shuffle(train_list)
    random.shuffle(val_list)
    
    return train_list, val_list
 

split_train_and_val_v22()

utils_data.split_train_and_val_v22	(		data_folder,
			save_folder,
			category_info,
			total_data_num = 100,
			ratio = 0.8 )

세이프모션의 2.2 버전 행동 데이터를 훈련용과 평가용으로 분리하는 기능
args:
    data_folder (str): 데이터가 저장된 폴더
    save_folder (str): 학습 및 훈련용 데이터를 저장할 폴더
    category_info (dict): 학습 데이터의 카테고리별 클래스 수
    total_data_num (int): 클래스별 총 데이터 수(학습+평가 데이터 수)
    ratio (float): 학습용 데이터의 비율

Definition at line 210 of file utils_data.py.

def split_train_and_val_v22(data_folder, save_folder, category_info, total_data_num=100, ratio=0.8):
    """
    세이프모션의 2.2 버전 행동 데이터를 훈련용과 평가용으로 분리하는 기능
    args:
        data_folder (str): 데이터가 저장된 폴더
        save_folder (str): 학습 및 훈련용 데이터를 저장할 폴더
        category_info (dict): 학습 데이터의 카테고리별 클래스 수
        total_data_num (int): 클래스별 총 데이터 수(학습+평가 데이터 수)
        ratio (float): 학습용 데이터의 비율
    """
    #변수 초기화 및 저장 폴더 생성
    split_datas = dict() #클래스별 데이터 분리용 변수
    for category, num in category_info.items():
        split_datas[category] = dict()
        for label in range(num):
            #클래스별 데이터 분리용 변수 초기화
            split_datas[category][label] = dict()
            split_datas[category][label]['train'] = []
            split_datas[category][label]['val'] = []
            
            #저장 폴더 생성
            folder_train = os.path.join(save_folder, 'train', category, f'{label:02d}') #훈련 데이터 폴더
            folder_val = os.path.join(save_folder, 'val', category, f'{label:02d}') #평가 데이터 폴더
            create_directory(folder_train)
            create_directory(folder_val)
 
    #데이터 분리
    for category, num in category_info.items():#카테고리별 클래스 수량
        for label in range(num): #클래스 번호
 
            folder = os.path.join(data_folder, category, f'{label:02d}') #클래스 관련 데이터 폴더
            name_list, path_list = search_file(folder, '.pkl') #폴더 내 데이터 목록
 
            data_num = min(len(path_list), total_data_num)  #총 데이터수
            train_num = int( data_num * ratio ) #학습용 데이터 수 설정
            
            random.shuffle(path_list) #섞기
            split_datas[category][label]['train'] = path_list[:train_num] #학습용 데이터
            split_datas[category][label]['val'] = path_list[train_num:data_num] #평가용 데이터
    
    #데이터 저장
    for category, num in category_info.items():
        for label in range(num):
            for mode, path_list in split_datas[category][label].items():
                folder = os.path.join(save_folder, mode, category, f'{label:02d}')
                for path in path_list:
                    name = path.split('/')[-1]
                    save_path = os.path.join(folder, name)
                    shutil.copy(path, save_path)