from monai.transforms import ( AsDiscrete, AddChanneld, Compose, CropForegroundd, LoadImaged, Orientationd, RandFlipd, RandCropByPosNegLabeld, RandShiftIntensityd, ScaleIntensityRanged, Spacingd, RandRotate90d, ToTensord, CenterSpatialCropd, Resized, SpatialPadd, apply_transform, RandZoomd, RandCropByLabelClassesd, ) import collections.abc import math import pickle import shutil import sys import tempfile import threading import time import warnings from copy import copy, deepcopy import h5py, os from monai.transforms import Lambda import numpy as np import torch from typing import IO, TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Mapping, Optional, Sequence, Tuple, Union sys.path.append("..") from torch.utils.data import Subset from monai.data import DataLoader, Dataset, list_data_collate, DistributedSampler, CacheDataset from monai.config import DtypeLike, KeysCollection from monai.transforms.transform import Transform, MapTransform from monai.utils.enums import TransformBackends from monai.config.type_definitions import NdarrayOrTensor from monai.transforms.io.array import LoadImage, SaveImage from monai.utils import GridSamplePadMode, ensure_tuple, ensure_tuple_rep from monai.data.image_reader import ImageReader from monai.utils.enums import PostFix DEFAULT_POST_FIX = PostFix.meta() class UniformDataset(Dataset): def __init__(self, data, transform, datasetkey): super().__init__(data=data, transform=transform) self.dataset_split(data, datasetkey) self.datasetkey = datasetkey def dataset_split(self, data, datasetkey): self.data_dic = {} for key in datasetkey: self.data_dic[key] = [] for img in data: key = get_key(img['name']) self.data_dic[key].append(img) self.datasetnum = [] for key, item in self.data_dic.items(): assert len(item) != 0, f'the dataset {key} has no data' self.datasetnum.append(len(item)) self.datasetlen = len(datasetkey) def _transform(self, set_key, data_index): data_i = self.data_dic[set_key][data_index] # 创建一个随机状态 random_state = np.random.RandomState(np.random.randint(2147483647)) # 分别对治疗前后的数据应用相同的随机变换 pre_data = {'image': data_i['pre']['image'], 'label': data_i['pre']['label']} post_data = {'image': data_i['post']['image'], 'label': data_i['post']['label']} # 对于每个transform,使用相同的随机状态 if self.transform is not None: for t in self.transform.transforms: # 如果是随机变换,设置相同的随机种子 if hasattr(t, 'rand_param'): t.rand_param = random_state if hasattr(t, '_do_transform'): t._do_transform = random_state.random() < t.prob pre_transformed = apply_transform(self.transform, pre_data) post_transformed = apply_transform(self.transform, post_data) else: pre_transformed = pre_data post_transformed = post_data return { 'pre': pre_transformed, 'post': post_transformed, 'name': data_i['name'], 'text': data_i['text'] } def __getitem__(self, index): ## the index generated outside is only used to select the dataset ## the corresponding data in each dataset is selelcted by the np.random.randint function set_index = index % self.datasetlen set_key = self.datasetkey[set_index] # data_index = int(index / self.__len__() * self.datasetnum[set_index]) data_index = np.random.randint(self.datasetnum[set_index], size=1)[0] return self._transform(set_key, data_index) class UniformCacheDataset(CacheDataset): def __init__(self, data, transform, cache_rate, datasetkey): super().__init__(data=data, transform=transform, cache_rate=cache_rate) self.datasetkey = datasetkey self.data_statis() def data_statis(self): data_num_dic = {} for key in self.datasetkey: data_num_dic[key] = 0 # breakpoint() for img in self.data: key = get_key(img['name']) data_num_dic[key] += 1 self.data_num = [] for key, item in data_num_dic.items(): assert item != 0, f'the dataset {key} has no data' self.data_num.append(item) self.datasetlen = len(self.datasetkey) def index_uniform(self, index): ## the index generated outside is only used to select the dataset ## the corresponding data in each dataset is selelcted by the np.random.randint function set_index = index % self.datasetlen data_index = np.random.randint(self.data_num[set_index], size=1)[0] post_index = int(sum(self.data_num[:set_index]) + data_index) return post_index def __getitem__(self, index): post_index = self.index_uniform(index) # print(post_index, self.__len__()) return self._transform(post_index) class LoadImageh5d(MapTransform): def __init__( self, keys: KeysCollection, reader: Optional[Union[ImageReader, str]] = None, dtype: DtypeLike = np.float32, meta_keys: Optional[KeysCollection] = None, meta_key_postfix: str = DEFAULT_POST_FIX, overwriting: bool = False, image_only: bool = False, ensure_channel_first: bool = False, simple_keys: bool = False, allow_missing_keys: bool = False, *args, **kwargs, ) -> None: super().__init__(keys, allow_missing_keys) self._loader = LoadImage(reader, image_only, dtype, ensure_channel_first, simple_keys, *args, **kwargs) if not isinstance(meta_key_postfix, str): raise TypeError(f"meta_key_postfix must be a str but is {type(meta_key_postfix).__name__}.") self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys) if len(self.keys) != len(self.meta_keys): raise ValueError("meta_keys should have the same length as keys.") self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys)) self.overwriting = overwriting def register(self, reader: ImageReader): self._loader.register(reader) def __call__(self, data, reader: Optional[ImageReader] = None): d = dict(data) for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix): data = self._loader(d[key], reader) if self._loader.image_only: d[key] = data else: if not isinstance(data, (tuple, list)): raise ValueError("loader must return a tuple or list (because image_only=False was used).") d[key] = data[0] if not isinstance(data[1], dict): raise ValueError("metadata must be a dict.") meta_key = meta_key or f"{key}_{meta_key_postfix}" if meta_key in d and not self.overwriting: raise KeyError(f"Metadata with key {meta_key} already exists and overwriting=False.") d[meta_key] = data[1] return d class RandZoomd_select(RandZoomd): def __call__(self, data): d = dict(data) name = d['name'] key = get_key(name) if (key not in ['10_03', '10_06', '10_07', '10_08', '10_09', '10_10']): return d d = super().__call__(d) return d class RandCropByPosNegLabeld_select(RandCropByPosNegLabeld): def __call__(self, data): d = dict(data) name = d['name'] key = get_key(name) if key in ['10_03', '10_07', '10_08', '04', '05']: # if key in ['10_03', '10_07', '10_08', '04'] return d d = super().__call__(d) return d class CenterTumorRandCropByLabelClassesd(RandCropByLabelClassesd): def __init__(self, center_ratio=0.6, **kwargs): super().__init__(**kwargs) self.center_ratio = center_ratio # 中心区域占整个裁剪区域的比例 def __call__(self, data): d = dict(data) label = d[self.label_key] # 获取肿瘤区域的中心点 tumor_indices = torch.nonzero((label == 2) | (label == 1)) # 获取肿瘤区域的所有索引 if len(tumor_indices) == 0: return super().__call__(d) # 如果没有肿瘤，使用原始的随机裁剪 center = torch.mean(tumor_indices.float(), dim=0) # 计算肿瘤区域的中心点 # 计算中心区域的范围 spatial_size = self.spatial_size center_size = [int(s * self.center_ratio) for s in spatial_size] # 确保裁剪区域包含肿瘤中心 min_bound = [c - s//2 for c, s in zip(center, spatial_size)] max_bound = [c + s//2 for c, s in zip(center, spatial_size)] # 调整边界确保在图像范围内 for i in range(len(min_bound)): if min_bound[i] < 0: min_bound[i] = 0 max_bound[i] = spatial_size[i] if max_bound[i] > label.shape[i]: max_bound[i] = label.shape[i] min_bound[i] = max(0, label.shape[i] - spatial_size[i]) # 在调整后的范围内随机选择裁剪起点 start_coords = [np.random.randint(min_b, max_b - s + 1) for min_b, max_b, s in zip(min_bound, max_bound, spatial_size)] # 执行裁剪 slices = [slice(s, s + sz) for s, sz in zip(start_coords, spatial_size)] result = {} for key in self.keys: result[key] = d[key][slices] return result class SeparateRandCropByLabelClassesd(RandCropByLabelClassesd): def __init__(self, max_tumor_ratio=0.4, max_liver_ratio=0.8, **kwargs): super().__init__(**kwargs) self.max_tumor_ratio = max_tumor_ratio # 最大肿瘤占比 self.max_liver_ratio = max_liver_ratio # 最大肝脏占比 def check_ratios(self, label): # 计算肿瘤和肝脏的体素数量 total_voxels = label.size tumor_voxels = np.sum((label == 2)) liver_voxels = np.sum(label > 0) # 包括肿瘤和肝脏 # 计算比例 tumor_ratio = tumor_voxels / total_voxels liver_ratio = liver_voxels / total_voxels # 如果任一比例超过阈值，返回False if tumor_ratio > self.max_tumor_ratio or liver_ratio > self.max_liver_ratio: return False return True def __call__(self, data): d = dict(data) # 继续原来的裁剪逻辑 random_state = np.random.RandomState(np.random.randint(1000)) pre_results = {'image.pre': d['image.pre'], 'label.pre': d['label.pre']} post_results = {'image.post': d['image.post'], 'label.post': d['label.post'], 'image.pre': d['image.pre'], 'label.pre': d['label.pre']} # 对 pre 数据进行裁剪 pre_cropper = RandCropByLabelClassesd( keys=["image.pre", "label.pre"], label_key="label.pre", spatial_size=self.spatial_size, ratios=self.ratios, num_classes=self.num_classes, num_samples=self.num_samples, image_key="image.pre", image_threshold=self.image_threshold ) pre_cropper._randomization = random_state pre_results = pre_cropper(pre_results) # 返回列表 # 对 post 数据进行裁剪 try: post_cropper = RandCropByLabelClassesd( keys=["image.post", "label.post"], label_key="label.post", spatial_size=self.spatial_size, ratios=self.ratios, num_classes=self.num_classes, num_samples=self.num_samples, image_key="image.post", image_threshold=self.image_threshold ) post_cropper._randomization = random_state post_results = post_cropper(post_results) except Exception as e: post_cropper = RandCropByLabelClassesd( keys=["image.post", "label.post"], label_key="label.pre", spatial_size=self.spatial_size, ratios=self.ratios, num_classes=self.num_classes, num_samples=self.num_samples, image_key="image.pre", image_threshold=self.image_threshold ) post_cropper._randomization = random_state post_results = post_cropper(post_results) # 创建结果列表 results = [] for i in range(self.num_samples): result = dict(d) # 创建新的字典，保留原始数据的其他字段 result.update({ "image.pre": pre_results[i]["image.pre"], "label.pre": pre_results[i]["label.pre"], "image.post": post_results[i]["image.post"], "label.post": post_results[i]["label.post"] }) results.append(result) return results class SeparateCenterTumorRandCropByLabelClassesd(SeparateRandCropByLabelClassesd): def __init__(self, center_ratio=0.6, min_bg_ratio=0.2, **kwargs): super().__init__(**kwargs) self.center_ratio = center_ratio self.min_bg_ratio = min_bg_ratio # 最小的非肿瘤区域比例 def get_center_crop(self, image, label, random_state, spatial_size, max_attempts=50): # 确保 label 是 PyTorch 张量用于计算 if isinstance(label, np.ndarray): label = torch.from_numpy(label) # 获取肿瘤区域中心点 tumor_indices = torch.nonzero((label == 2) | (label == 1)) if len(tumor_indices) == 0: return None center = torch.mean(tumor_indices.float(), dim=0) # 多次尝试找到合适的裁剪位置 for attempt in range(max_attempts): # 确保裁剪区域包含肿瘤中心 min_bound = [max(0, int(c - s//2)) for c, s in zip(center, spatial_size)] max_bound = [min(int(c + s//2), d) for c, s, d in zip(center, spatial_size, label.shape)] # 调整边界确保有效的裁剪范围 for i in range(len(min_bound)): # 确保裁剪区域不超过图像边界 if max_bound[i] - spatial_size[i] < 0: min_bound[i] = 0 max_bound[i] = spatial_size[i] elif max_bound[i] > label.shape[i]: max_bound[i] = label.shape[i] min_bound[i] = max(0, label.shape[i] - spatial_size[i]) # 确保有效的随机范围 if min_bound[i] > max_bound[i] - spatial_size[i]: min_bound[i] = max(0, max_bound[i] - spatial_size[i]) # 使用提供的随机状态选择裁剪起点 np.random.seed(random_state.randint(1234) + attempt) start_coords = [] for min_b, max_b, s in zip(min_bound, max_bound, spatial_size): valid_range = max_b - s - min_b + 1 if valid_range <= 0: start = min_b else: start = np.random.randint(min_b, min_b + valid_range) start_coords.append(start) # 执行裁剪 slices = [slice(s, s + sz) for s, sz in zip(start_coords, spatial_size)] cropped_label = label[slices] # 计算肿瘤区域比例 tumor_ratio = torch.sum((cropped_label == 1) | (cropped_label == 2)).item() / cropped_label.numel() # 如果非肿瘤区域比例足够大，接受这个裁剪 if (1 - tumor_ratio) >= self.min_bg_ratio: return { 'image': image[slices].copy() if isinstance(image, np.ndarray) else image[slices].numpy(), 'label': cropped_label.numpy() if isinstance(cropped_label, torch.Tensor) else cropped_label.copy() } # 如果多次尝试都找不到合适的裁剪，使用最后一次的结果 return { 'image': image[slices].copy() if isinstance(image, np.ndarray) else image[slices].numpy(), 'label': cropped_label.numpy() if isinstance(cropped_label, torch.Tensor) else cropped_label.copy() } def __call__(self, data): d = dict(data) # 设置相同的随机种子 random_state = np.random.RandomState(np.random.randint(1234)) # 处理 pre 数据 pre_result = self.get_center_crop( d["image.pre"], d["label.pre"], random_state, self.spatial_size ) # 处理 post 数据 post_result = self.get_center_crop( d["image.post"], d["label.post"], random_state, self.spatial_size ) # 如果任一结果为None，使用原始的随机裁剪 if pre_result is None or post_result is None: return super().__call__(d) # 合并结果 d["image.pre"] = pre_result['image'] d["label.pre"] = pre_result['label'] d["image.post"] = post_result['image'] d["label.post"] = post_result['label'] return d class Compose_Select(Compose): def __call__(self, input_): name = input_['name'] key = get_key(name) for index, _transform in enumerate(self.transforms): # for RandCropByPosNegLabeld and RandCropByLabelClassesd case if (key in ['10_03', '10_07', '10_08', '04']) and (index == 8): continue elif (key not in ['10_03', '10_07', '10_08', '04']) and (index == 9): continue # for RandZoomd case if (key not in ['10_03', '10_06', '10_07', '10_08', '10_09', '10_10']) and (index == 7): continue input_ = apply_transform(_transform, input_, self.map_items, self.unpack_items, self.log_stats) return input_ from itertools import cycle current_index = 0 # def choose_different_value(x, num_samples): # global current_index # num_texts = len(x["text"]) # if current_index >= num_samples: # current_index = 0 # current_choice = x["text"][current_index] # current_index = (current_index + 1) % num_texts # return {**x, "text": current_choice} def choose_different_value(x, num_samples): global current_index num_texts = len(x["text"]) # 处理空列表的情况 if num_texts == 0: return {**x, "text": ""} # 确保current_index不会超过实际文本数量 current_index = current_index % num_texts current_choice = x["text"][current_index] current_index = (current_index + 1) % num_texts return {**x, "text": current_choice} import random def get_loader(args): # 加载临床数据 clinical_data = load_clinical_data("/home/yyang303/project/Survival/data/HCC_clinical_data.csv") def check_shapes(stage): def _check_shapes(data): image = data['image.pre'] label = data['label.pre'] # post_image = data['post']['image'] # post_label = data['post']['label'] return data return _check_shapes train_transforms = Compose( [ LoadImageh5d(keys=["image.pre", "image.post", "label.pre", "label.post"]), Lambda(check_shapes("After LoadImageh5d")), AddChanneld(keys=["image.pre", "image.post", "label.pre", "label.post"]), Lambda(check_shapes("After AddChanneld")), Orientationd(keys=["image.pre", "image.post", "label.pre", "label.post"], axcodes="RAS"), Lambda(check_shapes("After Orientationd")), Spacingd( keys=["image.pre", "image.post", "label.pre", "label.post"], pixdim=(args.space_x, args.space_y, args.space_z), mode=("bilinear", "bilinear", "nearest", "nearest"), align_corners=True, ), Lambda(check_shapes("After Spacingd")), ScaleIntensityRanged( keys=["image.pre", "image.post"], a_min=args.a_min, a_max=args.a_max, b_min=args.b_min, b_max=args.b_max, clip=True, ), SpatialPadd( keys=["image.pre", "image.post", "label.pre", "label.post"], spatial_size=(args.roi_x, args.roi_y, args.roi_z), mode='constant' ), Lambda(check_shapes("After SpatialPadd")), RandCropByLabelClassesd( keys=["image.pre", "image.post", "label.pre", "label.post"], label_key="label.pre", spatial_size=(args.roi_x, args.roi_y, args.roi_z), ratios=[0, 0, 1], num_classes=3, num_samples=args.num_samples, image_key="image.pre", image_threshold=-1, # max_tumor_ratio=0.4, # 设置最大肿瘤占比为40% # max_liver_ratio=0.8, # 设置最大肝脏占比为80% ), Lambda(check_shapes("After SeparateCenterTumorRandCropByLabelClassesd")), RandRotate90d( keys=["image.pre", "image.post", "label.pre", "label.post"], prob=0.10, max_k=3, ), Lambda(check_shapes("After RandRotate90d")), Lambda(lambda x: choose_different_value(x, args.num_samples)), ToTensord(keys=["image.pre", "image.post", "label.pre", "label.post"]), ] ) val_transforms = Compose( [ LoadImageh5d(keys=["image.pre", "image.post", "label.pre", "label.post"]), AddChanneld(keys=["image.pre", "image.post", "label.pre", "label.post"]), Orientationd(keys=["image.pre", "image.post", "label.pre", "label.post"], axcodes="RAS"), Spacingd( keys=["image.pre", "image.post", "label.pre", "label.post"], pixdim=(args.space_x, args.space_y, args.space_z), mode=("bilinear", "bilinear", "nearest", "nearest"), ), ScaleIntensityRanged( keys=["image.pre", "image.post"], a_min=args.a_min, a_max=args.a_max, b_min=args.b_min, b_max=args.b_max, clip=True, ), # 先根据pre的肿瘤区域裁剪 CropForegroundd(keys=["image.pre", "image.post", "label.pre", "label.post"], source_key="image.pre"), RandCropByLabelClassesd( keys=["image.pre", "image.post", "label.pre", "label.post"], label_key="label.pre", spatial_size=(args.roi_x, args.roi_y, args.roi_z), ratios=[0.1, 0.1, 1], num_classes=3, num_samples=5, image_key="image.pre", image_threshold=-1, # center_ratio=0.6 ), Lambda(lambda x: choose_different_value(x,args.num_samples)), ToTensord(keys=["image.pre", "image.post", "label.pre", "label.post"]), ] ) # def load_data(file_path, root_path, label_root_path): # img_list = [] # lbl_list = [] # text_list = [] # name_list = [] # with open(file_path) as f: # for line in f: # parts = line.strip().split(maxsplit=2) # name = parts[1].split('.')[0] # img_list.append(root_path + parts[0]) # lbl_list.append(label_root_path + parts[1]) # text_descriptions = parts[2].split(' ' * 10) # text_descriptions = [desc.strip() for desc in text_descriptions if desc.strip()] # text_list.append(text_descriptions) # name_list.append(name) # return img_list, lbl_list, text_list, name_list def load_data(file_path, root_path, label_root_path): img_list = [] lbl_list = [] text_list = [] name_list = [] print(file_path) with open(file_path) as f: for line in f: parts = line.strip().split('\t') # if len(parts) == 1: # 如果没有制表符,则按多个空格分割 # parts = line.strip().split(' ') print(parts) name = parts[0].split('/')[1] + '_' + parts[0].split('/')[2].split('.')[0].split('_')[-1] # 只存储路径 img_list.append([root_path + parts[0], root_path + parts[4]]) lbl_list.append([label_root_path + parts[1], label_root_path + parts[5]]) # 保持完整的治疗方案描述 text_descriptions = parts[-4].strip() text_list.append([text_descriptions]) # 用列表包装，保持数据结构一致性 name_list.append(name) return img_list, lbl_list, text_list, name_list def load_data_val(file_path, root_path, label_root_path): img_list = [] lbl_list = [] text_list = [] name_list = [] with open(file_path) as f: for line in f: parts = line.strip().split(maxsplit=8) name = parts[0].split('/')[1] # 只存储路径 img_list.append(root_path + parts[0]) lbl_list.append(label_root_path + parts[1]) # 保持完整的治疗方案描述 text_descriptions = parts[-1].strip() text_list.append([text_descriptions]) # 用列表包装，保持数据结构一致性 name_list.append(name) return img_list, lbl_list, text_list, name_list if args.phase == 'train': train_img, train_lbl, train_text, train_name = [], [], [], [] for item in args.dataset_list: img, lbl, text, name = load_data(os.path.join(args.data_txt_path, item, f'train_paired_all_hcc_under_50_new.txt'), args.data_root_path, args.label_root_path) train_img.extend(img) train_lbl.extend(lbl) train_text.extend(text) train_name.extend(name) # print("a",train_img) # print("b",train_lbl) # print("c",train_text) # print("d",train_name) data_dicts_train = [ { 'image.pre': pre_img, 'image.post': post_img, 'label.pre': pre_lbl, 'label.post': post_lbl, 'name': name, 'text': text, 'clinical_info': torch.tensor(list(clinical_data.get(name, { 'sex': 0.0, 'age': 0.0, 'HBV': 0.0, 'AFP': 0.0, 'albumin': 0.0, 'bilirubin': 0.0, 'child': 0.0, 'BCLC': 0.0, 'numoflesions': 0.0, 'diameter': 0.0, 'VI': 0.0 }).values()), dtype=torch.float32) } for (pre_img, post_img), (pre_lbl, post_lbl), name, text in zip(train_img, train_lbl, train_name, train_text) ] print('train len {}'.format(len(data_dicts_train))) if args.cache_dataset: if args.uniform_sample: train_dataset = UniformCacheDataset(data=data_dicts_train, transform=train_transforms, cache_rate=args.cache_rate, datasetkey=args.datasetkey) else: train_dataset = CacheDataset(data=data_dicts_train, transform=train_transforms, cache_rate=args.cache_rate) else: if args.uniform_sample: train_dataset = UniformDataset(data=data_dicts_train, transform=train_transforms, datasetkey=args.datasetkey) else: train_dataset = Dataset(data=data_dicts_train, transform=train_transforms) train_sampler = DistributedSampler(dataset=train_dataset, even_divisible=True, shuffle=True) if args.dist else None print(args.batch_size) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.num_workers, collate_fn=list_data_collate, sampler=train_sampler) return train_loader, train_sampler, len(train_dataset) if args.phase == 'validation': val_img, val_lbl, val_text, val_name = [], [], [], [] for item in args.dataset_list: img, lbl, text, name = load_data(os.path.join(args.data_txt_path, item, 'val_paired_all_hcc_under_50_new.txt'), args.data_root_path, args.label_root_path) val_img.extend(img) val_lbl.extend(lbl) val_text.extend(text) val_name.extend(name) data_dicts_val = [ { 'image.pre': pre_img, 'image.post': post_img, 'label.pre': pre_lbl, 'label.post': post_lbl, 'name': name, 'text': text, 'clinical_info': torch.tensor(list(clinical_data.get(name, { 'sex': 0.0, 'age': 0.0, 'HBV': 0.0, 'AFP': 0.0, 'albumin': 0.0, 'bilirubin': 0.0, 'child': 0.0, 'BCLC': 0.0, 'numoflesions': 0.0, 'diameter': 0.0, 'VI': 0.0 }).values()), dtype=torch.float32) } for (pre_img, post_img), (pre_lbl, post_lbl), name, text in zip(val_img, val_lbl, val_name, val_text) ] print('val len {}'.format(len(data_dicts_val))) if args.cache_dataset: val_dataset = CacheDataset(data=data_dicts_val, transform=val_transforms, cache_rate=args.cache_rate) else: val_dataset = Dataset(data=data_dicts_val, transform=val_transforms) val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=4, collate_fn=list_data_collate) return val_loader, val_transforms, len(val_dataset) def get_key(name): dataset_index = int(name[0:2]) if dataset_index == 10: template_key = name[0:2] + '_' + name[17:19] else: template_key = name[0:2] return template_key def load_clinical_data(clinical_data_path): """ 读取并处理患者的临床数据 Args: clinical_data_path: CSV文件的路径 Returns: clinical_data: 包含患者临床信息的字典，以患者ID为键 """ # 读取CSV文件，设置ID列的类型为int import pandas as pd df = pd.read_csv(clinical_data_path, dtype={'ID': str}) # 定义需要使用的clinical features clinical_features = ['sex', 'age', 'HBV', 'AFP', 'albumin', 'bilirubin', 'child', 'BCLC', 'numoflesions', 'diameter', 'VI'] # 处理分类变量 df['child'] = df['child'].map({'A': 0, 'B': 1}) df['BCLC'] = df['BCLC'].map({'A': 0, 'B': 1, 'C': 2}) # 处理可能的缺失值 df = df.fillna({ 'sex': df['sex'].mode()[0], 'age': df['age'].mean(), 'HBV': df['HBV'].mode()[0], 'AFP': df['AFP'].mean(), 'albumin': df['albumin'].mean(), 'bilirubin': df['bilirubin'].mean(), 'child': df['child'].mode()[0], 'BCLC': df['BCLC'].mode()[0], 'numoflesions': df['numoflesions'].mean(), 'diameter': df['diameter'].mean(), 'VI': df['VI'].mode()[0] }) # 将DataFrame转换为字典格式 clinical_data = {} for _, row in df.iterrows(): patient_id = str(row['ID']) # 确保ID是字符串格式 clinical_info = { 'sex': float(row['sex']), # 确保所有值都是float类型 'age': float(row['age']), 'HBV': float(row['HBV']), 'AFP': float(row['AFP']), 'albumin': float(row['albumin']), 'bilirubin': float(row['bilirubin']), 'child': float(row['child']), 'BCLC': float(row['BCLC']), 'numoflesions': float(row['numoflesions']), 'diameter': float(row['diameter']), 'VI': float(row['VI']) } clinical_data[patient_id] = clinical_info return clinical_data if __name__ == "__main__": train_loader, test_loader = partial_label_dataloader() for index, item in enumerate(test_loader): print(item['image'].shape, item['label'].shape, item['task_id']) input()