def __getitem__(self, index): index += self.shift data = [] try: data = self.hdf5_dataset['%010.d' % (index + 1)].value.astype('float32') except KeyError as e: logger.warn("Didn't find key %010.d in the hdf5 file." % (index + 1)) data = np.zeros((3, 128, 192), dtype='float32') data = cv2.resize(data.transpose((1, 2, 0)), (192, 128)).transpose( (2, 0, 1)) if not self.rgb: data = data[1, :, :][np.newaxis, :, :] data = data.transpose((0, 2, 1)) if data is not None: target = self.y[index].astype('float32') else: logger.warn("Didn't find key %010.d in the hdf5 file." % (index + 1)) target = np.array([0.0]).astype('float32') return data, target / 60.0
def reshape_EOG_data(data): Fs = 50 # data = [batch_size, 2, 1500] # it should be [seq_len, batch_size, x_dim] # 1: swap batch size to pos 1 data = torch.from_numpy(data) data = Variable(data.transpose(0, 1)) # 2: retain just left EOG data = data[0] # now data = [batchsize, x_dim] # 3: rearrange in 1 second segments (Fs=50 samples) as seq len # so that we finally have [30, batchsize, Fs] data = data.reshape(data.shape[0], -1, Fs) data = data.transpose(0, 1) # data = (data - data.min().item()) / (data.max().item() - data.min().item()) return data
def transform_tr(self, sample): composed_transforms = transforms.Compose([ tr.RandomHorizontalFlip(), #tr.RandomScaleCrop(base_size=self.args.base_size, crop_size=self.args.crop_size, fill=255), #tr.FixScaleCrop(crop_size=self.args.crop_size), #tr.FixedResize(size=self.args.crop_size), #tr.RandomGaussianBlur(), tr.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ]) img = composed_transforms(sample) data = img['image'] label = img['label'] p = np.random.rand(1)[0] if p < 0.25: data = np.rot90(data, 1, (0, 1)).copy() label = np.rot90(label, 1, (0, 1)).copy() elif p >= 0.25 and p < 0.5: data = np.rot90(data, 2, (0, 1)).copy() label = np.rot90(label, 2, (0, 1)).copy() elif p >= 0.5 and p < 0.75: data = np.rot90(data, 3, (0, 1)).copy() label = np.rot90(label, 3, (0, 1)).copy() data = torch.from_numpy(data.transpose(2, 0, 1)) label = torch.from_numpy(label) return {'image': data, 'label': label}
def __getitem__(self, index): sample = self.imgs[index] if self.phase == 'train': splits = sample.split('/', 7)[-1] #分割6次,可变 label = int(splits.split('_')[0]) img_path = sample data = Image.open(img_path).convert('RGB') # data = amaugimg(data) data = self.transforms(data) return data, label else: #对于测试 data = Image.open(sample) data = data.convert('RGB') img1 = data #原图 img2 = data.transpose(Image.FLIP_LEFT_RIGHT) #水平反转图 data = data.convert('L') #灰度图 img3 = cv2.cvtColor(np.asarray(data), cv2.COLOR_RGB2BGR) img3 = Image.fromarray(cv2.cvtColor(img3, cv2.COLOR_BGR2RGB)) img4 = img3.transpose(Image.FLIP_LEFT_RIGHT) #灰度反转 img1 = self.transforms(img1) img2 = self.transforms(img2) img3 = self.transforms(img3) img4 = self.transforms(img4) return img1, img2
def __getitem__(self,index): ''' this is for dng and dng training dalong : Transfer all the data to the same format and the same folder structure input are in $root/input/*.dng; groundtruths are in $root/groundtruth/*.dng here all raw images are scaled to 0-1 in preprocess processdure ''' input_path = os.path.join(self.root,'input'); input_path = os.path.join(input_path,self.pathlist[index][:-1]); gt_path = os.path.join(self.root,'groundtruth'); gt_path = os.path.join(gt_path,self.pathlist[index][:-1]); raw = self.raw_loader(input_path); data = self.loader(gt_path); raw = pack_raw(raw,self.args); if self.Random : raw,data = RandomCrop(self.size,raw,data); raw,data = RandomFLipH(raw,data); raw,data = RandomFlipV(raw,data); raw,data = RandomTranspose(raw,data); # raw and data should be scaled to 0-1 raw = torch.FloatTensor(raw.transpose(2,0,1)); data = torch.FloatTensor(data.transpose(2,0,1)); return raw,data;
def get_mean_map(self): data = self.data N, C, T, V, M = data.shape self.mean_map = data.mean(axis=2, keepdims=True).mean( axis=4, keepdims=True).mean(axis=0) self.std_map = data.transpose((0, 2, 4, 1, 3)).reshape( (N * T * M, C * V)).std(axis=0).reshape((C, 1, V, 1))
def _to_tensor(data,transpose_data1d=False): if(len(data.shape)==2 and transpose_data1d is True):#swap channel and time axis for direct application of pytorch's 1d convs data = data.transpose((1,0)) if(isinstance(data,np.ndarray)): return torch.from_numpy(data) else:#default_collate will take care of it return data
def reshape(self, data, label, labels=None): assert data.shape[0] == label.shape[0] sequence_length = self.sequence_length n_chunks = data.shape[1] // sequence_length data = data[:, :n_chunks * sequence_length, :] data = data.reshape(data.shape[0], -1, sequence_length, data.shape[2]) data = np.concatenate(data.transpose(1, 0, 2, 3), axis=0) data = torch.Tensor(data).float() labels_reshaped = None # labels if not self.mse: label = np.repeat(label, n_chunks).reshape(label.shape[0], -1) label = np.concatenate(np.transpose(label)) label = np.repeat(label, sequence_length).reshape(-1, sequence_length) label = torch.Tensor(label).long() else: label = label[:, :n_chunks * sequence_length, :] label = label.reshape(label.shape[0], -1, sequence_length, label.shape[2]) label = np.concatenate(label.transpose(1, 0, 2, 3), axis=0) label = torch.Tensor(label).float() # labels = np.repeat(labels, n_chunks).reshape(labels.shape[0], -1) # labels = np.concatenate(np.transpose(labels)) # labels = np.repeat(labels, sequence_length).reshape(-1, sequence_length) # labels_reshaped = torch.Tensor(labels).long() return data, label
def train(epoch): train_loss = 0 cum_num_train = 0 loghatlist = [] iwaelist = [] for batch_idx, (data, _, lengths) in enumerate(train_loader): max_length = lengths.max() data = data.transpose(0, 1) # (num_seq, batch_size, num_notes) # data = data[:max_length] mask = generate_seq_mask(lengths, data.shape[0], data.shape[1]) # rescale data # data = (data - data.min()) / (data.max() - data.min()) #forward + backward + optimize optimizer.zero_grad() # kld_loss, nll_loss, _, _ = model(data, mask) # loss = kld_loss + nll_loss with torch.autograd.set_detect_anomaly(True): fivo_loss, logphat_total, _, kl, iwae_bound = model( data, mask, num_particles) loss = fivo_loss loss.backward() optimizer.step() logp_per_timestep = logphat_total / lengths iwae_bound_per_t = iwae_bound / lengths mean_logp_per_timestep = logp_per_timestep.mean().item() mean_iwae = iwae_bound_per_t.mean().item() # grad norm clipping, only in pytorch version >= 1.10 nn.utils.clip_grad_norm_(model.parameters(), clip) for i, loghat_ in enumerate(logp_per_timestep): loghatlist.append(loghat_.item()) iwaelist.append(iwae_bound_per_t[i].item()) #printing if batch_idx % print_every == 0: print( 'Train Epoch: {} [{}/{} ({:.0f}%)]\t Sequence LL: {:.6f} KL: {:.6f} timestep LL : {:.6f}, timestep IWAE : {:.6f}' .format(epoch, batch_idx * batch_size, len(train_loader.dataset), 100. * batch_idx / len(train_loader), -loss.item() / data.size(1), kl.mean(), mean_logp_per_timestep, mean_iwae)) train_loss += loss.item() cum_num_train += data.size(1) avg_train_loss = train_loss / cum_num_train print( '====> Epoch: {} Average LL per sequence: {:.4f}, Average LL per timestep: {:.4f}, IWAE per timestep : {:.6f}' .format(epoch, -avg_train_loss, np.mean(loghatlist), np.mean(iwaelist))) if USEWANDB: wandb.log({'train_FIVO(4)_t': np.mean(loghatlist)}, step=epoch) wandb.log({'train_IWAE(4)_t': np.mean(loghatlist)}, step=epoch) wandb.log({'train_KL': kl.mean()}, step=epoch)
def get_mean_std(data_path, input_size, rgb): tform = [] tform.append(transforms.Resize(size=input_size)) if not rgb: tform.append(transforms.Grayscale()) tform.append(transforms.ToTensor()) tform = transforms.Compose(tform) dset = datasets.ImageFolder(root=data_path, transform=tform) train_loader = DataLoader(dataset=dset, batch_size=50) scaler = StandardScaler(with_mean=True, with_std=True) print('Computing pixel mean and stdev...') for idx, (data, labels) in enumerate(train_loader): if idx % 20 == 0: print("Batch {:d} / {:d}".format(idx, len(train_loader))) data = data.numpy() n_channels = data.shape[1] # reshape into [n_pixels x 3] data = data.transpose((0, 2, 3, 1)).reshape((-1, n_channels)) # pass batch to incremental mean and stdev calculator scaler.partial_fit(data) print('Done, mean = ') pixel_mean = scaler.mean_ pixel_std = scaler.scale_ print(pixel_mean) print('std = ') print(pixel_std) return pixel_mean, pixel_std
def collate_fn(data): data.sort(key=lambda x: len(x[0]), reverse=True) # seperate source and target sequences data, labels, vocab_sizes, label_unk_idx = zip(*data) vocab_size = vocab_sizes[0] label_unk_idx = label_unk_idx[0] def merge(sequences): lengths = [len(seq) for seq in sequences] padded_seqs = torch.ones(len(sequences), max(lengths)).long() * vocab_size for i, seq in enumerate(sequences): end = lengths[i] padded_seqs[i, :end] = seq[:end] return padded_seqs, lengths def merge_labels(sequences): lengths = [len(seq) for seq in sequences] padded_seqs = torch.ones(len(sequences), max(lengths)).long() * label_unk_idx for i, seq in enumerate(sequences): end = lengths[i] padded_seqs[i, :end] = seq[:end] return padded_seqs, lengths # merge sequences (from tuple of 1D tensor to 2D tensor) data, data_lengths = merge(data) labels, label_lengths = merge_labels(labels) data = data.transpose(1, 0) labels = labels.transpose(1, 0) if USE_CUDA: data = data.cuda() labels = labels.cuda() return data, data_lengths, labels, label_lengths
def xunlian(): datasets = myBertDatasets() dataloader = torch.utils.data.DataLoader(datasets, batch_size=BATCH_SIZE, shuffle=True) deepcluster = DeepCluster().to(device) loss_func1 = nn.MSELoss() loss_func2 = nn.KLDivLoss(reduction='batchmean') optimizer = torch.optim.Adam(deepcluster.parameters(), lr=LR) # schedule = torch.optim.lr_scheduler.StepLR(optimizer=optimizer, step_size=1, gamma=0.85) for epoch in np.arange(EPOCH): for step, data in enumerate(dataloader): data = data.transpose(1, 0).to(device) _, masked_indices, pre_masked_indices, Q, P = deepcluster(data) loss1 = loss_func1(pre_masked_indices, masked_indices) loss2 = loss_func2(Q, P) loss = 0.4 * loss1 + 0.6 * loss2 optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 10 == 0 and step % 20 == 0: print( f'epoch:{epoch} | step:{step} | loss1={loss1} loss2={loss2} --- loss={loss}' ) # schedule.step() torch.save( deepcluster.state_dict(), fr'D:\SJTU\Study\MME_Lab\Teacher_Lu\click_number\EEG词袋模型\模型\{name}-deepcluster.pt' )
def __init__(self, root='./data', train=True, transform=None): self.T = transform dataset = root.split('/')[-1] if train: if dataset == 'cifar10': data_list = ['data_batch_%d'%(i+1) for i in range(5)] elif dataset == 'cifar100': data_list = ['train'] else: if dataset == 'cifar10': data_list = ['test_batch'] elif dataset == 'cifar100': data_list = ['test'] self.data = [] self.label = [] for filename in data_list: filepath = os.path.join(os.path.join(root,filename)) with open(filepath, 'rb') as f: entry = pickle.load(f,encoding='latin1') self.data.append(entry['data']) if 'labels' in entry: self.label.extend(entry['labels']) else: self.label.extend(entry['fine_labels']) data = np.vstack(self.data).reshape(-1,3,32,32) self.images = data.transpose((0,2,3,1)) #NHWC self.labels = np.array(self.label)
def MirrorSymmetricTransform(data, padding): print('padding:', padding) if padding <= 0: return data c, w, h = data.shape if min([w, h, c]) != c: data = data.transpose(2, 0, 1) c, w, h = data.shape assert padding < h and padding < w, "w: {}, h: {}, padding: {}".format( w, h, padding) res = np.zeros((c, w + 2 * padding, h + 2 * padding)) res[:, 0:padding, 0:padding] = np.flip(data[:, 0:padding, 0:padding], axis=(1, 2)) res[:, 0:padding, padding:-padding] = np.flip(data[:, 0:padding, :], axis=1) res[:, 0:padding, -padding:] = np.flip(data[:, 0:padding, h - padding:h], axis=(1, 2)) res[:, padding:-padding, 0:padding] = np.flip(data[:, :, 0:padding], axis=2) res[:, padding:-padding, padding:-padding] = data res[:, padding:-padding, -padding:] = np.flip(data[:, :, -padding:], axis=2) res[:, -padding:, 0:padding] = np.flip(data[:, -padding:, 0:padding], axis=(1, 2)) res[:, -padding:, padding:-padding] = np.flip(data[:, -padding:, :], axis=1) res[:, -padding:, -padding:] = np.flip(data[:, -padding:, -padding:], axis=(1, 2)) return res
def load_images(self, process_once=True): 'Process training data and save as images. Overwrite for each new dataset' # for cifar10 #np.random.seed(self.seed) if os.path.exists( '/home/michal5/cs498_finalproject/cifar10_val_data.txt'): process_once = False subfolders = [ 'data_batch_1', 'data_batch_2', 'data_batch_3', 'data_batch_4', 'data_batch_5' ] val_dict = [] data = [] labels = [] train_data = [] train_labels = [] val_data = [] val_labels = [] for folder in subfolders: dictionary = unpickle('/data/common/' + 'cifar-10-batches-py' + '/' + folder) images = dictionary[b'data'] label_entry = dictionary[b'labels'] data.append(images) labels += label_entry data = np.concatenate(data) data = data.reshape((50000, 3, 32, 32)) data = data.transpose((0, 2, 3, 1)) labels = np.asarray(labels) if process_once: with open('/home/michal5/cs498_finalproject/cifar10_val_data.txt' ) as f: val_values = json.load(f) for i, label in enumerate(labels): if not process_once: if random.random() > 0.8: val_data.append(data[i]) val_labels.append(label) val_dict.append(i) else: train_data.append(data[i]) train_labels.append(label) else: if i in val_values: val_data.append(data[i]) val_labels.append(label) else: train_data.append(data[i]) train_data.append(label) if not process_once: file_name = '/shared/rsaas/michal5/classes/498_dl/cs498_finalproject/' + 'cifar10_val_data' + '.txt' with open(file_name, 'w+') as image_val: json.dump(val_dict, image_val) train_labels = np.asarray(train_labels, dtype=np.int) val_labels = np.asarray(val_labels, dtype=np.int) return train_data, train_labels, val_data, val_labels
def __getitem__(self, index): h5f = h5py.File(self.path, 'r') key = self.keys[index] g = h5f[key] mosaic_noisy = np.array(g['mosaic_noisy']).reshape( g['mosaic_noisy'].shape) mosaic_blur = np.array(g['mosaic_blur']).reshape( g['mosaic_blur'].shape) linRGB = np.array(g['linRGB']).reshape(g['linRGB'].shape) wb = np.array(g['wb']).reshape(g['wb'].shape) XYZ2Cam = np.array(g['XYZ2Cam']).reshape(g['XYZ2Cam'].shape) if len(mosaic_noisy.shape) == 4: mosaic_noisy = mosaic_noisy[-1] if len(mosaic_blur.shape) == 4: mosaic_blur = mosaic_blur[-1] data = np.concatenate([mosaic_noisy, mosaic_blur, linRGB], 2) h5f.close() if self.train: p = 0.5 if random.random() > p: #RandomRot90 data = data.transpose(1, 0, 2) if random.random() > p: #RandomHorizontalFlip data = data[:, ::-1, :] data = data[:, 1:-1, :] if random.random() > p: #RandomVerticalFlip data = data[::-1, :, :] data = data[1:-1, :, :] (H, W, C) = data.shape rnd_h = random.randint(0, max(0, (H - self.patch_size) // 2)) * 2 rnd_w = random.randint(0, max(0, (W - self.patch_size) // 2)) * 2 patch = data[rnd_h:rnd_h + self.patch_size, rnd_w:rnd_w + self.patch_size, :] else: patch = data mosaic_noisy = patch[:, :, 0] mosaic_blur = patch[:, :, 1] linRGB = patch[:, :, 2:5] mosaic_noisy = np.clip(mosaic_noisy, 0.0, 1.0) mosaic_noisy = raw2rggb(mosaic_noisy) mosaic_blur = raw2rggb(mosaic_blur) Cam2sRGB = get_ccm(XYZ2Cam) Cam2sRGB = torch.FloatTensor(Cam2sRGB) mosaic_noisy = torch.from_numpy( np.ascontiguousarray(np.transpose(mosaic_noisy, (2, 0, 1)))).float() mosaic_blur = torch.from_numpy( np.ascontiguousarray(np.transpose(mosaic_blur, (2, 0, 1)))).float() linRGB = torch.from_numpy( np.ascontiguousarray(np.transpose(linRGB, (2, 0, 1)))).float() return mosaic_noisy, mosaic_blur, linRGB, Cam2sRGB
def test(result_dir): """ upsample a point cloud """ pytorch_utils.load_network(net, CKPT) net.to(DEVICE) net.eval() test_files = glob(TEST_DATA, recursive=True) for point_path in test_files: folder = os.path.basename(os.path.dirname(point_path)) out_path = os.path.join(result_dir, folder, point_path.split('/')[-1][:-4] + '.ply') data = pc_utils.load(point_path, NUM_SHAPE_POINT) data = data[np.newaxis, ...] num_shape_point = data.shape[1] * FLAGS.drop_out if FLAGS.drop_out < 1: _, data = operations.furthest_point_sample( data, int(num_shape_point)) # normalize "unnecessarily" to apply noise data, centroid, furthest_distance = pc_utils.normalize_point_cloud( data) is_2D = np.all(data[:, :, 2] == 0) if JITTER: data = pc_utils.jitter_perturbation_point_cloud( data, sigma=FLAGS.jitter_sigma, clip=FLAGS.jitter_max, is_2D=is_2D) # transpose to NCHW format data = torch.from_numpy(data).transpose(2, 1).to(device=DEVICE) logger.info(os.path.basename(point_path)) start = time.time() with torch.no_grad(): # 1x3xN input_pc_list, pred_pc_list = pc_prediction( net, data, patch_num_ratio=PATCH_NUM_RATIO) # for i, patch_pair in enumerate(zip(input_pc_list, pred_pc_list)): # in_patch, out_patch = patch_pair # pc_utils.save_ply(in_patch.transpose(2, 1).cpu().numpy()[ # 0], path[:-4]+'_input_%d.ply' % i) # pc_utils.save_ply(out_patch.transpose(2, 1).cpu().numpy()[ # 0], path[:-4]+'_output_%d.ply' % i) pred_pc = torch.cat(pred_pc_list, dim=-1) input_point = torch.cat(input_pc_list, dim=-1) end = time.time() print("total time: ", end - start) _, pred_pc = operations.furthest_point_sample( pred_pc, int(num_shape_point) * UP_RATIO, NCHW=True) pred_pc = pred_pc.transpose(2, 1).cpu().numpy() pred_pc = (pred_pc * furthest_distance) + centroid data = data.transpose(2, 1).cpu().numpy() data = (data * furthest_distance) + centroid data = data[0, ...] pred_pc = pred_pc[0, ...] pc_utils.save_ply(data, out_path[:-4] + '_input.ply') pc_utils.save_ply(pred_pc, out_path[:-4] + '.ply')
def test(epoch): model.eval() test_loss = 0 for batch_idx, data in enumerate(test_loader): data = data[0].transpose(1, 2).to(device) recon_batch, mu, logvar = model(data) test_loss += loss_function(recon_batch, data.transpose(1, 2), mu, logvar).item() print('test', test_loss / len(test_loader))
def __getitem__(self,index): filename = self.video_path[index] tmp_data = [] tmp_data_f = [] s_index = 0 s_index_f = 0 for parent, dirnames, filenames in os.walk(filename): if(len(filenames)<self.num_frames_per_clip): return [], s_index filenames = sorted(filenames) s_index = random.randint(0, len(filenames) - self.num_frames_per_clip) for i in range(s_index, s_index + self.num_frames_per_clip): image_name = str(filename) + '/' + str(filenames[i]) #print(image_name) img = Image.open(image_name) img_data = np.array(img) tmp_data.append(img_data) if self.num_frames_per_clip == 1: while (len(ret_arr) < 16): tmp_data.append(img_data) #print(type(filenames)) #tmp_data, _ = self.get_frames_data(filenames) img_datas = []; #print(len(tmp_data)) if(len(tmp_data)!=0): for j in xrange(len(tmp_data)): img = Image.fromarray(tmp_data[j].astype(np.uint8)) if(img.width>img.height): scale = float(self.crop_size)/float(img.height) img = np.array(cv2.resize(np.array(img),(int(img.width * scale + 1), self.crop_size))).astype(np.float32) else: scale = float(self.crop_size)/float(img.width) img = np.array(cv2.resize(np.array(img),(self.crop_size, int(img.height * scale + 1)))).astype(np.float32) crop_x = int((img.shape[0] - self.crop_size)/2) crop_y = int((img.shape[1] - self.crop_size)/2) img = img[crop_x:crop_x+self.crop_size, crop_y:crop_y+self.crop_size,:] - self.np_mean[j] img_datas.append(img) label = torch.LongTensor([self.labels[index]]) data = np.array(img_datas).astype(np.float32) #print(data_f.shape) #print(data.shape,filename) #print(data.shape,filename) data = data.transpose(3, 0, 1, 2) clip_frames = torch.from_numpy(data) return clip_frames, label, index
def evaluate(epoch): """uses test data to evaluate likelihood of the model""" mean_kld_loss, mean_nll_loss = 0, 0 mean_loss = 0 kl_acc = 0 loghatlist = [] iwaelist = [] for i, (data, _, lengths) in enumerate(valid_loader): #data = Variable(data) # data = Variable(data.squeeze().transpose(0, 1), requires_grad=False) data = data.transpose(0, 1) mask = generate_seq_mask(lengths, data.shape[0], data.shape[1]) # data = (data - data.min()) / (data.max() - data.min()) # kld_loss, nll_loss, _, _ = model(data, mask) loss, loghat, _, kl, iwae_bound = model(data, mask, num_particles) kl_acc += kl.mean() mean_loss += loss logp_per_timestep = loghat / lengths iwae_bound_per_t = iwae_bound / lengths for i, loghat_ in enumerate(logp_per_timestep): loghatlist.append(loghat_.item()) iwaelist.append(iwae_bound_per_t[i].item()) # mean_kld_loss += kld_loss.item() # mean_nll_loss += nll_loss.item() # mean_kld_loss /= len(valid_loader.dataset) # mean_nll_loss /= len(valid_loader.dataset) mean_loss /= len(valid_loader.dataset) kl_acc /= len(valid_loader.dataset) mean_loghat_per_timestep = np.mean(loghatlist) mean_iwae_per_timestep = np.mean(iwaelist) if USEWANDB: # wandb.log({'valid_NLL': loss}, step=epoch) wandb.log({'valid_FIVO(4)_t': mean_loghat_per_timestep}, step=epoch) wandb.log({'valid_IWAE(4)_t': mean_iwae_per_timestep}, step=epoch) # wandb.log({'valid_KLD': mean_kld_loss}, step=epoch) # wandb.log({'valid_NLL': mean_nll_loss}, step=epoch) # wandb.log({'valid_loss': mean_kld_loss + mean_nll_loss}, step=epoch) print( '====> Valid set loss: Avg. Marginal LL = {:.4f}, KL = {:.4f}, Marginal LL per timestep = {:.4f}, IWAE bound per timestep = {:.4f}' .format(-mean_loss, kl_acc, mean_loghat_per_timestep, mean_iwae_per_timestep)) # print('====> Valid set loss: KLD Loss = {:.4f}, NLL Loss = {:.4f} '.format( # mean_kld_loss, mean_nll_loss)) return mean_loss
def __call__(self, sample): data, target = sample['data'], sample['target'] # swap color axis because # numpy image: H x W x C # torch image: C X H X W data = data.transpose((1, 2, 0)) target = target.transpose((1, 2, 0)) return {'data': data, 'target': target}
def __getitem__(self, index): data = np.load(self.filenames[index]) label = self.labels[index] data = data.transpose(2, 0, 1) data = torch.from_numpy(np.asarray(data)).float() label = torch.from_numpy(np.asarray(label)).float() return data, label
def __getitem__(self, idx): data = self.data[idx] label = self.label[idx] if self.crop_size: data, label = transform.random_crop(data, label, size=[self.crop_size, self.crop_size]) if self.random_flip: data, label = transform.rand_flip(data, label) data = torch.from_numpy(data.transpose((2, 0, 1))) return data, label
def __call__(self, sample): data, target = sample['data'], sample['target'] # swap color axis because # numpy image: H x W x C # torch image: C X H X W data = data.transpose((2, 0, 1)) target = target.transpose((2, 0, 1)) return { 'data': torch.from_numpy(data).float(), 'target': torch.from_numpy(target).float() }
def data_loop(loader, model, z_dim, device, train_mode=True): loss = 0 for data, _ in tqdm.tqdm(loader): x = data.transpose(0, 1).to(device) batch_size = x.size(1) z_prev = torch.zeros(batch_size, z_dim).to(device) if train_mode: loss += model.train({"x": x, "z_prev": z_prev}) * batch_size else: loss += model.test({"x": x, "z_prev": z_prev}) * batch_size return loss / len(loader.dataset)
def __getitem__(self, index): # get the anchor index for current sample index # here we set the anchor index to the last one # sample in this group minibatch_db = [self._roidb[index]] blobs = get_minibatch(minibatch_db, self._num_classes) # print(blobs) # import IPython; IPython.embed() # assert(1 == 0) data = torch.from_numpy(blobs['data']) im_info = torch.from_numpy(blobs['im_info']) # we need to random shuffle the bounding box. data_height, data_width = data.size(1), data.size(2) if self.training: np.random.shuffle(blobs['gt_boxes']) try: gt_boxes = torch.from_numpy(blobs['gt_boxes']) except: print('gt_boxes error') import IPython IPython.embed() im_info[0, 0] = data.size(1) im_info[0, 1] = data.size(2) gt_boxes_padding = torch.FloatTensor(self.max_num_box, gt_boxes.size(1)).zero_() num_boxes = min(gt_boxes.size(0), self.max_num_box) gt_boxes_padding[:num_boxes, :] = gt_boxes[:num_boxes] # permute trim_data to adapt to downstream processing try: data = data.transpose(2, 3).transpose(1, 2).contiguous() except: import IPython IPython.embed() im_info = im_info.view(3) return data.squeeze(0), im_info, gt_boxes_padding, num_boxes else: data = data.permute(0, 3, 1, 2).contiguous().view(3, data_height, data_width) im_info = im_info.view(3) gt_boxes = torch.FloatTensor([1, 1, 1, 1, 1]) num_boxes = 0 return data, im_info, gt_boxes, num_boxes
def test(net, img, args): """ Test a model on a specific image """ net.eval() patch_size = args.patch_size center_pixel = args.center_pixel batch_size, device = args.batch_size, torch.device(args.device) n_classes = args.n_classes kwargs = { 'step': args.test_stride, 'window_size': (patch_size, patch_size) } probs = np.zeros(img.shape[:2] + (n_classes, )) iterations = utils.count_sliding_window(img, **kwargs) // batch_size for batch in tqdm(utils.grouper(batch_size, utils.sliding_window(img, **kwargs)), total=(iterations), desc="Inference on the image"): with torch.no_grad(): if patch_size == 1: data = [b[0][0, 0] for b in batch] data = np.copy(data) data = torch.from_numpy(data) else: data = [b[0] for b in batch] data = np.copy(data) data = data.transpose(0, 3, 1, 2) data = torch.from_numpy(data) data = data.unsqueeze(1) indices = [b[1:] for b in batch] data = data.to(device) output = net(data) if isinstance(output, tuple): output = output[0] output = output.to('cpu') if patch_size == 1 or center_pixel: output = output.numpy() else: output = np.transpose(output.numpy(), (0, 2, 3, 1)) for (x, y, w, h), out in zip(indices, output): if center_pixel: probs[x + w // 2, y + h // 2] += out else: probs[x:x + w, y:y + h] += out return probs
def __init__(self, root='./data', train=True, transform=None, inlist=None): self.T = transform self.train = train self.inlist = inlist dataset = root.split('/')[-1] if train: if dataset == 'cifar10': data_list = ['data_batch_%d' % (i + 1) for i in range(5)] elif dataset == 'cifar100': data_list = ['train'] else: if dataset == 'cifar10': data_list = ['test_batch'] elif dataset == 'cifar100': data_list = ['test'] self.data = [] self.label = [] for filename in data_list: filepath = os.path.join(os.path.join(root, filename)) with open(filepath, 'rb') as f: entry = pickle.load(f, encoding='latin1') self.data.append(entry['data']) if 'labels' in entry: self.label.extend(entry['labels']) else: self.label.extend(entry['fine_labels']) data = np.vstack(self.data).reshape(-1, 3, 32, 32) data = data.transpose((0, 2, 3, 1)) #NHWC labels = np.array(self.label) if self.train: n_class = np.max(labels) + 1 img_list, lbl_list = [], [] for i in range(n_class): if i in inlist: idx = np.squeeze(np.argwhere(labels == i)) img = data[idx] lbl = labels[idx] img_list.append(img) lbl_list.append(lbl) self.images = np.concatenate(img_list) self.labels = np.concatenate(lbl_list) else: self.images = data self.labels = labels
def train(epoch): model.train() train_loss = 0 for batch_idx, data in enumerate(train_loader): data = data[0].transpose(1, 2).to(device) optimizer.zero_grad() recon_batch, mu, logvar = model(data) loss = loss_function(recon_batch, data.transpose(1, 2), mu, logvar) loss.backward() train_loss += loss optimizer.step() if batch_idx % 100 == 0: print(f'{epoch} / {batch_idx}\t{loss:.4f}') print('train', train_loss / len(train_loader.dataset)) return train_loss / len(train_loader.dataset)
def check_rgb(data): """ check weather the data is RGB or not if its gray,transfer it to RGB :param data: :return: """ h, w, *c = data.shape is_gray = False if not c: is_gray = True if is_gray: data = np.tile(data, (3, 1, 1)) data = data.transpose((1, 2, 0)) return data