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