| import numpy as np |
| import random |
| import torch |
| from torch.utils.data import Dataset |
| from torchvision.transforms import v2 |
|
|
| class custom_dataset(Dataset): |
| def __init__(self, file_list, label_list, data_types_list, norm_dict, norm=True, time_size=243, augment=False, flipping=0.5, noise=0.5, noise_max_amp=0.1, zooming=0.5, zoom_min_max=[0.7, 1.0], cropping=0.5, intensity_mul=0.5, intensity_min_max=[0.8, 1.2], ret_y_type=torch.long): |
| self.use_norm = norm |
| self.time_size = time_size |
| self.norm_dict = norm_dict |
| self.files = file_list |
| self.labels = label_list |
| self.data_types = data_types_list |
| self.indices = np.arange(len(self.files)).astype(int) |
| self.augment = augment |
| self.flipping = flipping |
| self.noise = noise |
| self.noise_max_amp = noise_max_amp |
| self.zooming = zooming |
| self.zoom_min_max = zoom_min_max |
| self.cropping = cropping |
| self.intensity_mul = intensity_mul |
| self.intensity_min_max = intensity_min_max |
| self.ret_y_type = ret_y_type |
|
|
| def __getitem__(self, item: int): |
| cur_dtype = self.data_types[item] |
| cur_y_data = self.labels[item] |
| if cur_dtype <= 1: |
| cur_x_data = np.load(self.files[item]) |
| if self.use_norm: |
| cur_x_data -= self.norm_dict[cur_dtype][0] |
| cur_x_data /= self.norm_dict[cur_dtype][1] |
| if self.augment: |
| cur_x_data, zz, zs, org_size = augment_data(cur_x_data, flipping=self.flipping, noise=self.noise, noise_max_amp=self.noise_max_amp, zooming=self.zooming, zoom_min_max=self.zoom_min_max, cropping=self.cropping, intensity_mul=self.intensity_mul, intensity_min_max=self.intensity_min_max) |
| cur_x_data = torch.from_numpy(np.repeat(cur_x_data[None, :, :], 3, axis=0).astype("float32")) |
| if zz is not None: |
| cur_x_data = v2.Resize(size=org_size)(cur_x_data[:, zs[0]: zs[0] + zz[0], zs[1]: zs[1] + zz[1]]) |
| return cur_x_data, torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| return torch.from_numpy(np.repeat(cur_x_data[None, :, :], 3, axis=0).astype("float32")), torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| elif cur_dtype == 2 or cur_dtype == 3: |
| cur_x_data = (np.load(self.files[item])[:, 256:-256]).transpose((1, 0)) |
| if self.use_norm: |
| cur_x_data -= self.norm_dict[cur_dtype][0] |
| cur_x_data /= self.norm_dict[cur_dtype][1] |
| if len(cur_x_data[0]) != 34: |
| cur_x_data = np.concatenate([np.tile(cur_x_data, (1, 7)), cur_x_data[:, :5], np.zeros((512, 21))], axis=1) |
| else: |
| cur_x_data = np.concatenate([np.tile(cur_x_data, (1, 7)), cur_x_data[:, :5]], axis=1) |
| if self.augment: |
| cur_x_data, zz, zs, org_size = augment_data(cur_x_data, flipping=self.flipping, noise=self.noise, noise_max_amp=self.noise_max_amp, zooming=self.zooming, zoom_min_max=self.zoom_min_max, cropping=self.cropping, intensity_mul=self.intensity_mul, intensity_min_max=self.intensity_min_max) |
| cur_x_data = torch.from_numpy(np.repeat(cur_x_data[None, :, :], 3, axis=0).astype("float32")) |
| if zz is not None: |
| cur_x_data = v2.Resize(size=org_size)(cur_x_data[:, zs[0]: zs[0] + zz[0], zs[1]: zs[1] + zz[1]]) |
| return cur_x_data, torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| return torch.from_numpy(np.repeat(cur_x_data[None, :, :], 3, axis=0).astype("float32")), torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| elif cur_dtype == 4: |
| cur_x_data = np.load(self.files[item])[:, :243] |
| if self.use_norm: |
| cur_x_data -= self.norm_dict[cur_dtype][0] |
| cur_x_data /= self.norm_dict[cur_dtype][1] |
| if self.augment: |
| cur_x_data, zz, zs, org_size = augment_data(cur_x_data, flipping=self.flipping, noise=self.noise, noise_max_amp=self.noise_max_amp, zooming=self.zooming, zoom_min_max=self.zoom_min_max, cropping=self.cropping, intensity_mul=self.intensity_mul, intensity_min_max=self.intensity_min_max) |
| cur_x_data = torch.from_numpy(np.repeat(cur_x_data[None, :, :], 3, axis=0).astype("float32")) |
| if zz is not None: |
| cur_x_data = v2.Resize(size=org_size)(cur_x_data[:, zs[0]: zs[0] + zz[0], zs[1]: zs[1] + zz[1]]) |
| return cur_x_data, torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| return torch.from_numpy(np.repeat(cur_x_data[None, :, :], 3, axis=0).astype("float32")), torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| else: |
| cur_x_data = np.load(self.files[item]).astype("float") |
| if self.use_norm: |
| cur_x_data -= self.norm_dict[cur_dtype][0] |
| cur_x_data /= self.norm_dict[cur_dtype][1] |
| if self.augment: |
| cur_x_data, zz, zs, org_size = augment_data(cur_x_data, flipping=self.flipping, noise=self.noise, noise_max_amp=self.noise_max_amp, zooming=self.zooming, zoom_min_max=self.zoom_min_max, cropping=self.cropping, intensity_mul=self.intensity_mul, intensity_min_max=self.intensity_min_max) |
| cur_x_data = torch.from_numpy(cur_x_data.transpose((2, 0, 1)).astype("float32")) |
| if zz is not None: |
| cur_x_data = v2.Resize(size=org_size)(cur_x_data[:, zs[0]: zs[0] + zz[0], zs[1]: zs[1] + zz[1]]) |
| return cur_x_data, torch.tensor(cur_y_data, dtype=self.ret_y_type) |
| return torch.from_numpy(cur_x_data.transpose((2, 0, 1)).astype("float32")), torch.tensor(cur_y_data, dtype=self.ret_y_type) |
|
|
| def __len__(self) -> int: |
| return len(self.labels) |
|
|
| def pseudo_labeling(all_preds, itr, temp_nl=2, kappa_n=0.005, kappa_p=0.05, tau_n=0.05, tau_p=0.70, class_blnc=1, num_classes=9): |
| all_preds_edit = all_preds - np.max(all_preds, axis=2)[:, :, None] |
| preds_softmax = np.exp(all_preds_edit)/np.sum(np.exp(all_preds_edit), axis=2)[:, :, None] |
| preds_softmax_neg = np.exp(all_preds_edit/temp_nl)/np.sum(np.exp(all_preds_edit/temp_nl), axis=2)[:, :, None] |
| preds_std = np.std(preds_softmax, axis=0) |
| preds_std_neg = np.std(preds_softmax_neg, axis=0) |
| preds_softmax = np.mean(preds_softmax, axis=0) |
| preds_softmax_neg = np.mean(preds_softmax_neg, axis=0) |
| max_value = np.max(preds_softmax, axis=1) |
| max_idx = np.argmax(preds_softmax, axis=1) |
| max_std = preds_std[np.arange(len(preds_std)), max_idx] |
| nl_mask = ((preds_std_neg < kappa_n) * (preds_softmax_neg < tau_n)) * 1 |
| for enum, item in enumerate(max_idx): |
| nl_mask[enum, item] = 0 |
| selected_idx = (max_value >= tau_p) * (max_std < kappa_p) |
| pseudo_maxstd = max_std[selected_idx] |
| pseudo_target = max_idx[selected_idx] |
| pseudo_idx = np.where(selected_idx)[0].tolist() |
| if itr < class_blnc - 1: |
| min_count = 5000000 |
| for class_idx in range(num_classes): |
| class_len = len(np.where(pseudo_target==class_idx)[0]) |
| if class_len < min_count: |
| min_count = class_len |
| min_count = max(25, min_count) |
| blnc_idx_list = [] |
| for class_idx in range(num_classes): |
| current_class_idx = np.where(pseudo_target==class_idx) |
| if len(np.where(pseudo_target==class_idx)[0]) > 0: |
| current_class_maxstd = pseudo_maxstd[current_class_idx] |
| sorted_maxstd_idx = np.argsort(current_class_maxstd) |
| current_class_idx = current_class_idx[0][sorted_maxstd_idx[:min_count]] |
| blnc_idx_list.extend(current_class_idx) |
| blnc_idx_list = np.array(blnc_idx_list) |
| pseudo_target = pseudo_target[blnc_idx_list] |
| pseudo_idx = pseudo_idx[blnc_idx_list] |
| pseudo_nl_mask = [] |
| pseudo_nl_idx = [] |
| for i in range(len(preds_softmax)): |
| if i not in pseudo_idx and sum(nl_mask[i]) > 0: |
| pseudo_nl_mask.append(nl_mask[i]) |
| pseudo_nl_idx.append(i) |
| pseudo_nl_mask = np.array(pseudo_nl_mask) |
| return pseudo_idx, pseudo_target, pseudo_nl_idx, pseudo_nl_mask |
|
|
| def get_dataset(data_files, norm_dict, norm=True, time_size=243, class_limit=-1): |
| print("Files: ", data_files) |
| dp_base = "../" |
| file_list = [] |
| label_list = [] |
| data_types_list = [] |
| for data_file in data_files: |
| class_counts = np.zeros(9) |
| cd_type = int(data_file.split("_")[-2]) |
| with open(data_file, "r") as f: |
| data_info = f.readlines() |
| data_info = np.array([x.split("\n")[0].split("\t") for x in data_info]) |
| x_files = [] |
| y_labels = [] |
| for x in data_info: |
| cur_y_lab = int(x[1]) |
| if class_limit != -1 and class_counts[cur_y_lab] >= class_limit: |
| continue |
| class_counts[cur_y_lab] += 1 |
| x_files.append(dp_base + x[0]) |
| y_labels.append(cur_y_lab) |
| file_list.extend(x_files) |
| label_list.extend(y_labels) |
| data_types_list.extend([cd_type] * len(x_files)) |
| return custom_dataset(file_list, label_list, data_types_list, norm_dict, norm=norm, time_size=time_size) |
|
|
| def get_dataset_files(data_files, norm_dict, norm=False, time_size=243, augment=False, flipping=0.5, noise=0.5, noise_max_amp=0.1, zooming=0.5, zoom_min_max=[0.7, 1.0], cropping=0.5, intensity_mul=0.5, intensity_min_max=[0.8, 1.2]): |
| return custom_dataset([x[0] for x in data_files], [x[1] for x in data_files], [x[2] for x in data_files], norm_dict, norm=norm, time_size=time_size, augment=augment, flipping=flipping, noise=noise, noise_max_amp=noise_max_amp, zooming=zooming, zoom_min_max=zoom_min_max, cropping=cropping, intensity_mul=intensity_mul, intensity_min_max=intensity_min_max) |
|
|
| def get_dataset_files_neg(data_files, norm_dict, norm=False, time_size=243, augment=False, flipping=0.5, noise=0.5, noise_max_amp=0.1, zooming=0.5, zoom_min_max=[0.7, 1.0], cropping=0.5, intensity_mul=0.5, intensity_min_max=[0.8, 1.2]): |
| return custom_dataset([x[0] for x in data_files], [x[1] for x in data_files], [x[2] for x in data_files], norm_dict, norm=norm, time_size=time_size, augment=augment, flipping=flipping, noise=noise, noise_max_amp=noise_max_amp, zooming=zooming, zoom_min_max=zoom_min_max, cropping=cropping, intensity_mul=intensity_mul, intensity_min_max=intensity_min_max, ret_y_type=torch.float32) |
|
|
| def get_lab_unlab(data_files, class_limit=-1, random_seed=0, labeled_perc=0.1, grouped_shuffle=1): |
| print("Files: ", data_files) |
| dp_base = "../" |
| labeled_list = [] |
| unlabeled_list = [] |
| for data_file in data_files: |
| class_counts = np.zeros(9) |
| cd_type = int(data_file.split("_")[-2]) |
| with open(data_file, "r") as f: |
| data_info = f.readlines() |
| data_info = np.array([x.split("\n")[0].split("\t") for x in data_info]) |
| x_files = [] |
| y_labels = [] |
| for x in data_info: |
| cur_y_lab = int(x[1]) |
| if class_limit != -1 and class_counts[cur_y_lab] >= class_limit: |
| continue |
| class_counts[cur_y_lab] += 1 |
| x_files.append(dp_base + x[0]) |
| y_labels.append(cur_y_lab) |
| comb_list = [[x_files[ci], y_labels[ci], cd_type] for ci in range(len(x_files))] |
| if grouped_shuffle != 1: |
| comb_list_inds = np.arange(int(len(comb_list) / grouped_shuffle)) |
| else: |
| comb_list_inds = np.arange(len(comb_list)) |
| random.Random(random_seed).shuffle(comb_list_inds) |
| labeled_count = (class_counts * labeled_perc + 1).astype(int) |
| cur_class_counts = np.zeros(9) |
| for ci, cli in enumerate(comb_list_inds): |
| if grouped_shuffle != 1: |
| cl = comb_list[cli * grouped_shuffle] |
| else: |
| cl = comb_list[cli] |
| cur_class = cl[1] |
| if cur_class_counts[cur_class] < labeled_count[cur_class]: |
| if grouped_shuffle != 1: |
| labeled_list.extend([cl for cl in comb_list[cli * grouped_shuffle: (cli + 1) * grouped_shuffle]]) |
| else: |
| labeled_list.append(cl) |
| else: |
| if grouped_shuffle != 1: |
| unlabeled_list.extend([cl for cl in comb_list[cli * grouped_shuffle: (cli + 1) * grouped_shuffle]]) |
| else: |
| unlabeled_list.append(cl) |
| if grouped_shuffle != 1: |
| cur_class_counts[cur_class] += grouped_shuffle |
| else: |
| cur_class_counts[cur_class] += 1 |
| return labeled_list, unlabeled_list |
| |
|
|
| def get_pseudo_labels(all_preds, threshold): |
| all_preds_edit = all_preds - np.max(all_preds, axis=2)[:, :, None] |
| preds_softmax = np.exp(all_preds_edit)/np.sum(np.exp(all_preds_edit), axis=2)[:, :, None] |
| preds_argmax = np.argmax(all_preds_edit, axis=-1) |
| preds_mean = np.mean(preds_softmax, axis=0) |
| mask = np.ones(preds_argmax[0].shape).astype(bool) |
| for mi in range(1, len(all_preds_edit)): |
| mask = mask * (preds_argmax[0] == preds_argmax[mi]) |
| preds_mean_arg = np.array([preds_mean[i, x] for i, x in enumerate(preds_argmax[0])]) |
| mask_thresh = preds_mean_arg > threshold |
| ret_inds = np.where(mask * mask_thresh)[0] |
| return np.array([[r, preds_argmax[0, r]] for r in ret_inds]) |
|
|
|
|
| def augment_data(data_in, flipping=0.5, noise=0.5, noise_max_amp=0.1, zooming=0.5, zoom_min_max=[0.7, 1.0], cropping=0.5, intensity_mul=0.5, intensity_min_max=[0.8, 1.2]): |
| yx_shape = data_in.shape |
| flip = np.random.random() < flipping |
| if flip: |
| flip_type = np.random.randint(1, 4) |
| if flip_type == 1: |
| data_in = data_in[:, ::-1] |
| elif flip_type == 2: |
| data_in = data_in[:, ::-1] |
| else: |
| data_in = data_in[::-1, ::-1] |
| add_noise = np.random.random() < noise |
| if add_noise: |
| data_in += (np.random.random(size=yx_shape) * 2 - 1) * noise_max_amp |
| mult_intensity = np.random.random() < intensity_mul |
| if mult_intensity: |
| data_in *= (np.random.random() * (intensity_min_max[1] - intensity_min_max[0]) + intensity_min_max[0]) |
| data_in[data_in < 0] = 0.0 |
| data_in[data_in > 1] = 1.0 |
| zoom = np.random.random() < zooming |
| crop = np.random.random() < cropping |
| if zoom or crop: |
| zoom_xy = ((np.random.random(2) * (zoom_min_max[1] - zoom_min_max[0]) + zoom_min_max[0]) * yx_shape[:2]).astype(int) |
| zoom_starts = (np.random.random(2) * (yx_shape[:2] - zoom_xy)).astype(int) |
| else: |
| zoom_xy = None |
| zoom_starts = None |
| if not zoom and crop: |
| crop_mask = np.zeros(yx_shape) |
| crop_mask[zoom_starts[0]: zoom_starts[0] + zoom_xy[0], zoom_starts[1]: zoom_starts[1] + zoom_xy[1]] = 1.0 |
| data_in *= crop_mask |
| zoom_xy = None |
| zoom_starts = None |
| return data_in, zoom_xy, zoom_starts, yx_shape[:2] |
|
|
|
|
