def interpolate_image(image, size=None, scale_factor=None, mode='nearest', align_corners=None, recompute_scale_factor=None): """ Simple wrapper around torch.nn.functional.interpolate() for 2D images. """ interpolated = torch.nn.functional.interpolate( image.view((1, 1) + image.shape), size, scale_factor, mode, align_corners, recompute_scale_factor) return interpolated.view(interpolated.shape[2:])
def __getitem__(self, index): img_id = self.images[index] #data = Image.open(img_id)#.reshape(1,28,28) image = io.imread(img_id) image = np.array(image).reshape(1, 28, 28) #print(image.shape) if self.transform is not None: image = self.transform(image) image = image.view(1, 28, 28) #print(image.shape) classes = self.classes[index] return image, classes
def main(): # choose the backbone architecture: is_resnet = True is_densenet = False is_senet = False model = define_model(is_resnet, is_densenet, is_senet) model = torch.nn.DataParallel(model).cuda() # load the pretrained model: if is_resnet: checkpoint = torch.load('./pretrained_model/resnet50_checkpoint.pth.tar') # model.load_state_dict(torch.load('./pretrained_model/model_resnet')) if is_densenet: checkpoint = torch.load('./pretrained_model/densenet_checkpoint.pth.tar') # model.load_state_dict(torch.load('./pretrained_model/model_densenet')) if is_senet: checkpoint = torch.load('./pretrained_model/senet_checkpoint.pth.tar') # model.load_state_dict(torch.load('./pretrained_model/model_senet')) model.load_state_dict(checkpoint['state_dict']) model.eval() imagesPath = './data/Autohich/gray_image/' image_loader = loaddata_autohich_gray.readImage(imagesPath) # print('-----++++transformed image:', type(image_loader)) # test(image_loader, model) times = [] for i, [image_name, image] in enumerate(image_loader): t1 = time.time() print('----------- i', i) print('---Input info:', image.size(), image_name) img_name = image_name[0] print('---Input name:', img_name) # get the original image for display&scale purposes image_original_path = os.path.join(imagesPath, img_name) image_original = matplotlib.pyplot.imread(image_original_path) #(H, W) = (800, 1280) # # image = torch.autograd.Variable(image, volatile=True).cuda() #bai2 old way # # torch.set_grad_enabled(False) #bai2 new way image = torch.Tensor(image).cuda() #bai2 new way image_RGB = image.view(image.size(2),image.size(3),image.size(1)).data.cpu().numpy() with torch.no_grad(): out = model(image) print('---Output info:', out.size()) t2 = time.time() times.append(t2-t1) times = times[-20:] # inference_time = sum(times)/len(times)*1000 inference_time = (t2-t1)*1000 # out = F.upsample(out, size=(out.size(2)*2, out.size(3)*2), mode='bilinear') out = F.upsample(out, size=(np.shape(image_original)[0], np.shape(image_original)[1]), mode='bilinear') output = out.view(out.size(2),out.size(3)).data.cpu().numpy() gray = output*0.229 + 0.485 # transform the depth output back into original value through imageNet mean & std print('\n**********************************************************************************************') print(' True Value of Depth Map: {}; max = {}, min={}'.format(np.shape(gray), np.amax(gray), np.amin(gray))) print(' Inference time = {:.2f}ms'.format(inference_time)) print('**********************************************************************************************\n') # fig, axs = plt.subplots(1,2) # axs[0].imshow(image_original, cmap='gray') # axs[0].set_title(img_name) # axs1 = axs[1].imshow(output, cmap='jet') # axs[1].set_title('depth_'+ img_name) # cbar1 = fig.colorbar(axs1, ax=axs[1], fraction=0.035, pad=0.035) # cbar1.minorticks_on() # plt.show() ########################################################################## ###### add the converted RGB image into the figure fig, axs = plt.subplots(1,3) axs[0].imshow(image_original, cmap='gray') axs[0].set_title(img_name) axs1 = axs[1].imshow(output, cmap='jet') axs[1].set_title('depth_'+ img_name) cbar1 = fig.colorbar(axs1, ax=axs[1], fraction=0.035, pad=0.035) cbar1.minorticks_on() axs[2].imshow(image_original) axs[2].set_title('RGB_' + img_name) plt.show()
def forward(self, x): x = self.encoder(x) return x num_epochs=200 classif=mlffn() criterion = nn.MSELoss() optimizer = torch.optim.Adam( classif.parameters(), lr=0.0001, weight_decay=1e-5) prev_loss=10000 for epoch in range(num_epochs): for data in dataloader: #print (data) img, clas = data img = img.view(img.size(0), -1) img = Variable(img) #print (img.shape),128,784 #print (clas) #clas=clas.type(torch.IntTensor) # ===================forward===================== #img = model.bottle(img) #print (img.shape) output = classif(img) #print (output[0][1].item()) # 128,784 loss = criterion(output, clas) # ===================backward==================== optimizer.zero_grad() loss.backward() optimizer.step()