Upload folder using huggingface_hub

toolkit/__init__.py

@@ -0,0 +1 @@
+"""Minimal toolkit namespace used by the SWD-H stage1 release."""

toolkit/globals.py

@@ -0,0 +1,3 @@
+emos_mer = ['neutral', 'angry', 'happy', 'sad', 'worried', 'surprise']
+emo2idx_mer = {emo: idx for idx, emo in enumerate(emos_mer)}
+idx2emo_mer = {idx: emo for idx, emo in enumerate(emos_mer)}

toolkit/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility helpers for dataset IO, parsing, and vLLM-based scoring."""

toolkit/utils/chatgpt.py

@@ -0,0 +1,24 @@
+"""No-network stubs kept only for compatibility with legacy imports.
+
+The open-source stage1 package does not use OpenAI or other hosted GPT APIs.
+Use local Hugging Face/vLLM models for evaluation label extraction.
+"""
+
+
+def _removed_api(*args, **kwargs):
+    raise RuntimeError(
+        "Hosted GPT API helpers were removed from the SWD-H stage1 open-source package."
+    )
+
+
+func_get_completion = _removed_api
+get_completion = _removed_api
+get_translate_eng2chi = _removed_api
+get_translate_chi2eng = _removed_api
+get_image_emotion_batch = _removed_api
+get_video_emotion_batch = _removed_api
+get_text_emotion_batch = _removed_api
+get_multi_emotion_batch = _removed_api
+get_evoke_emotion_batch = _removed_api
+get_micro_emotion_batch = _removed_api
+get_different_format = _removed_api

toolkit/utils/functions.py

@@ -0,0 +1,100 @@
+import os
+import re
+import math
+
+import cv2
+import numpy as np
+import pandas as pd
+import torchaudio
+from PIL import Image
+
+
+def string_to_list(value):
+    if isinstance(value, np.ndarray):
+        value = value.tolist()
+    if isinstance(value, list):
+        return value
+    if value == '' or pd.isna(value):
+        return []
+
+    value = str(value).strip()
+    if value.startswith('['):
+        value = value[1:]
+    if value.endswith(']'):
+        value = value[:-1]
+    return [item.strip() for item in re.split('[\'\",]', value)
+            if item.strip() not in ['', ',']]
+
+
+def func_gain_videopath(video_root, vid_name):
+    for suffix in ('.mp4', '.avi'):
+        candidate = f"{video_root}/{vid_name}{suffix}"
+        if os.path.exists(candidate):
+            return candidate
+    return f"{video_root}/{vid_name}.mp4"
+
+
+def func_gain_audiopath(video_root, vid_name):
+    return f"{video_root}/{vid_name}.wav"
+
+
+def func_gain_name2trans(trans_path):
+    from toolkit.utils.read_files import func_read_key_from_csv
+
+    names = func_read_key_from_csv(trans_path, 'name')
+    chis = func_read_key_from_csv(trans_path, 'chinese')
+    return {name: chi for name, chi in zip(names, chis)}
+
+
+def func_read_audio_second(audio_path):
+    waveform, sr = torchaudio.load(audio_path)
+    if len(waveform.shape) == 2:
+        return waveform.shape[1] / sr
+    if len(waveform.shape) == 1:
+        return len(waveform) / sr
+    raise ValueError('Unsupported waveform shape')
+
+
+def func_opencv_to_image(img):
+    return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+
+def func_decord_to_image(img):
+    return Image.fromarray(img)
+
+
+def func_opencv_to_decord(img):
+    return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+
+def func_discrte_label_distribution(labels):
+    unique, counts = np.unique(labels, return_counts=True)
+    return dict(zip(unique.tolist(), counts.tolist()))
+
+
+def func_label_distribution(labels):
+    return func_discrte_label_distribution(labels)
+
+
+def split_list_into_batch(items, split_num=None, batchsize=None):
+    """Split a list into non-empty batches while preserving item order."""
+    if split_num is None and batchsize is None:
+        raise ValueError("Either split_num or batchsize must be provided.")
+    if batchsize is not None and batchsize <= 0:
+        raise ValueError("batchsize must be positive.")
+    if split_num is not None and split_num <= 0:
+        raise ValueError("split_num must be positive.")
+    if len(items) == 0:
+        return []
+
+    if split_num is None:
+        split_num = math.ceil(len(items) / batchsize)
+
+    batches = []
+    each_split = math.ceil(len(items) / split_num)
+    for idx in range(split_num):
+        batch = items[idx * each_split:(idx + 1) * each_split]
+        if batch:
+            batches.append(batch)
+
+    return batches

toolkit/utils/qwen.py

@@ -0,0 +1,384 @@
+
+import os
+import cv2
+import math
+import time
+import tqdm
+import glob
+import base64
+import numpy as np
+
+
+# ====================================================== # 
+############          模型基本调用策略         ############
+# ====================================================== # 
+def func_postprocess_qwen(response):
+    response = response.strip()
+    if response.startswith("输入"):   response = response[len("输入"):]
+    if response.startswith("输出"):   response = response[len("输出"):]
+    if response.startswith("翻译"):   response = response[len("翻译"):]
+    if response.startswith("让我们来翻译一下："): response = response[len("让我们来翻译一下："):]
+    if response.startswith("output"): response = response[len("output"):]
+    if response.startswith("Output"): response = response[len("Output"):]
+    if response.startswith("input"): response = response[len("input"):]
+    if response.startswith("Input"): response = response[len("Input"):]
+    response = response.strip()
+    if response.startswith(":"):  response = response[len(":"):]
+    if response.startswith("："): response = response[len("："):]
+    response = response.strip()
+    response = response.replace('\n', '') # remove \n
+    response = response.strip()
+    return response
+
+
+# 采用qwen完成接口调用：同时支持 prompt 或者 prompt_list
+def get_completion_qwen(model, tokenizer, prompt):
+    
+    assert isinstance(prompt, str)
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": prompt}
+    ]
+
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
+    model_inputs = tokenizer([text], return_tensors="pt").to("cuda")
+
+    generated_ids = model.generate(
+        model_inputs.input_ids,
+        max_new_tokens=512
+    )
+    generated_ids = [
+        output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+    ]
+
+    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+    response = func_postprocess_qwen(response)
+    print(f"Prompt: {prompt} \n Response: {response}")
+    return response
+
+
+# 依赖于 vllm 
+def get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list):
+    
+    assert isinstance(prompt_list, list)
+
+    message_batch = []
+    for prompt in prompt_list:
+        message_batch.append([{"role": "user", "content": prompt}])
+
+    text_batch = tokenizer.apply_chat_template(
+        message_batch,
+        tokenize=False,
+        add_generation_prompt=True,
+    )
+
+    outputs = llm.generate(text_batch, sampling_params)
+    
+    # => batch_responses
+    batch_responses = []
+    for output in outputs:
+        prompt = output.prompt
+        response = output.outputs[0].text
+        response = func_postprocess_qwen(response)
+        batch_responses.append(response)
+        print(f"Prompt: {prompt} \n Response: {response}")
+    return batch_responses
+
+
+
+# ========================= # 
+##      基本操作：翻译      ##
+# ========================= # 
+def translate_chi2eng_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    
+    def func_prompt_template(reason):
+        prompt = f"""Please translate the Chinese input into English. Please ensure the translated results does not contain any Chinese words.
+Input: 高兴; Output: happy \
+Input: 生气; Output: angry \
+Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+
+def translate_eng2chi_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    
+    def func_prompt_template(reason):
+        prompt = f"""Please translate the English input into Chinese.
+Input: happy; Output: 高兴 \
+Input: angry; Output: 生气 \
+Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+
+
+
+# ========================== # 
+##      reason merging      ##
+# ========================== # 
+def reason_merge_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, 
+                      reason=None, subtitle=None, batch_reasons=None, batch_subtitles=None):
+    
+    def func_prompt_template(reason, subtitle):
+        
+        assert subtitle != "", 'Error: subtitle cannot be empty.'
+        
+        if reason != '':
+            reason_merge = ""
+            reason_merge += f"Clue: {reason}；"
+            reason_merge += f"Subtitle: {subtitle}"
+            prompt = f"Please assume the role of an expert in the field of emotions. \
+    We have provided clues from the video that may be related to the characters' emotional states. \
+    In addition, we have also provided the subtitle content of the video. \
+    Please merge all these information to infer the emotional states of the characters, and provide reasoning for your inferences. \
+    Input: {reason_merge}\
+    Output:"
+        else:
+            reason_merge = ""
+            reason_merge += f"Subtitle: {subtitle}"
+            prompt = f"Please assume the role of an expert in the field of emotions.\
+    We have provided the subtitle content of the video.\
+    Please infer the emotional states of the characters, and provide reasoning process for your inferences.\
+    Input: {reason_merge}\
+    Output:"
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason, subtitle)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason, subtitle in zip(batch_reasons, batch_subtitles):
+            prompt = func_prompt_template(reason, subtitle)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+
+
+############################################################################
+############################################################################
+############################################################################
+## 后面这些都是跟标签和评价相关的部分
+
+# ====================================================== # 
+##      reason -> (onehot, rank, openset, valence)      ##
+# ====================================================== # 
+def reason_to_onehot_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    
+    # 1. 给 few-shot 的结果看起来更合理一些 => 至少格式看着正确一些
+    # 2. 增加一个相对复杂的shot看看结果
+    # 3. 再次强调看看呢？ => 依旧是很多输出 mix 的结果，说明模型的指令追随能力一般般
+    def func_prompt_template(reason):
+        prompt = f"""Please act as an expert in the field of emotions. \
+We provide clues that related to the character's emotions. Based on the provided clues, please identify the emotional states of the main character. \
+The main character is the one with the most detailed clues. \
+Please select one of the following emotion labels that best matches the given clues: [happy, angry, worried, sad, surprise, neutral]. \
+We would like to emphasize that please must only output one label from the above candidates: [happy, angry, worried, sad, surprise, neutral]. You cannot output label outside these candidates, like mixed, happiness. \
+Input: We cannot recognize his emotional state; Output: neutral \
+Input: His emotional state is joyful, happiness, anger; Output: happy \
+Input: While the woman in the video appears to be in a positive emotional state, the audio suggests that the speaker might be experiencing anxiety or nervousness, particularly when discussing the shopping card; Output: worried \
+Input: The character likely experiences a range of positive emotions including excitement, enthusiasm, and confidence. They might feel motivated and inspired by the topic they are discussing, demonstrating a high level of engagement and investment; Output: happy \
+Input: {reason}; Output: """
+        return prompt
+
+    # 标签后处理: 删除结尾处的 “句号”
+    def func_onehot_label_polish(onehot):
+        onehot = onehot.split('.')[0]
+        return onehot
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        response = func_onehot_label_polish(response)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        for ii, response in enumerate(response_list):
+            response_list[ii] = func_onehot_label_polish(response)
+        return response_list
+
+def reason_to_rank_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    
+    def func_prompt_template(reason):
+        prompt = f"""Please assume the role of an expert in the emotional domain. We provide clues that may be related to the emotions of the character. \
+            Based on the provided clues, identify the emotional states of the main character. \
+            We provide a set of emotional candidates, please rank them in order of likelihood from high to low. \
+            The candidate set is [happy, angry, worried, sad, surprise, neutral]. Please directly output the ranking results. \
+            Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+
+def reason_to_openset_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    
+    def func_prompt_template(reason):
+        prompt = f"""Please assume the role of an expert in the field of emotions. \
+We provide clues that may be related to the emotions of the characters. Based on the provided clues, please identify the emotional states of the main character. \
+The main character is the one with the most detailed clues. \
+Please separate different emotional categories with commas and output only the clearly identifiable emotional categories in a list format. \
+If none are identified, please output an empty list. \
+Input: We cannot recognize his emotional state; Output: [] \
+Input: His emotional state is happy, sad, and angry; Output: [happy, sad, angry] \
+Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+
+
+def reason_to_valence_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    
+    def func_prompt_template(reason):
+        prompt = f"""Please identify the overall positive or negative emotional polarity of the main characters.  \
+The output should be a floating-point number ranging from -1 to 1.  \
+Here, -1 indicates extremely negative emotions, 0 indicates neutral emotions, and 1 indicates extremely positive emotions.  \
+Please provide your judgment as a floating-point number.  \
+Input: I am very happy; Output: 1  \
+Input: I am very angry; Output: -1 \
+Input: I am neutral; Output: 0 \
+Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+
+
+# ========================================== # 
+##      openset -> (onehot, sentiment)      ##
+# ========================================== # 
+def openset_to_onehot_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    def func_prompt_template(reason):
+        prompt = f"""Please act as an expert in the field of emotions. \
+            We provide a few words to describe the emotions of a character. \
+            Please choose the emotion label from the following list that is closest to the given words: happy, angry, worried, sad, surprise, neutral.
+            Input: [joyful]; Output: happy \
+            Input: []; Output: neutral \
+            Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+def openset_to_sentiment_qwen(model=None, tokenizer=None, llm=None, sampling_params=None, reason=None, batch_reasons=None):
+    def func_prompt_template(reason):
+        prompt = f"""Please act as an expert in the field of emotions. \
+            We provide a few words to describe the emotions of a character. \
+            Please choose the most likely sentiment from the given candidates: [positive, negative, neutral] \
+            Please direct output answer without analyzing process. \
+            Input: [joyful]; Output: positive \
+            Input: []; Output: neutral \
+            Input: {reason}; Output: """
+        return prompt
+
+    ## process for reason
+    if reason is not None:
+        prompt = func_prompt_template(reason)
+        response = get_completion_qwen(model, tokenizer, prompt)
+        return response
+
+    ## process for reason_list
+    if batch_reasons is not None:
+        prompt_list = []
+        for reason in batch_reasons:
+            prompt = func_prompt_template(reason)
+            prompt_list.append(prompt)
+        response_list = get_completion_qwen_bacth(llm, sampling_params, tokenizer, prompt_list)
+        return response_list
+
+

toolkit/utils/read_files.py

@@ -0,0 +1,263 @@
+import os
+import json
+import math
+import random
+import numpy as np
+import pandas as pd
+import tqdm
+
+## read pkl
+# videoIDs, videoSpeakers, videoLabels, videoText, videoAudio, videoVisual1, videoSentence, trainVid, \
+#     testVid = pickle.load(open(pkl_path, "rb"), encoding='latin1')
+
+## write pkl
+# pickle.dump([videoIDs, videoSpeakers, videoLabelsNew, videoTextNew, videoAudioNew, videoVisualNew, videoSentence, trainVid, \
+#             testVid], open(save_path, 'wb'))
+
+## read txt
+# with open(output_path, encoding='utf8') as f: lines = [line.strip() for line in f]
+# lines = [line for line in lines if len(line)!=0]
+
+## write txt
+# file_object = open('thefile.txt', 'w')
+# file_object.write(all_the_text)
+# file_object.close()
+
+## read csv file
+# df_label = pd.read_csv(label_file)
+# meta_columns = ['timestamp', 'segment_id']
+# metas = df_label[meta_columns].values # change to numpy
+# label_timestamps = metas[:,0]
+# df = pd.concat(segment_dfs) ## concat different csv files
+# for _, row in df.iterrows(): ## read for each row
+#     word = row['word']
+
+## write csv file
+# meta_columns = ['timestamp', 'segment_id']
+# columns = meta_columns + [str(i) for i in range(embedding_dim)] # x,x,0,1,2,3,4,5,...
+# data = np.column_stack([metas, aligned_embeddings])
+# df = pd.DataFrame(data=data, columns=columns)
+# df[meta_columns] = df[meta_columns].astype(np.int64)
+# df.to_csv(csv_file, index=False)
+
+## read json
+# with open("../config/record.json",'r') as load_f:
+#   load_dict = json.load(load_f)
+
+## write json
+# with open("../config/record.json","w") as f:
+#   json.dump(new_dict,f)
+
+
+
+# 功能1：只支持一个keyname
+def func_labelstudio_init_key(keyname, names, values, save_path=""):
+    whole_json = []
+    for ii, name in enumerate(names):
+        # s3_path = f's3://zeroqiaoba-first/video3/{name}.webm' # case1 [ok]
+        # s3_path = f's3://zeroqiaoba/video5/{name}.webm'
+        # s3_path = f's3://zeroqiaoba-first\\video3\\{name}.webm' # case2 [unwork]
+        s3_path = f'/data/local-files/?d=video_webm/{name}.webm' # local storage
+        onefile_json = {}
+        onefile_json['id'] = ii
+        onefile_json['data'] = {}
+        onefile_json['data']['video'] = s3_path
+        onefile_json['data'][keyname] = values[ii]
+        onefile_json['annotations'] = []
+        onefile_json['predictions'] = []
+        whole_json.append(onefile_json)
+    ## save whole_json
+    with open(save_path, "w") as f: 
+        json.dump(whole_json, f)
+    return whole_json
+
+
+# 功能1：给一个json文件增加一个key
+def func_labelstudio_update_key(json_path, val_name, name2val):
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    for item in data:
+        video = item['data']['video']
+        videoname = os.path.basename(video).rsplit('.', 1)[0] # 对于 case1 [ok]
+        # videoname = video.split('\\')[-1].rsplit('.', 1)[0] # case2 [unwork]
+        item['data'][val_name] = name2val[videoname]
+    
+    with open(json_path, "w") as f:
+        json.dump(data, f)
+        
+
+# 功能：将一个json分割到多个json，并存储在store_root中
+def func_labelstudio_split_json(json_path, store_root, split_num=8, shuffle=True):
+    if not os.path.exists(store_root):
+        os.makedirs(store_root)
+
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    if shuffle:
+        data = func_shuffle_list_data(data)
+
+    subset_number = math.ceil(len(data)/split_num)
+    for ii in range(split_num):
+        sub_data = data[ii*subset_number:(ii+1)*subset_number]
+
+        save_path = os.path.join(store_root, f'split-{ii}.json')
+        with open(save_path, "w") as f:
+            json.dump(sub_data, f)
+
+# 功能：将一个list文件分成多份，存储在store_root中
+def func_split_list_data(data, store_root, split_num=8, shuffle=True):
+    if not os.path.exists(store_root):
+        os.makedirs(store_root)
+
+    if shuffle:
+        data = func_shuffle_list_data(data)
+
+    subset_number = math.ceil(len(data)/split_num)
+    for ii in range(split_num):
+        sub_data = data[ii*subset_number:(ii+1)*subset_number]
+
+        save_path = os.path.join(store_root, f'split-{ii}.npy')
+        np.save(save_path, sub_data)
+
+
+# 功能2：读取key值对应的 name2key [因为可能存在多个values，所以返回的values都变成list格式了]
+def func_labelstudio_read_key(json_path):
+    with open(json_path,'r',encoding='utf-8') as f:
+        data = json.load(f)
+    
+    name2val = {}
+    for item in data:
+        values = []
+
+        ## analyze videoname
+        videopath = item['data']['video']
+        videoname = os.path.basename(videopath).rsplit('.', 1)[0]
+        # case1: sample_00001189.webm
+        # case2: def5d5b7-sample_00001189.webm
+        videoname_split = videoname.split('-', 1)
+        if len(videoname_split) == 2:
+            videoname = videoname_split[1]
+        elif len(videoname_split) == 1:
+            videoname = videoname_split[0]
+        else:
+            print (videoname)
+            raise ValueError('videoname has some errors!!')
+        
+        ## analyze annotations
+        keys, values = [], []
+        annotations = item['annotations']
+        assert len(annotations) == 1
+        result = annotations[0]['result']
+        for ii in range(len(result)): # result 可能有多个 value
+
+            # 分析 choices 内容
+            if 'choices' in result[ii]['value']:
+                item = result[ii]['value']['choices']
+                keyname = result[ii]['from_name']
+                values.append(item)
+                keys.append(keyname)
+                
+            # 分析 text 内容
+            if 'text' in result[ii]['value']:
+                item = result[ii]['value']['text']
+                keyname = result[ii]['from_name']
+                values.append(item)
+                keys.append(keyname)
+
+        name2val[videoname] = (keys, values)
+    return name2val
+
+
+def func_shuffle_list_data(whole_json):
+	indices = np.arange(len(whole_json))
+	random.shuffle(indices)
+
+	new_json = []
+	for index in indices:
+		new_json.append(whole_json[index])
+	return new_json
+
+
+# 功能3：从csv中读取特定的key对应的值
+def func_read_key_from_csv(csv_path, key):
+    values = []
+    df = pd.read_csv(csv_path)
+    # for _, row in df.iterrows():
+    for _, row in df.iterrows():
+        if key not in row:
+            values.append("")
+        else:
+            value = row[key]
+            if pd.isna(value): value=""
+            values.append(value)
+    return values
+
+
+# names[ii] -> keys=name2key[names[ii]], containing keynames
+def func_write_key_to_csv(csv_path, names, name2key, keynames):
+    ## specific case: only save names
+    if len(name2key) == 0 or len(keynames) == 0:
+        df = pd.DataFrame(data=names, columns=['name'])
+        df.to_csv(csv_path, index=False)
+        return
+
+    ## other cases:
+    if isinstance(keynames, str):
+        keynames = [keynames]
+    assert isinstance(keynames, list)
+    columns = ['name'] + keynames
+
+    values = []
+    for name in names:
+        value = name2key[name]
+        values.append(value)
+    values = np.array(values)
+    # ensure keynames is mapped
+    if len(values.shape) == 1:
+        assert len(keynames) == 1
+    else:
+        assert values.shape[-1] == len(keynames)
+    data = np.column_stack([names, values])
+
+    df = pd.DataFrame(data=data, columns=columns)
+    df.to_csv(csv_path, index=False)
+    
+
+# 仅限于utf-8
+def func_read_text_file(file_path):
+    try:
+        with open(file_path, encoding='utf8') as f: lines = [line.strip() for line in f]
+        lines = [line for line in lines if len(line)!=0]
+        return lines
+    except:
+        with open(file_path, encoding='ansi') as f: lines = [line.strip() for line in f]
+        lines = [line for line in lines if len(line)!=0]
+        return lines
+
+##############################################################################################
+## names[ii] -> values[ii], 可能存在多个values，写到keyname+{jj} 中，返回json内容，存储是后面存储的
+# whole_json = func_labelstudio_init_key(keyname, names, values)
+
+## 给一个json_path增加一个key，并按照原始路径保存到json_path
+# func_labelstudio_update_key(json_path, val_name, name2val)
+
+## 功能：将一个json分割到多个json，并存储在store_root中
+# func_labelstudio_split_json(json_path, store_root, split_num=8, shuffle=True)
+
+## 功能：将一个list数据分割成split_num
+# func_split_list_data(data, store_root, split_num=8, shuffle=True)
+
+## 功能：读取key值对应的 name2key，可能有多个values值
+# name2val = func_labelstudio_read_key(json_path)
+
+## 将json信息打乱
+## new_json = func_shuffle_list_data(whole_json)
+
+## 功能：从csv中读取特定的key对应的值
+# func_read_key_from_csv(csv_path, key)
+
+## names[ii] -> keys=name2key[names[ii]], containing keynames -> csv_path
+## func_write_key_to_csv(csv_path, names, name2key, keynames)
+##############################################################################################