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
