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])