def train_batch(b):
"""
:param b: contains:
:param imgs: the image, [batch_size, 3, IM_SIZE, IM_SIZE]
:param all_anchors: [num_anchors, 4] the boxes of all anchors that we'll be using
:param all_anchor_inds: [num_anchors, 2] array of the indices into the concatenated
RPN feature vector that give us all_anchors,
each one (img_ind, fpn_idx)
:param im_sizes: a [batch_size, 4] numpy array of (h, w, scale, num_good_anchors) for each image.
:param num_anchors_per_img: int, number of anchors in total over the feature pyramid per img
Training parameters:
:param train_anchor_inds: a [num_train, 5] array of indices for the anchors that will
be used to compute the training loss (img_ind, fpn_idx)
:param gt_boxes: [num_gt, 4] GT boxes over the batch.
:param gt_classes: [num_gt, 2] gt boxes where each one is (img_id, class)
:return:
"""
'''
return Result(
od_obj_dists=od_obj_dists, # 1
rm_obj_dists=obj_dists, # 2
obj_scores=nms_scores, # 3
obj_preds=nms_preds, # 4
obj_fmap=obj_fmap, # 5 pick
od_box_deltas=od_box_deltas, # 6
rm_box_deltas=box_deltas, # 7
od_box_targets=bbox_targets, # 8
rm_box_targets=bbox_targets, # 9
od_box_priors=od_box_priors, # 10
rm_box_priors=box_priors, # 11 pick
boxes_assigned=nms_boxes_assign, # 12
boxes_all=nms_boxes, # 13
od_obj_labels=obj_labels, # 14
rm_obj_labels=rm_obj_labels, # 15
rpn_scores=rpn_scores, # 16
rpn_box_deltas=rpn_box_deltas, # 17
rel_labels=rel_labels, # 18
im_inds=im_inds, # 19 pick
fmap=fmap if return_fmap else None, # 20
)
'''
# b.imgs = F.upsample(b.imgs, size=592, mode='bilinear')
# b.im_sizes[0, :, :2] = 592
result = detector[b]
print("imgs.shape", b.imgs.shape)
print("im_sizes", b.im_sizes)
print("boxes", result.rm_box_priors)
print("im_inds", result.im_inds)
print("rm_obj_dists.shape", result.rm_obj_dists.shape)
# tform = [
# Normalize(mean=[0, 0, 0], std=[1 / 0.229, 1 / 0.224, 1 / 0.225]),
# Normalize(mean=[-0.485, -0.456, -0.406], std=[1, 1, 1]),
# ToPILImage()
# ]
for i in range(len(b.imgs)):
# pil_img = transform_pipeline(b.imgs[i]).convert("RGB")
img_tensor = b.imgs[i].data.cpu()
print(img_tensor.shape, img_tensor.max(), img_tensor.min())
img_tensor = Normalize(mean=[0, 0, 0],
std=[1 / 0.229, 1 / 0.224,
1 / 0.225])(img_tensor)
img_tensor = Normalize(mean=[-0.485, -0.456, -0.406],
std=[1, 1, 1])(img_tensor)
pil_img = ToPILImage()(img_tensor)
pil_img = pil_img.convert("RGB")
draw = ImageDraw.Draw(pil_img)
for j in range(len(result.rm_box_priors)):
if result.im_inds.data[j] == i:
# class_ind = int(result.rm_obj_dists.data[j].max(0)[1])
class_ind = int(result.obj_preds[j])
class_score = float(result.obj_scores[j])
# if class_ind != 0:
draw = draw_box(
draw, result.rm_box_priors.data[j], "%s[%.3f]" %
(train.ind_to_classes[class_ind], class_score))
pil_img.save(
"/newNAS/Workspaces/UCGroup/gslu/aws_ailab/code/neural-motifs/checkpoints/%d.png"
% i)
# scores = result.od_obj_dists
# box_deltas = result.od_box_deltas
# labels = result.od_obj_labels
# roi_boxes = result.od_box_priors
# bbox_targets = result.od_box_targets
# rpn_scores = result.rpn_scores
# rpn_box_deltas = result.rpn_box_deltas
#
# # detector loss
# valid_inds = (labels.data != 0).nonzero().squeeze(1)
# fg_cnt = valid_inds.size(0)
# bg_cnt = labels.size(0) - fg_cnt
# class_loss = F.cross_entropy(scores, labels)
#
# # No gather_nd in pytorch so instead convert first 2 dims of tensor to 1d
# box_reg_mult = 2 * (1. / FG_FRACTION) * fg_cnt / (fg_cnt + bg_cnt + 1e-4)
# twod_inds = valid_inds * box_deltas.size(1) + labels[valid_inds].data
#
# box_loss = bbox_loss(roi_boxes[valid_inds], box_deltas.view(-1, 4)[twod_inds],
# bbox_targets[valid_inds]) * box_reg_mult
#
# loss = class_loss + box_loss
#
# # RPN loss
# if not conf.use_proposals:
# train_anchor_labels = b.train_anchor_labels[:, -1]
# train_anchors = b.train_anchors[:, :4]
# train_anchor_targets = b.train_anchors[:, 4:]
#
# train_valid_inds = (train_anchor_labels.data == 1).nonzero().squeeze(1)
# rpn_class_loss = F.cross_entropy(rpn_scores, train_anchor_labels)
#
# # print("{} fg {} bg, ratio of {:.3f} vs {:.3f}. RPN {}fg {}bg ratio of {:.3f} vs {:.3f}".format(
# # fg_cnt, bg_cnt, fg_cnt / (fg_cnt + bg_cnt + 1e-4), FG_FRACTION,
# # train_valid_inds.size(0), train_anchor_labels.size(0)-train_valid_inds.size(0),
# # train_valid_inds.size(0) / (train_anchor_labels.size(0) + 1e-4), RPN_FG_FRACTION), flush=True)
# rpn_box_mult = 2 * (1. / RPN_FG_FRACTION) * train_valid_inds.size(0) / (train_anchor_labels.size(0) + 1e-4)
# rpn_box_loss = bbox_loss(train_anchors[train_valid_inds],
# rpn_box_deltas[train_valid_inds],
# train_anchor_targets[train_valid_inds]) * rpn_box_mult
#
# loss += rpn_class_loss + rpn_box_loss
# res = pd.Series([rpn_class_loss.data[0], rpn_box_loss.data[0],
# class_loss.data[0], box_loss.data[0], loss.data[0]],
# ['rpn_class_loss', 'rpn_box_loss', 'class_loss', 'box_loss', 'total'])
# else:
# res = pd.Series([class_loss.data[0], box_loss.data[0], loss.data[0]],
# ['class_loss', 'box_loss', 'total'])
#
# optimizer.zero_grad()
# loss.backward()
# clip_grad_norm(
# [(n, p) for n, p in detector.named_parameters() if p.grad is not None],
# max_norm=conf.clip, clip=True)
# optimizer.step()
return res
def make_panel(list_of_images):
images = [image[1] for image in list_of_images]
panel = torch.cat(images, dim=2)
panel_pil = ToPILImage().__call__(panel)
return panel_pil
ref_noise_vec = final_gen_codes.mean(
axis=0, keepdims=True) # final_gen_codes[0:1, :]
if score_rank_avg:
ref_noise_vec = w_avg_code
elif evolspace == "BigGAN":
ref_vec = final_gen_codes.mean(axis=0,
keepdims=True) # final_gen_codes[0:1, :]
if score_rank_avg:
ref_vec = w_avg_code
ref_noise_vec = ref_vec[:, :128]
ref_class_vec = ref_vec[:, 128:]
## View image correspond to the reference code
ref_vect = torch.from_numpy(
np.concatenate((ref_noise_vec, ref_class_vec), axis=1)).float().cuda()
refimg = G.visualize(ref_vect).cpu()
centimg = ToPILImage()(refimg[0, :, :, :])
centimg.show(title="Center Reference Image")
#%% Visualize the Final Generation together with the center reference image.
VisFinalGen = False
if VisFinalGen:
#% If you want to regenerate the images from last generation here.
print(
"Review the last generation codes w.r.t. the center code for manifold."
)
imgs_final = G.visualize_batch_np(
np.concatenate(
(ref_noise_vec.repeat(25, axis=0), final_gen_codes[:, :]), axis=1))
ToPILImage()(make_grid(imgs_final, nrow=5)).show()
#G.visualize(torch.from_numpy(np.concatenate((ref_noise_vec.repeat(5,axis=0), final_gen_codes[:5,:]), axis=1)).float().cuda()).cpu()
#ToPILImage()(make_grid(imgs.cpu())).show()
#%% Compute Hessian decomposition and get the vectors
from __future__ import print_function
from torch import optim
import torch as t
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
# import matplotlib.pyplot as plt
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
show = ToPILImage()
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
(0.5, 0.5, 0.5)) # Normalize(mean, std)
])
# 训练集
train_set = tv.datasets.CIFAR10(
root='/Users/weiyangbin/Downloads/cifar-100-python/',
train=True,
download=True,
transform=transform)
train_loader = t.utils.data.DataLoader(train_set,
batch_size=4,
shuffle=True,
num_workers=2)
def __getitem__(self, index):
img_path, pid, camid = self.dataset[index]
img = read_image(img_path)
seed = random.randint(0, 2**32)
radint = random.randint(0, 1)
# print('radint',radint)
# if self.transform is not None:
# random.seed(seed)
# img = self.transform(img)
# area = img.size()[1] * img.size()[2]
area = 256 * 128
i = random.randint(0, 20)
j = random.randint(0, 20)
# print('&&&*****')
# print('i',i)
# print('j',j)
# print('####')
target_area = random.uniform(0.02, 0.4) * area
aspect_ratio = random.uniform(0.3, 1 / (0.3))
img_transform = build_transforms(self.cfg, radint, i, j, is_train=True)
mask_transform = mask_transforms(self.cfg, radint, i, j, is_train=True)
img = img_transform(img)
x1, y1, h, w = get_x1y1(img)
# print(img.size())
# import pdb
# pdb.set_trace()
REA = RandomErasing(radint,
x1,
y1,
h,
w,
probability=self.cfg.INPUT.RE_PROB,
mean=self.cfg.INPUT.PIXEL_MEAN)
img = REA(img)
MREA = MaskRandomErasing(radint,
x1,
y1,
h,
w,
probability=self.cfg.INPUT.RE_PROB,
mean=self.cfg.INPUT.PIXEL_MEAN)
if self.use_salience and not self.use_parsing:
salience_path = osp.join(self.salience_base_path,
get_image_name(img_path) + '.npy')
if self.transform_salience_parsing == None:
salience_img = preprocess_salience(
read_numpy_file(salience_path))
else:
random.seed(seed)
# salience_img = self.transform_salience_parsing(Image.fromarray(read_numpy_file(salience_path)))
salience_img = mask_transform(
Image.fromarray(read_numpy_file(salience_path)))
salience_img = MREA(salience_img)
salience_img = ToPILImage()(salience_img)
salience_img = T.Resize((64, 32))(salience_img)
salience_img = T.ToTensor()(salience_img)
# print(salience_img.size())
# import pdb
# pdb.set_trace()
# salience_img = salience_img.resize((32, 64), Image.BILINEAR)
# salience_img = np.array(salience_img)
# salience_img =torch.Tensor(salience_img)
return img, pid, camid, salience_img, img_path
elif not self.use_salience and self.use_parsing:
parsing_path = osp.join(self.parsing_base_path,
get_image_name(img_path) + '.npy')
zerovalue = get_value(parsing_path)
# parsing_img, label_mark = decode_parsing(torch.tensor(read_numpy_file(parsing_path)))
parsing_img = decode_parsing(
torch.tensor(read_numpy_file(parsing_path)))
parsing_img = new_decode_parsing(
torch.tensor(read_numpy_file(parsing_path)), zerovalue)
body_parsing_img = body_decode_parsing(
torch.tensor(read_numpy_file(parsing_path)))
if self.transform_salience_parsing != None:
new_parsing_img = []
body_new_parsing_img = []
for slide in parsing_img:
random.seed(seed)
# img_i = self.transform_salience_parsing(Image.fromarray(slide))
img_i = mask_transform(Image.fromarray(slide))
img_i = MREA(img_i)
img_i = ToPILImage()(img_i)
img_i = T.Resize((64, 32))(img_i)
# img_i = T.ToTensor()(img_i)
# img_i = img_i.resize((64, 192), Image.BILINEAR)
# img_i = img_i.resize((32, 64), Image.BILINEAR)
img_i = np.array(img_i)
new_parsing_img.append(img_i)
for slide in body_parsing_img:
random.seed(seed)
img_i = self.transform_salience_parsing(
Image.fromarray(slide))
# img_i = img_i.resize((64, 192), Image.BILINEAR)
# img_i = img_i.resize((32, 64), Image.BILINEAR)
img_i = np.array(img_i)
body_new_parsing_img.append(img_i)
# parsing_img = np.array(new_parsing_img)
parsing_img = torch.Tensor(new_parsing_img)
# import pdb
# pdb.set_trace()
# body_new_parsing_img = np.array(body_new_parsing_img)
body_new_parsing_img = torch.Tensor(body_new_parsing_img)
# return img, pid, camid, parsing_img,body_new_parsing_img, img_path
return img, pid, camid, parsing_img, img_path
elif self.use_parsing and self.use_salience:
parsing_path = osp.join(self.parsing_base_path,
get_image_name(img_path) + '.npy')
salience_path = osp.join(self.salience_base_path,
get_image_name(img_path) + '.npy')
if self.transform_salience_parsing == None:
salience_img = preprocess_salience(
read_numpy_file(salience_path))
parsing_img = decode_parsing(
torch.tensor(read_numpy_file(parsing_path)))
else:
random.seed(seed)
salience_img = self.transform_salience(
Image.fromarray(read_numpy_file(salience_path)))
salience_img = salience_img.resize((64, 128), Image.BILINEAR)
salience_img = np.array(salience_img)
parsing_img = decode_parsing(
torch.tensor(read_numpy_file(parsing_path)))
new_parsing_img = []
for slide in parsing_img:
random.seed(seed)
img_i = self.transform_salience_parsing(
Image.fromarray(slide))
img_i = img_i.resize((64, 128), Image.BILINEAR)
img_i = np.array(img_i)
new_parsing_img.append(img_i)
parsing_img = np.array(new_parsing_img)
return img, pid, camid, salience_img, parsing_img, img_path
else:
return img, pid, camid, img_path
def validate(eval_loader,
model,
log,
global_step,
epoch,
save_pred=False,
mask_path=None):
meters = AverageMeterSet()
model.eval() #switch to evaluate mode
target_total = torch.randn(0, 1).double().cuda()
pred_total = torch.randn(0, 1).double().cuda()
end = time.time()
index = 0
for i, (input, target) in enumerate(eval_loader):
inputs = Variable(input).cuda()
targets = torch.autograd.Variable(target).float().cuda()
#target_var = torch.autograd.Variable(target).long()
#one_hot = torch.zeros( target_var.size(0), args.num_classes, target_var.size(2), target_var.size(3) )
#target_onehot = one_hot.scatter_(1, target_var.data, 1)
#target_var = Variable(target_onehot).cuda()
### compute output and loss
model_output = model(inputs)
#LOG.info('model shape', model_output.shape)
#LOG.info('mode', model_output[0,:,0:10,0:10])
#LOG.info('targets', targets[0,:,0:10,0:10])
model_out = torch.sigmoid(model_output) #since binary
model_out = model_out[:, 1, :, :].unsqueeze(1)
#LOG.info('mode', model_out[0,:,0:10,0:10])
#LOG.info('model squeeze', model_out.squeeze(1)[0,:,0:10,0:10])
#t = torch.Tensor([0.55]).cuda()
#model_out = (model_out > t).float() * 1
#model_out = torch.round(model_out)
#correction = torch.Tensor([1]).cuda()
#model_out = torch.round(correction - model_out)
#print('model corrected', model_out[0])
#print('targets', targets[0])
loss = dice_loss(model_out, targets)
dice = 1 - loss
meters.update('loss', loss.item())
target_total = torch.cat((target_total, targets.data.double()), 0)
pred_total = torch.cat((pred_total, model_out.data.double()), 0)
#LOG.info('loss = %s' %loss.item())
#LOG.info('dice = %s' %dice)
#print('\ntargets', targets.shape)
#print('model', model_out.shape)
#print('targets total', target_total.shape)
#print('pred total', pred_total.shape)
outnames = pd.read_csv(args.test_csv, header=None)
target_var = targets.cpu()
pred_var = model_out.cpu()
#if save_pred:
if False:
#sm = nn.Softmax()
#sm_output= sm(model_output)
#model_sigmoid = torch.sigmoid(model_output) #since binary
#target_var = targets.cpu()
#model_pred = model_out.cpu()
#print(model_pred.shape[0])
#print(model_pred[0])
#print(target[0])
#model_pred = np.argmax(model_sigmoid.detach(), axis = 1) #un one hot?
#model_pred = torch.cat((model_pred, model_sigmoid.data.double()), 0)
#print(model_pred)
for sample in range(model_pred.size(0)):
outname = outnames.iloc[index, 0].split(".")[0]
outpath = mask_path + "/" + outname + ".png"
pred = pred_var[sample].float()
target = target_var[sample].float()
TP = torch.mul(pred, target)
FP = pred - TP
FN = target - TP
#print('pred', model_pred[0].float())
#print('target', target_var[0].float())
######
#pred = model_pred[sample].unsqueeze(0)
#print(pred)
#pred = pred.data.cpu()
#print(pred)
#print(pred.size())
#print(target.size())
#print(pred.type())
#pixels = visionF.to_pil_image(pred).convert('RGB')
#pixels = ToPILImage()(pred).convert('RGB')
TP = ToPILImage()(TP).convert('RGB')
FP = ToPILImage()(FP).convert('RGB')
FN = ToPILImage()(FN).convert('RGB')
numpixels = TP.size[0] * TP.size[1]
colors = []
for pixel in range(numpixels):
tp = TP.getdata()[pixel]
fp = FP.getdata()[pixel]
fn = FN.getdata()[pixel]
colors.append((fp[0], tp[0], fn[0]))
#p = pred[pixel]
#pred_by_pixel.append(p)
#colors.append( (color[0], 0, 0) )
# if color not black: colors.append(red)
# else: colors.append(black)
mask = Image.new(TP.mode, TP.size)
mask.putdata(colors)
mask.save(outpath)
index = index + 1
#target_total = torch.cat((target_total, target_var.data.double()), 0)
#pred_total = torch.cat((pred_total, model_pred.data.double()), 0)
#LOG.info('pred preview {}'.format(pred_total.data))
#LOG.info('model_output.size {}'.format(model_output.size()))
#LOG.info('model_sigmoid.size {}'.format(model_sigmoid.size()))
############# print progress to console
if i % args.print_freq == 0:
LOG.info('Test: [{0}/{1}]\t'
'Dice {2}\t'.format(i, len(eval_loader),
round(dice.item(), 4)))
#import matplotlib.pyplot as plt
#preds = pred_total.cpu().numpy()
#plt.hist(preds.flatten(), bins="auto")
#plt.show()
overall_loss = dice_loss(pred_total, target_total)
overall_dice = 1 - overall_loss
print('[{}/{}] Overall Dice score: {}\n'.format(
epoch, args.epochs, round(overall_dice.item(), 4)))
if args.log:
LOG.info('[{}/{}] Overall Dice score: {}'.format(
epoch, args.epochs, round(overall_dice.item(), 4)))
if save_pred:
return overall_dice.item(), target_var.detach(), pred_var.detach(
), outnames
else:
return overall_dice.item()
def __init__(self, index_permutation: Sequence[int]):
self.permutation = index_permutation
self._to_tensor = ToTensor()
self._to_image = ToPILImage()
def display_topk(model,
dataset,
rows=3,
cols=3,
largest=True,
color=False,
figsize=(12, 6)):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.eval()
loader = DataLoader(dataset, batch_size=64)
label_probs_lst = []
with torch.set_grad_enabled(False):
for images, labels in loader:
images = images.to(device)
labels = labels.to(device)
logits = model(images)
probs = F.softmax(logits, -1)
_, preds = torch.max(probs, 1)
# Probability assigned to the correct label
label_probs_lst += [probs[range(len(probs)), labels].cpu()]
label_probs = torch.cat(label_probs_lst, 0)
label_probs, args = torch.topk(label_probs,
k=rows * cols,
largest=largest)
# Batch of best or worst images
images = torch.stack([dataset[i][0] for i in args], 0)
labels = [dataset[i][1] for i in args]
# Run images through the feature visualizer
model_vis = ResnetVisualizer(model.to("cpu")).eval()
probs, vis = model_vis(images)
_, preds = torch.max(probs, 1)
fig, axs = plt.subplots(rows, cols, figsize=figsize)
zipped = zip(preds, labels, label_probs, images, vis, axs.ravel())
for pred, label, label_prob, image, feat, ax in zipped:
if not color:
image[...] = image.mean(0, keepdim=True)
# Convert torch tensors to PIL images
image = rescale_to(image, 0, 255).round().to(torch.uint8)
image = ToPILImage()(image)
feat = rescale_to(feat, 0, 255).round().to(torch.uint8)
feat = ToPILImage()(feat).point(lambda px: np.abs(px - 255))
# Overlay feature map on image
red = Image.new('RGB', image.size, (255, 0, 0))
mask = Image.new('RGBA', image.size, (0, 0, 0, 123))
mask.putalpha(feat)
out = Image.composite(image, red, mask)
#image, feat = to_img(image), to_img(feat)
ax.imshow(out, interpolation='bicubic')
ax.axis('off')
_pred = validset.classes[pred]
_label = validset.classes[label]
ax.set_title(
f'Pred: {_pred}, Actual: {_label}, \nProb: {label_prob:.2f}')
return axs
import cv2
import numpy as np
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
import torch as t
from torch.tensor import Tensor
show = ToPILImage() # 可以把Tensor转成Image，方便可视化
# 第一次运行程序torchvision会自动下载CIFAR-10数据集，
# 大约100M，需花费一定的时间，
# 如果已经下载有CIFAR-10，可通过root参数指定
# 定义对数据的预处理
transform = transforms.Compose([
transforms.ToTensor(), # 转为Tensor
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), # 归一化
])
# # 训练集
# trainset = tv.datasets.CIFAR10(
# root='.',
# train=True,
# download=True,
# transform=transform)
#
# trainloader = t.utils.data.DataLoader(
# trainset,
# batch_size=4,
# shuffle=True,
# num_workers=2)
def display_transform():
return Compose([ToPILImage(), Resize(400), CenterCrop(400), ToTensor()])
from torchvision.transforms import ToPILImage,ToTensor
import h5py
import numpy as np
from PIL import Image
import time
import torch
tran1=ToPILImage()
tran2=ToTensor()
file=h5py.File("./test_set_s3.h5")
data = file["train/data"]
label = file["train/label"]
print("data:",data)
print("label:",label)
for i in range(3):
im1=torch.from_numpy(data[i])
im2=torch.from_numpy(label[i])
im1=tran1(torch.from_numpy(data[i]))
im2=tran1(torch.from_numpy(label[i]))
print(data)
im1.show()
time.sleep(1)
im2.show()
time.sleep(1)
file.close()
def val_hr_transform(crop_size):
return Compose([
ToPILImage(),
Resize(crop_size, interpolation=Image.BICUBIC),
ToTensor()
])
# Load camera and image
json_file = "./calibration.json"
cam = DSCamera(json_file)
img = np.array(PIL.Image.open("./sample.jpg"))
img_size = (512, 512)
f = 0.25
# Generate 3D points
h, w = img_size
z = f * min(img_size)
x = np.arange(w) - w / 2
y = np.arange(h) - h / 2
x_grid, y_grid = np.meshgrid(x, y, indexing="xy")
point3D = np.stack([x_grid, y_grid, np.full_like(x_grid, z)], axis=-1)
# Project on image plane
img_pts, valid_mask = cam.world2cam(point3D)
img_pts[~valid_mask] = -1.0
# To torch tensor
src = ToTensor()(img)
mapxy = torch.from_numpy(img_pts).float()
mapxy[..., 0] = 2 * mapxy[..., 0] / cam.w - 1.0
mapxy[..., 1] = 2 * mapxy[..., 1] / cam.h - 1.0
grid = mapxy.view(1, h, w, 2)
# Remap and show
dst = F.grid_sample(src.unsqueeze(0), grid, align_corners=False)[0]
ToPILImage()(src).show(title="Fisheye")
ToPILImage()(dst).show(title="Perspective")
def main(args):
modelpath = args.loadDir + args.loadModel
weightspath = args.loadDir + args.loadWeights
print("Loading model: " + modelpath)
print("Loading weights: " + weightspath)
model = Net(NUM_CLASSES)
model = torch.nn.DataParallel(model)
if (not args.cpu):
model = model.cuda()
def load_my_state_dict(
model, state_dict
): #custom function to load model when not all dict elements
own_state = model.state_dict()
for a in own_state.keys():
print(a)
for a in state_dict.keys():
print(a)
print('-----------')
for name, param in state_dict.items():
if name not in own_state:
continue
own_state[name].copy_(param)
return model
model = load_my_state_dict(model, torch.load(weightspath))
print("Model and weights LOADED successfully")
model.eval()
if (not os.path.exists(args.datadir)):
print("Error: datadir could not be loaded")
loader = DataLoader(cityscapes(args.datadir,
input_transform_cityscapes,
subset=args.subset),
num_workers=args.num_workers,
batch_size=args.batch_size,
shuffle=False)
# For visualizer:
# must launch in other window "python3.6 -m visdom.server -port 8097"
# and access localhost:8097 to see it
if (args.visualize):
vis = visdom.Visdom()
with torch.no_grad():
for step, (images, filename) in enumerate(loader):
images_A = images.cuda()
outputsA = model(images_A)
outputs = outputsA
label = outputs[0].cpu().max(0)[1].data.byte()
label_color = Colorize()(label.unsqueeze(0))
filenameSave = "./save_color/" + filename[0].split(
"leftImg8bit/")[1]
os.makedirs(os.path.dirname(filenameSave), exist_ok=True)
label_save = ToPILImage()(label_color)
label_save.save(filenameSave)
print(step, filenameSave)
UPSCALE_FACTOR = opt.upscale_factor
TEST_MODE = True if opt.test_mode == 'GPU' else False
IMAGE_NAME0 = opt.image_name
MODEL_NAME = opt.model_name
path = 'drive/My Drive/Aerocosmos/05june/standart/'
path_img = 'drive/My Drive/Aerocosmos/data/pan_png/SRF_4/data/'
IMAGE_NAME = path_img + IMAGE_NAME0
model = Generator(UPSCALE_FACTOR).eval()
if TEST_MODE:
model.cuda()
model.load_state_dict(torch.load(path + 'epochs/' + MODEL_NAME))
# model.load_state_dict(torch.load('epochs/' + MODEL_NAME))
else:
model.load_state_dict(torch.load(path +'epochs/' + MODEL_NAME, map_location=lambda storage, loc: storage))
image = Image.open(IMAGE_NAME)
with torch.no_grad():
image = Variable(ToTensor()(image), volatile=True).unsqueeze(0)
if TEST_MODE:
image = image.cuda()
start = time.clock()
out = model(image)
elapsed = (time.clock() - start)
#print('cost' + str(elapsed) + 's')
out_img = ToPILImage()(out[0].data.cpu())
out_img.save(path + 'test/' + 'out_srf_' + str(UPSCALE_FACTOR) + '_' + IMAGE_NAME0)
def train_lr_transform(crop_size, upscale_factor):
return Compose([
ToPILImage(),
Resize(128 // upscale_factor, interpolation=Image.BICUBIC),
ToTensor()
])
# aims : cifar10完成分类
# time : 20190807
# author : Bruce
import torch
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
show = ToPILImage() # 可以把Tensor转为Image，便于可视化
import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from scipy import misc
# 数据增广方法
transform = transforms.Compose([
transforms.ToTensor(), # 转Tensor格式
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), # 归一化
])
# 训练集
trainset = tv.datasets.CIFAR10(
#虽然Bruce已经手动下载了cifar-10-batches-py文件夹，但是没用
#然后是选定了名为 cifar-10-batches-py 的文件夹的地址。所以，是文件名的区别？很奇怪哦~
#root = '/home/bruce/Downloads/git/dataWhaleWithBruce/pytorch/Task1/cifar-10-batches-py/',
#root = '~/Downloads/cifar-10-python.tar.gz',
def tensor_to_img(tensor):
return ToPILImage()(tensor)
def tensor_to_image(tensor):
image = ToPILImage()(tensor)
b = BytesIO()
image.save(b, format="png")
return b.getvalue()
for index in test_bar:
if success:
image = pre_process(frame).unsqueeze(0)
image = image.to(device)
out, _ = model(image)
out = out.cpu()
out_image = out.data[0].numpy()
out_image *= 255.0
out_image = (np.uint8(out_image)).transpose((1, 2, 0))
# save sr video
sr_video_writer.write(out_image)
# make compared video and crop shot of left top\right top\center\left bottom\right bottom
out_image = ToPILImage()(out_image)
crop_out_images = transforms.FiveCrop(size=out_image.width // 5 -
9)(out_image)
crop_out_images = [
np.asarray(transforms.Pad(padding=(10, 5, 0, 0))(img))
for img in crop_out_images
]
out_image = transforms.Pad(padding=(5, 0, 0, 5))(out_image)
compared_image = transforms.Resize(size=(video_size[1], video_size[0]),
interpolation=Image.BICUBIC)(
ToPILImage()(frame))
crop_compared_images = transforms.FiveCrop(
size=compared_image.width // 5 - 9)(compared_image)
crop_compared_images = [
np.asarray(transforms.Pad(padding=(0, 5, 10, 0))(img))
for img in crop_compared_images
def resize(x, target_shape):
x = ToPILImage()(x.cpu().to(torch.float32))
x = Resize(target_shape)(x)
x = ToTensor()(x)
return x.cuda()
def main(args):
modelpath = args.loadDir + args.loadModel
weightspath = args.loadDir + args.loadWeights
print("Loading model: " + modelpath)
print("Loading weights: " + weightspath)
#Import ERFNet model from the folder
#Net = importlib.import_module(modelpath.replace("/", "."), "ERFNet")
model = ERFNet(NUM_CLASSES)
model = torch.nn.DataParallel(model)
if (not args.cpu):
model = model.cuda()
#model.load_state_dict(torch.load(args.state))
#model.load_state_dict(torch.load(weightspath)) #not working if missing key
def load_my_state_dict(
model, state_dict
): #custom function to load model when not all dict elements
own_state = model.state_dict()
for name, param in state_dict.items():
if name not in own_state:
continue
own_state[name].copy_(param)
return model
model = load_my_state_dict(model, torch.load(weightspath))
print("Model and weights LOADED successfully")
model.eval()
if (not os.path.exists(args.datadir)):
print("Error: datadir could not be loaded")
# loader = DataLoader(cityscapes(args.datadir, input_transform_cityscapes, target_transform_cityscapes, subset=args.subset),
# num_workers=args.num_workers, batch_size=args.batch_size, shuffle=False)
loader = DataLoader(CoIL(args.datadir, input_transform_cityscapes,
target_transform_cityscapes),
num_workers=args.num_workers,
batch_size=args.batch_size,
shuffle=False)
# For visualizer:
# must launch in other window "python3.6 -m visdom.server -port 8097"
# and access localhost:8097 to see it
if (args.visualize):
vis = visdom.Visdom()
for step, (images, labels, filename, filenameGt) in enumerate(loader):
if (not args.cpu):
images = images.cuda()
#labels = labels.cuda()
inputs = Variable(images)
print("inputs ", inputs.shape)
#targets = Variable(labels)
with torch.no_grad():
outputs = model(inputs)
label = outputs[0].max(0)[1].byte().cpu().data
print("label ", label.shape)
#label_cityscapes = cityscapes_trainIds2labelIds(label.unsqueeze(0))
label_color = Colorize()(label.unsqueeze(0))
filenameSave = "./save_color/" + filename[0].split("CoILTrain/")[1]
os.makedirs(os.path.dirname(filenameSave), exist_ok=True)
#image_transform(label.byte()).save(filenameSave)
label_save = ToPILImage()(label_color)
label_save.save(filenameSave)
if (args.visualize):
vis.image(label_color.numpy())
print(step, filenameSave)
import torchvision as tv
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
import torch as t
show = ToPILImage() #将tensor 转为image
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5, 0.5), (0.5, 0.5, 0.5, 0.5))
])
trainset = tv.datasets.CIFAR10(root='',
train=True,
download=True,
transform=transform)
trainloader = t.utils.data.DataLoader(trainset,
batch_size=4,
shuffle=True,
num_workers=2)
testset = tv.datasets.CIFAR10('',
train=False,
download=True,
transform=transform)
testloader = t.utils.data.DataLoader(testset,
batch_size=4,
# -*- coding: utf-8 -*-
# @TIME : 2021/3/18 16:39
# @AUTHOR : Xu Bai
# @FILE : 2-2-4.小试牛刀：CIFAR-10分类.py
# @DESCRIPTION :
# CIFAR数据集10个类别， 3 * 32 * 32
import torch as t
import torchvision as tv
import torchvision.transforms as transforms
from torch import optim
from torch.autograd import Variable
from torchvision.transforms import ToPILImage
show = ToPILImage() # 可以把Tensor转化为Image，方便查看
# 定义对数据的预处理
transform = transforms.Compose([
transforms.ToTensor(), # 转化为Tensor
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # mean，std归一化
])
# 训练集
trainset = tv.datasets.CIFAR10(
root='./',
train=
True, # If True, creates dataset from training set, otherwise creates from test set.
download=True,
transform=transform)
trainloader = t.utils.data.DataLoader(trainset,
batch_size=4,
shuffle=True,
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import math
from torchvision.transforms import ToTensor,ToPILImage
from skimage.draw import polygon_perimeter
from skimage import io
import numpy as np
use_cuda = True
to_PIL = ToPILImage()
class GlimpseWindow:
"""
Generates glimpses from images using Cauchy kernels.
Args:
glimpse_h (int): The height of the glimpses to be generated.
glimpse_w (int): The width of the glimpses to be generated.
"""
def __init__(self, glimpse_h: int, glimpse_w: int):
self.glimpse_h = glimpse_h
self.glimpse_w = glimpse_w
@staticmethod
def _get_filterbanks(delta_caps: Variable, center_caps: Variable, image_size: int, glimpse_size: int) -> Variable:
"""
Generates Cauchy Filter Banks along a dimension.
if idx % 50 == 0:
writer.add_images('images/input_images',
input_image,
global_step=global_step)
writer.add_images('images/target_images',
target_image,
global_step=global_step)
writer.add_images('images/generated_images',
gen_op.detach(),
global_step=global_step)
if not os.path.exists(f"../data/{str(idx)}"):
os.makedirs(f"../data/{str(idx)}")
img = gen_op.cpu()[0]
img = np.array(ToPILImage()(img))
cv2.imwrite(f"../data/{str(idx)}/e_{str(epoch)}.jpg",
cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
print(
f"epoch: {epoch}, idx: {idx}, Generator loss: {gen_loss.detach()} discriminator loss: {disc_loss.detach()}"
)
if idx % 500 == 0:
torch.save(
{
'gen': gen.state_dict(),
'disc': dis.state_dict(),
'optim_D': optim_d.state_dict(),
'optim_G': optim_g.state_dict(),
'epoch': epoch
}, f"./models/shoes_e{str(epoch)}_i{str(idx)}.pth")
import sys
import traceback
import logging
from Parameters import ARGS
from Dataset import Dataset
import Utils
from nets.SqueezeNet10 import SqueezeNet
from torch.autograd import Variable
import numpy as np
import torch.nn.utils as nnutils
import torch
from torchvision.transforms import ToPILImage
from PIL import Image
to_img = ToPILImage()
import time
def main():
logging.basicConfig(filename='training.log', level=logging.DEBUG)
logging.debug(ARGS) # Log arguments
# Set Up PyTorch Environment
# torch.set_default_tensor_type('torch.FloatTensor')
torch.cuda.set_device(ARGS.gpu)
torch.cuda.device(ARGS.gpu)
net = SqueezeNet().cuda()
criterion = torch.nn.MSELoss().cuda()
optimizer = torch.optim.Adadelta(net.parameters())
NUM_IMG_PER_EPOCH = 5
# Optimizer params.
LEARNING_RATE=5e-4
BETAS=(0.9, 0.999)
OPT_EPS=1e-08
WEIGHT_DECAY=1e-6
DISCOUNT_RATE_START=0.1
DISCOUNT_RATE=0.01
MAX_CONSISTENCY_EPOCH=30
DISCOUNT_RATE_START_EPOCH=50
color_transform_target = Colorize(1.0, 2.0, remove_negative=True, extend=True, white_val=1.0) # min_val, max_val, remove negative
color_transform_output = Colorize(1.0, 2.0, remove_negative=False, extend=True, white_val=1.0) # Automatic color based on tensor min/max val
# color_transform_output = ColorizeMinMax() # Automatic color based on tensor min/max val
image_transform = ToPILImage()
#Augmentations - different function implemented to perform random augments on both image and target
class MyCoTransform(object):
def __init__(self, enc, augment=True, height=512):
self.enc=enc
self.augment = augment
self.height = height
self.rotation_angle = 5.0
self.affine_angle = 5.0
self.shear_angle = 5.0
self.crop_ratio = 0.7
def test(test_loader, model, epoch):
model.eval()
totalNumber = 0
errorSum = {
'MSE': 0,
'RMSE': 0,
'ABS_REL': 0,
'LG10': 0,
'MAE': 0,
'DELTA1': 0,
'DELTA2': 0,
'DELTA3': 0
}
for i, sample_batched in enumerate(test_loader):
image, depth, label, image_name = sample_batched['image'], sample_batched['depth'], sample_batched['label'], \
sample_batched['image_name']
image = image.cuda()
depth = depth.cuda()
print(image_name)
# label = label.cuda()
output = F.softmax(model(image))
if args.rebuild_strategy == 'soft_sum':
depth_pred = soft_sum(output, args.discrete_strategy)
if args.rebuild_strategy == 'max':
depth_pred = max(output, args.discrete_strategy)
depth_pred = F.interpolate(depth_pred.float(),
size=[depth.size(2),
depth.size(3)],
mode='bilinear')
t = depth_pred.squeeze().float().cpu() / args.range
print(t.size())
results_imgs = ToPILImage()(depth_pred.squeeze().float().cpu() /
args.range)
if not os.path.exists(
str(args.img_path) + '/' + str(epoch) + 'epochs_results/'):
os.mkdir(str(args.img_path) + '/' + str(epoch) + 'epochs_results/')
results_imgs.save(
str(args.img_path) + '/' + str(epoch) + 'epochs_results/' +
str(image_name).strip(str([''])))
batchSize = depth.size(0)
totalNumber = totalNumber + batchSize
errors = util.evaluateError(depth_pred, depth)
errorSum = util.addErrors(errorSum, errors, batchSize)
averageError = util.averageErrors(errorSum, totalNumber)
averageError['RMSE'] = np.sqrt(averageError['MSE'])
print('epoch %d testing' % epoch)
print(averageError)
with open(os.path.join(args.save_path, 'records_val.csv'), 'a') as f:
f.write('%d,%f,%f,%f,%f,%f,%f,%f,%f\n' %
(epoch, averageError['MSE'], averageError['RMSE'],
averageError['ABS_REL'], averageError['LG10'],
averageError['MAE'], averageError['DELTA1'],
averageError['DELTA2'], averageError['DELTA3']))
return averageError['RMSE']
from lib.fpn.box_utils import bbox_loss
import torch.backends.cudnn as cudnn
from pycocotools.cocoeval import COCOeval
from lib.pytorch_misc import optimistic_restore, clip_grad_norm
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torchvision.transforms import Resize, Compose, ToTensor, Normalize, ToPILImage
from PIL import Image, ImageDraw, ImageFont
cudnn.benchmark = True
conf = ModelConfig()
tform = [
Normalize(mean=[0, 0, 0], std=[1 / 0.229, 1 / 0.224, 1 / 0.225]),
Normalize(mean=[-0.485, -0.456, -0.406], std=[1, 1, 1]),
ToPILImage()
]
# tform = [
# SquarePad(),
# Resize(IM_SCALE),
# ToTensor(),
# Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
# ]
transform_pipeline = Compose(tform)
font = ImageFont.truetype(
'/newNAS/Workspaces/UCGroup/gslu/aws_ailab/aws_server/freefont/FreeMonoBold.ttf',
12)
def draw_box(draw, boxx, text_str):
box = tuple([float(b) for b in boxx])
