Upload 3 files

data/data_loader.py

@@ -0,0 +1,295 @@
+import json
+import os
+import pickle
+import random
+from pathlib import Path
+import time
+import wfdb
+import numpy as np
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision.transforms import ColorJitter
+from scipy.io import loadmat
+from load_class import get_temp_qa, change_ecg_to_qa, prepare_ecg_qa_data
+from utils import set_device
+import matplotlib.pyplot as plt
+import argparse
+from meta_trainer import MetaTrainer
+import warnings
+from transformers import AutoTokenizer
+
+warnings.filterwarnings("ignore")
+
+torch.manual_seed(222)
+torch.cuda.manual_seed_all(222)
+np.random.seed(222)
+
+PROJECT_ROOT = str(Path.cwd().parent.parent)  # project path
+LOG_PATH = PROJECT_ROOT + "/logs/"
+MODELS_PATH = PROJECT_ROOT + "/models/"
+
+class FSL_ECG_QA_DataLoader(Dataset):
+    """
+    This is DataLoader for episodic training on FSL_ECG_QA dataset
+    NOTICE: meta-learning is different from general supervised learning, especially the concept of batch and set.
+    batch: contains several sets / tasks
+    sets: conains n_way * k_shot for meta-train set, n_way * k_query for meta-test set.
+    """
+
+    def __init__(self, mode, batchsz, n_way, k_shot, k_query, seq_len, seq_len_a, repeats, tokenizer,
+                 prefix_length, startidx=0, all_ids=None, in_templates=None, prompt=1, paraphrased_path="",test_dataset=""):
+        self.batchsz = batchsz  
+        self.n_way = n_way  
+        self.k_shot = k_shot  
+        self.k_query = k_query  
+        self.repeats = repeats
+        self.setsz = self.n_way * self.k_shot if self.repeats == 0 else self.n_way * self.k_shot * (self.repeats + 1)
+        self.querysz = self.n_way * self.k_query  # number of samples per set for evaluation
+        self.seq_len = seq_len  # sentence seq length
+        self.seq_len_a = seq_len_a
+        self.prefix_length = prefix_length
+        self.startidx = startidx  # index label not from 0, but from startidx
+        self.device = set_device()
+        print('shuffle DB: %s, b:%d, %d-way, %d-shot, %d-query, %d-repeats' % (mode, batchsz, n_way, k_shot,
+                                                                                          k_query, repeats))
+        self.gpt_tokenizer = tokenizer
+        self.mode = mode
+        self.all_ids = all_ids
+        self.prompt = prompt
+        self.test_dataset=test_dataset
+        
+        json_data_ecg = change_ecg_to_qa(all_ids, in_templates, paraphrased_path, test_dataset=test_dataset)
+      
+        self.data = []
+        self.img2caption = {}
+        
+        for i, (category_name, ecg_q_as) in enumerate(json_data_ecg.items()):
+            self.data.append(ecg_q_as)
+
+        self.cls_num = len(self.data)
+        print("self.cls_num", self.mode, self.cls_num)
+        
+        self.create_batch(self.batchsz)
+
+
+    def create_batch(self, batchsz):
+        """
+        create batch for meta-learning.
+        ×episode× here means batch, and it means how many sets we want to retain.
+        :param episodes: batch size
+        :return:
+        """
+        self.support_x_batch = []  # support set batch
+        self.query_x_batch = []  # query set batch
+        # Creating of tasks; batchsz is the num. of iterations when sampling from the task distribution
+        for b in range(batchsz):  # for each batch
+            # 1.select n_way classes randomly
+            selected_cls = np.random.choice(self.cls_num, self.n_way, replace=False)  # no duplicate
+            support_x = []
+            query_x = []
+            for cls in selected_cls:
+                selected_question = np.random.choice(len(self.data[cls]), 1)[0]
+                selected_imgs_idx = np.random.choice(len(self.data[cls][selected_question]), self.k_shot + self.k_query)
+                np.random.shuffle(selected_imgs_idx)
+                indexDtrain = np.array(selected_imgs_idx[:self.k_shot])  # idx for Dtrain
+                indexDtest = np.array(selected_imgs_idx[self.k_shot:])  # idx for Dtest
+                support_x.append(
+                    np.array(self.data[cls][selected_question])[indexDtrain].tolist())  # get all images filename for current Dtrain
+                query_x.append(np.array(self.data[cls][selected_question])[indexDtest].tolist())
+                if self.repeats > 0:
+                    for i in range(self.repeats):
+                        support_x.append(np.array(self.data[cls][selected_question])[indexDtrain].tolist())
+
+            # shuffle the corresponding relation between support set and query set
+            random.shuffle(support_x)
+            random.shuffle(query_x)
+
+            self.support_x_batch.append(support_x)  # append set to current sets
+            self.query_x_batch.append(query_x)  # append sets to current sets
+                            
+            # shuffle the corresponding relation between support set and query set
+            random.shuffle(support_x)
+            random.shuffle(query_x)
+            self.support_x_batch.append(support_x)  # append set to current sets
+            self.query_x_batch.append(query_x)  # append sets to current sets
+
+    def get_ptbxl_data_path(self, ecg_id):
+        return os.path.join(
+            f"{int(ecg_id / 1000) * 1000 :05d}",
+            f"{ecg_id:05d}_hr"
+        )
+        
+    def gen_prompt(self, q_str):    
+        if self.prompt == 1:
+            token_p = "Question: "+q_str+"Answer: "
+        if self.prompt == 2:
+            token_p = q_str
+        if self.prompt == 3:
+            token_p = q_str+"the answer can be both, none or in question."
+        return token_p
+        
+    def __getitem__(self, index):
+        """
+        index means index of sets, 0<= index <= batchsz-1
+        :param index:
+        :return:
+        """
+        support_x = torch.FloatTensor(self.setsz, 12, 2500)
+        query_x = torch.FloatTensor(self.querysz, 12, 2500)
+        
+        support_y_q = []
+        support_y_a = []
+        support_y_q_mask = []
+        support_y_a_mask = []
+        query_y_q = []
+        query_y_a = []
+        query_y_q_mask = []
+        query_y_a_mask = []
+        
+        flatten_support_x = [f"/gpfs/home1/jtang1/multimodal_fsl_99/process_ptbxl2/{self.get_ptbxl_data_path(sample['ecg_id'][0])}"
+                             for sublist in self.support_x_batch[index] for sample in sublist]
+        flatten_query_x = [f"/gpfs/home1/jtang1/multimodal_fsl_99/process_ptbxl2/{self.get_ptbxl_data_path(sample['ecg_id'][0])}"
+                           for sublist in self.query_x_batch[index] for sample in sublist]
+        
+        for sublist in self.support_x_batch[index]:
+            for sample in sublist:
+                q_str = sample["question"].lower()
+                for num_a, content in enumerate(sample["answer"]):
+                    if num_a != 0:
+                        a_str += ", " + content.lower()
+                    else:
+                        a_str = content.lower()
+                
+                q_str_tokenized = self.gpt_tokenizer(self.gen_prompt(q_str), return_tensors="pt")['input_ids']
+
+                caption_padded_q, mask_0_q = pad_tokens(q_str_tokenized, self.seq_len, self.prefix_length,
+                                                self.gpt_tokenizer.eos_token_id)
+                support_y_q.append(caption_padded_q)
+                support_y_q_mask.append(mask_0_q)
+                
+                a_str_tokenized = self.gpt_tokenizer(a_str, return_tensors="pt")['input_ids']
+                caption_padded_a, mask_0_a = pad_tokens(a_str_tokenized, self.seq_len_a, self.prefix_length,
+                                                self.gpt_tokenizer.eos_token_id)
+                support_y_a.append(caption_padded_a)
+                support_y_a_mask.append(mask_0_a)
+                
+        support_y_q = torch.stack(support_y_q)
+        support_y_a = torch.stack(support_y_a)
+        support_y_q_mask = torch.stack(support_y_q_mask)
+        support_y_a_mask = torch.stack(support_y_a_mask)
+        
+        for sublist in self.query_x_batch[index]:
+            for sample in sublist:
+                q_str = sample["question"].lower()
+                for num_a, content in enumerate(sample["answer"]):
+                    if num_a != 0:
+                        a_str += ", " + content.lower()
+                    else:
+                        a_str = content.lower()
+
+                q_str_tokenized = self.gpt_tokenizer(self.gen_prompt(q_str), return_tensors="pt")['input_ids']
+                caption_padded_q, mask_0_q = pad_tokens(q_str_tokenized, self.seq_len, self.prefix_length,
+                                                        self.gpt_tokenizer.eos_token_id)
+                query_y_q.append(caption_padded_q)
+                query_y_q_mask.append(mask_0_q)
+
+                a_str_tokenized = self.gpt_tokenizer(a_str, return_tensors="pt")['input_ids']
+                caption_padded_a, mask_0_a = pad_tokens(a_str_tokenized, self.seq_len_a, self.prefix_length,
+                                                        self.gpt_tokenizer.eos_token_id)
+                query_y_a.append(caption_padded_a)
+                query_y_a_mask.append(mask_0_a)
+
+        query_y_q = torch.stack(query_y_q)
+        query_y_q_mask = torch.stack(query_y_q_mask)
+        query_y_a = torch.stack(query_y_a)
+        query_y_a_mask = torch.stack(query_y_a_mask)
+
+        # Reading of ecgs:
+        for i, path in enumerate(flatten_support_x):
+            ecg = loadmat(path)['feats']
+            support_x[i] = torch.tensor(ecg)
+
+        for i, path in enumerate(flatten_query_x):
+            ecg = loadmat(path)['feats']
+            query_x[i] = torch.tensor(ecg)
+
+        return support_x, support_y_q, support_y_a, support_y_q_mask, support_y_a_mask, flatten_support_x, query_x, query_y_q, query_y_a, query_y_q_mask, query_y_a_mask, flatten_query_x
+
+    def __len__(self):
+        return self.batchsz
+
+
+def pad_tokens(tokens, seq_len, prefix_length, eos_token_id):
+    tokens = tokens.squeeze(0)
+    padding = seq_len - tokens.shape[0]
+    if padding > 0:
+        tokens = torch.cat((tokens, torch.zeros(padding, dtype=torch.int64) - 1))
+    elif padding < 0:
+        tokens = tokens[:seq_len]
+    mask = tokens.ge(0)  # mask is zero where we out of sequence
+    tokens[~mask] = eos_token_id
+    mask = mask.float()
+    mask = torch.cat((torch.ones(prefix_length), mask), dim=0)  # adding prefix mask
+    return tokens, mask 
+    
+    
+if __name__ == '__main__':
+    argparser = argparse.ArgumentParser()
+
+    argparser.add_argument('--experiment_id', type=int, default=666)
+    argparser.add_argument('--batchsz_train', type=int, default=10000)
+    argparser.add_argument('--batchsz_test', type=int, default=1000)
+    argparser.add_argument('--model_name', type=str, help="path to model download from hugging face", default="path/to/model")
+    argparser.add_argument('--update_step', type=int, help='task-level inner update steps', default=5)
+    argparser.add_argument('--update_step_test', type=int, help='update steps for finetunning', default=15)
+    
+    argparser.add_argument('--paraphrased_path', type=str, default='path/to/paraphrased', 
+                          help='path to ./paraphrased containing trian/val/test ECG-QA json files')
+    argparser.add_argument('--question_type', type=str, help='question types, single-verify, single-choose, single-query,all', default='single-verify')
+    argparser.add_argument('--epoch', type=int, help='epoch number', default=10000)
+    argparser.add_argument('--n_way', type=int, help='n way', default=5)
+    argparser.add_argument('--k_spt', type=int, help='k shot for support set', default=5)
+    argparser.add_argument('--k_qry', type=int, help='k shot for query set', default=5)
+    argparser.add_argument('--prompt', type=int, help='1,Question: +q_str+Answer:,2,q_str,3,q_str+the answer can be both, none or in question.', default=1)
+    argparser.add_argument('--dif_exp', type=int, help='0,same_exp,1,dif_exp', default=0)
+    argparser.add_argument('--frozen_gpt', type=int, help='0,unfrozen_gpt,1,frozen_gpt', default=1)  
+    argparser.add_argument('--frozen_features', type=int, help='0,unfrozen_features,1,frozen_features', default=1)    
+    argparser.add_argument('--repeats', type=int, help='repeats for support set', default=0)
+    argparser.add_argument('--seq_len', help='for padding batch', type=int, default=30) 
+    argparser.add_argument('--seq_len_a', help='for padding batch', type=int, default=30)
+    argparser.add_argument('--prefix_length', type=int, default=4)
+    argparser.add_argument('--mapper_type', type=str, help='ATT MLP', default="MLP")
+    argparser.add_argument('--task_num', type=int, help='meta batch size, namely task num', default=1)
+    argparser.add_argument('--meta_lr', type=float, help='meta-level outer learning rate', default=5e-4)
+    argparser.add_argument('--update_lr', type=float, help='task-level inner update learning rate', default=0.05)
+    argparser.add_argument('--test_dataset', type=str, default="ptb-xl", choices=["ptb-xl", "mimic"], help='Dataset to use (ptb-xl or mimic)')
+    args = argparser.parse_args()
+
+    class_qa, train_temp, test_temp = prepare_ecg_qa_data(args)
+    
+    device = set_device()
+    meta = MetaTrainer(args, args.experiment_id, is_pretrained=False).to(device)
+    params = list(filter(lambda p: p.requires_grad, meta.model.parameters()))
+    params_summed = sum(p.numel() for p in params)
+    print("Total num of params: {} ".format(params_summed))
+    gpt_tokenizer = AutoTokenizer.from_pretrained(args.model_name)
+    data_loader_train = FSL_ECG_QA_DataLoader(mode='train', n_way=args.n_way, k_shot=args.k_spt,k_query=args.k_qry, batchsz=args.batchsz_train,
+                                      seq_len=args.seq_len, seq_len_a=args.seq_len_a,repeats=args.repeats, tokenizer=gpt_tokenizer,
+                                      prefix_length=args.prefix_length,all_ids=class_qa, in_templates=train_temp, prompt=args.prompt,
+                                      paraphrased_path= args.paraphrased_path, test_dataset=args.test_dataset)
+    data_loader_test  = FSL_ECG_QA_DataLoader(mode='test', n_way=args.n_way, k_shot=args.k_spt,k_query=args.k_qry, batchsz=args.batchsz_train,
+                                      seq_len=args.seq_len, seq_len_a=args.seq_len_a,repeats=args.repeats, tokenizer=gpt_tokenizer,
+                                      prefix_length=args.prefix_length,all_ids=class_qa, in_templates=test_temp, prompt=args.prompt,
+                                      paraphrased_path= args.paraphrased_path, test_dataset=args.test_dataset)
+    batch = next(iter(data_loader_train))
+    
+    if isinstance(batch, dict):
+        for key, value in batch.items():
+            print(f"{key}: {value}")
+    elif isinstance(batch, (list, tuple)):
+        for i, item in enumerate(batch):
+            print(f"Item {i}: {item}")
+    else:
+        print(batch)
+

data/load_class.py

@@ -0,0 +1,440 @@
+import os
+import glob
+import json
+import argparse
+from typing import List, Dict, Any, Union
+from collections import Counter
+import numpy as np
+
+def get_temp_qa(question_type, paraphrased_path):
+    """
+    Load all question data and return a list of filtered template IDs based on question_type.
+
+    Args:
+        question_type (str): Type of question to filter by ('single-query', 'single-verify', etc., or 'all').
+        paraphrased_path (str): Base path for the dataset.
+
+    Returns:
+        List[int]: A list of unique template IDs matching the filter criteria.
+    """
+    data = []
+    
+    for split in ["train", "valid", "test"]:
+        file_pattern = os.path.join(paraphrased_path, split, "*.json")
+        for fname in sorted(glob.glob(file_pattern)):
+            with open(fname, "r") as f:
+                records = json.load(f)
+                data.extend(records)
+
+    print(f"Loaded {len(data)} samples!")
+    
+    temp_list = []
+    if question_type != "all":
+        for item in data:
+            if item['question_type'] == question_type:
+                temp_list.append(item['template_id'])
+    else:
+        for item in data:
+            if "single-" in item['question_type']:
+                temp_list.append(item['template_id'])
+    
+    temp_ids = list(set(temp_list))
+    
+    # Filter template IDs to avoid conflict class
+    temp_ids = [i for i in temp_ids if i not in [17, 14, 26, 28, 4, 40, 31]]
+    return temp_ids
+
+def prepare_ecg_qa_data(args):
+    if args.question_type == "all":
+        class_qa = get_class_qa("single-verify")
+        ecg_qa_list_1 = change_ecg_to_qa(
+            class_qa, "single-verify",
+            paraphrased_path=args.paraphrased_path,
+            dif_exp=args.dif_exp
+        )
+
+        class_qa += get_class_qa("single-choose")
+        ecg_qa_list_2 = change_ecg_to_qa(
+            class_qa, "single-choose",
+            paraphrased_path=args.paraphrased_path,
+            dif_exp=args.dif_exp
+        )
+
+        class_qa += get_class_qa("single-query")
+        ecg_qa_list_3 = change_ecg_to_qa(
+            class_qa, "single-query",
+            paraphrased_path=args.paraphrased_path,
+            dif_exp=args.dif_exp
+        )
+
+        ecg_qa_list = {**ecg_qa_list_1, **ecg_qa_list_2, **ecg_qa_list_3}
+    else:
+        class_qa = get_temp_qa(args.question_type, args.paraphrased_path)
+        ecg_qa_list = change_ecg_to_qa(
+            class_qa, args.question_type,
+            paraphrased_path=args.paraphrased_path,
+            dif_exp=args.dif_exp
+        )
+
+    all_ecg_qa_temp = list(ecg_qa_list.keys())
+    sample_size = int(len(all_ecg_qa_temp) * 0.8)
+    train_temp = np.random.choice(all_ecg_qa_temp, sample_size, replace=False).tolist()
+    test_temp = [i for i in all_ecg_qa_temp if i not in train_temp]
+
+    return class_qa, train_temp, test_temp
+
+def change_ecg_to_qa(
+    sample_ids, 
+    question_type, 
+    paraphrased_path,
+    in_template=None, 
+    dif_exp=1, 
+    attr="",
+    test_dataset="ptb-xl"
+):
+    """
+    Process ECG data to create a dictionary of question-answer pairs categorized by template.
+    
+    Args:
+        sample_ids (List[int]): List of template IDs to include.
+        question_type (str): Type of question to filter.
+        paraphrased_path (str): Base path for all data.
+        data_root_path (str, optional): Path to the data root directory.
+        in_template (List, optional): List of templates to include.
+        dif_exp (int, optional): Controls return format. Default is 1.
+        attr (str, optional): Attribute type filter.
+        test_dataset (str, optional): Dataset to use ('ptb-xl' or 'mimic'). Default is 'ptb-xl'.
+        
+    Returns:
+        Dict: Dictionary of ECG QA data categorized by template.
+    """
+    data = []
+    
+        
+    # Define subdirectories to process
+    subdirectories = ["train", "valid", "test"]
+    
+    # Load data from all subdirectories
+    for subdir in subdirectories:
+        directory_path = os.path.join(paraphrased_path, subdir)
+        if not os.path.exists(directory_path):
+            print(f"Warning: Directory {directory_path} does not exist!")
+            continue
+            
+        file_pattern = os.path.join(directory_path, "*.json")
+        files = sorted(glob.glob(file_pattern))
+        
+        if not files:
+            print(f"Warning: No JSON files found in {directory_path}")
+            continue
+            
+        for fname in files:
+            with open(fname, "r") as f:
+                json_data = json.load(f)
+                data.extend(json_data)
+    
+    # Filter by attribute type if specified
+    if attr != "":
+        sample_data = [item for item in data if item['attribute_type'] == attr]
+    else:
+        sample_data = data
+    
+    # Filter samples by file existence if using MIMIC dataset
+    if test_dataset == "mimic":
+        ecg_data_path = os.path.join(paraphrased_path, "mimic_iv_ecg/processed_test_30k/")
+        if not os.path.exists(ecg_data_path):
+            print(f"Warning: MIMIC ECG data path {ecg_data_path} does not exist!")
+        sample_data = [sample for sample in sample_data if os.path.isfile(os.path.join(ecg_data_path, f"{sample['ecg_id'][0]}.mat"))]
+
+    ecg_qa_dict = {}
+    
+    if len(sample_data) == 0:
+        print(f"Cannot find template_id == {sample_ids} or no data available")
+    else:
+        for sample in sample_data:
+            template_id = sample['template_id']
+            if template_id in sample_ids:
+                process_sample_by_type(sample, template_id, ecg_qa_dict, in_template)
+    
+    filter_ecg_qa_dict_by_question_type(ecg_qa_dict, question_type)
+    
+    if dif_exp == 1:
+        return {key: [value] for key, value in ecg_qa_dict.items()}
+    
+    return filter_by_question_frequency(ecg_qa_dict)
+
+
+def process_sample_by_type(sample, template_id, ecg_qa_dict, in_template):
+    """
+    Process a sample based on its question type.
+    
+    Args:
+        sample (Dict): The sample data.
+        template_id (int): The template ID.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+        in_template (List, optional): List of templates to include.
+    """
+    question_type = sample['question_type']
+    
+    if question_type == 'single-verify':
+        process_single_verify_sample(sample, template_id, ecg_qa_dict, in_template)
+    elif question_type == 'single-choose':
+        process_single_choose_sample(sample, template_id, ecg_qa_dict, in_template)
+    elif question_type == 'single-query':
+        process_single_query_sample(sample, template_id, ecg_qa_dict, in_template)
+
+
+def process_single_verify_sample(sample, template_id, ecg_qa_dict, in_template):
+    """
+    Process a single-verify type sample.
+    
+    Args:
+        sample (Dict): The sample data.
+        template_id (int): The template ID.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+        in_template (List, optional): List of templates to include.
+    """
+    if sample['answer'][0] in ["yes", "no"]:
+        answer = sample['answer'][0]
+        all_attributes = "_".join(sorted(sample['attribute']))
+        dict_key = f"{template_id}_{all_attributes}_{answer}"
+        
+        if in_template is None or dict_key in in_template:
+            if dict_key not in ecg_qa_dict:
+                ecg_qa_dict[dict_key] = [sample]
+            else:
+                ecg_qa_dict[dict_key].append(sample)
+
+
+def process_single_choose_sample(sample, template_id, ecg_qa_dict, in_template):
+    """
+    Process a single-choose type sample.
+    
+    Args:
+        sample (Dict): The sample data.
+        template_id (int): The template ID.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+        in_template (List, optional): List of templates to include.
+    """
+    if len(sample['answer']) == 1:
+        answer = sample['answer'][0]
+    elif len(sample['answer']) == 2:
+        answer = "both"
+        sample['answer'] = ["both"]
+    else:
+        print("single-choose data have more than 2 answers!")
+        return
+    
+    all_attributes = "_".join(sorted(sample['attribute']))
+    
+    if in_template is None:
+        handle_single_choose_without_template(sample, template_id, answer, all_attributes, ecg_qa_dict)
+    else:
+        handle_single_choose_with_template(sample, template_id, answer, all_attributes, in_template, ecg_qa_dict)
+
+
+def handle_single_choose_without_template(sample, template_id, answer, all_attributes, ecg_qa_dict):
+    """
+    Handle a single-choose type sample when no template is provided.
+    
+    Args:
+        sample (Dict): The sample data.
+        template_id (int): The template ID.
+        answer (str): The answer string.
+        all_attributes (str): The joined attributes string.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+    """
+    if answer == "both":
+        dict_key = f"{template_id}_{all_attributes}_{answer}"
+        add_to_ecg_qa_dict(dict_key, sample, ecg_qa_dict)
+    elif answer == "none":
+        for attr in sample['attribute']:
+            dict_key = f"{template_id}_{attr}_{answer}"
+            add_to_ecg_qa_dict(dict_key, sample, ecg_qa_dict)
+    else:
+        dict_key = f"{template_id}_{answer}_{answer}"
+        add_to_ecg_qa_dict(dict_key, sample, ecg_qa_dict)
+
+
+def handle_single_choose_with_template(sample, template_id, answer, all_attributes, in_template, ecg_qa_dict):
+    """
+    Handle a single-choose type sample when a template is provided.
+    
+    Args:
+        sample (Dict): The sample data.
+        template_id (int): The template ID.
+        answer (str): The answer string.
+        all_attributes (str): The joined attributes string.
+        in_template (List): List of templates to include.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+    """
+    full_key = f"{template_id}_{all_attributes}_{answer}"
+    short_key = f"{template_id}_{answer}"
+    
+    if full_key in in_template or short_key in in_template:
+        if answer == "both":
+            dict_key = f"{template_id}_{all_attributes}_{answer}"
+            add_to_ecg_qa_dict(dict_key, sample, ecg_qa_dict)
+        elif answer == "none":
+            for attr in sample['attribute']:
+                dict_key = f"{template_id}_{attr}_{answer}"
+                add_to_ecg_qa_dict(dict_key, sample, ecg_qa_dict)
+        else:
+            dict_key = f"{template_id}_{answer}_{answer}"
+            add_to_ecg_qa_dict(dict_key, sample, ecg_qa_dict)
+
+
+def process_single_query_sample(sample, template_id, ecg_qa_dict, in_template):
+    """
+    Process a single-query type sample.
+    
+    Args:
+        sample (Dict): The sample data.
+        template_id (int): The template ID.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+        in_template (List, optional): List of templates to include.
+    """
+    if len(sample['answer']) == 1:
+        answer = sample['answer'][0]
+    elif len(sample['answer']) >= 2:
+        answer = ", ".join(sample['answer'])
+        sample['answer'] = [answer]
+    
+    all_attributes = "_".join(sorted(sample['attribute']))
+    dict_key = f"{template_id}_{all_attributes}_{answer}"
+    
+    if in_template is None or dict_key in in_template:
+        if dict_key not in ecg_qa_dict:
+            ecg_qa_dict[dict_key] = [sample]
+        else:
+            ecg_qa_dict[dict_key].append(sample)
+
+
+def add_to_ecg_qa_dict(key, sample, ecg_qa_dict):
+    """
+    Add a sample to the ECG QA dictionary.
+    
+    Args:
+        key (str): The dictionary key.
+        sample (Dict): The sample data.
+        ecg_qa_dict (Dict): Dictionary to populate with processed data.
+    """
+    if key not in ecg_qa_dict:
+        ecg_qa_dict[key] = [sample]
+    else:
+        ecg_qa_dict[key].append(sample)
+
+
+def filter_ecg_qa_dict_by_question_type(ecg_qa_dict, question_type):
+    """
+    Filter the ECG QA dictionary by question type and minimum sample counts.
+    
+    Args:
+        ecg_qa_dict (Dict): Dictionary to filter.
+        question_type (str): Type of question to filter by.
+    """
+    for key in list(ecg_qa_dict.keys()):
+        if question_type in ["single-verify", "single-choose", "single-query"]:
+            qt = question_type
+        elif question_type == "all":
+            if len(ecg_qa_dict[key]) == 0:
+                del ecg_qa_dict[key]
+                continue
+            qt = ecg_qa_dict[key][0]['question_type']
+        else:
+            continue
+        
+        if qt == "single-verify" and len(ecg_qa_dict[key]) < 140:
+            del ecg_qa_dict[key]
+        elif qt == "single-choose" and len(ecg_qa_dict[key]) < 14:
+            del ecg_qa_dict[key]
+        elif qt == "single-query" and len(ecg_qa_dict[key]) < 50:
+            del ecg_qa_dict[key]
+
+
+def filter_by_question_frequency(ecg_qa_dict):
+    """
+    Filter the ECG QA dictionary by question frequency.
+    
+    Args:
+        ecg_qa_dict (Dict): Dictionary to filter.
+        
+    Returns:
+        Dict: Filtered dictionary.
+    """
+    for key in list(ecg_qa_dict.keys()):
+        question_id_counter = Counter(sample['question_id'] for sample in ecg_qa_dict[key])
+        frequent_question_ids = [q_id for q_id, count in question_id_counter.items() if count >= 10]
+        
+        all_samples_by_question = []
+        for question_id in frequent_question_ids:
+            question_samples = [sample for sample in ecg_qa_dict[key] if sample['question_id'] == question_id]
+            all_samples_by_question.append(question_samples)
+        
+        if len(all_samples_by_question) != 0:
+            ecg_qa_dict[key] = all_samples_by_question
+        else:
+            del ecg_qa_dict[key]
+    
+    return ecg_qa_dict
+
+
+def validate_path(path):
+    """
+    Validate if a path exists.
+    
+    Args:
+        path (str): Path to validate.
+        
+    Returns:
+        bool: True if path exists, False otherwise.
+    """
+    if not os.path.exists(path):
+        return False
+    return True
+
+
+def main():
+    """
+    Main function to run the ECG data processing.
+    """
+    parser = argparse.ArgumentParser(description='ECG Data Processor')
+    parser.add_argument('--paraphrased_path', type=str, 
+                        default='path/to/paraphrased', 
+                        help='path to ./paraphrased containing trian/val/test ECG-QA json files')
+    parser.add_argument('--test_dataset', type=str, default="ptb-xl", choices=["ptb-xl", "mimic"], 
+                        help='Dataset to use (ptb-xl or mimic)')
+    
+    args = parser.parse_args()
+    paraphrased_path = args.paraphrased_path
+    
+    # Process each question type
+    for q_type in ['single-verify', 'single-choose', 'single-query', 'all']:
+        print(f"\nProcessing {q_type} question type...")
+        
+        # Get template IDs for the question type
+        temp_ids = get_temp_qa(q_type, paraphrased_path)
+        print(f"{q_type} temp_ids: {temp_ids} (total: {len(temp_ids)})")
+        
+        # Get the QA dictionary
+        ecg_qa_dict = change_ecg_to_qa(
+            temp_ids,
+            q_type,
+            paraphrased_path=paraphrased_path,
+            test_dataset=args.test_dataset
+        )
+        print(f"ECG QA dictionary length: {len(ecg_qa_dict)}")
+        
+        # Calculate total QA count
+        total_qa_count = 0
+        for category_key in ecg_qa_dict.keys():
+            category_values = ecg_qa_dict.get(category_key)
+            category_total = sum(len(item) for item in category_values)
+            total_qa_count += category_total
+            
+        print(f"Total QA count for '{q_type}': {total_qa_count}")
+        print("-" * 40)
+
+
+if __name__ == "__main__":
+    main()