diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2ff501d --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.ipynb_checkpoints +__pycache__ +**/.DS_Store diff --git a/README.md b/README.md new file mode 100644 index 0000000..9fbc856 --- /dev/null +++ b/README.md @@ -0,0 +1,82 @@ +# Neighbourhood Consensus Networks + +![](https://www.di.ens.fr/willow/research/ncnet/images/teaser.png) + + +## About + +This is the implementation of the paper "Neighbourhood Consensus Networks" by I. Rocco, M. Cimpoi, R. Arandjelović, A. Torii, T. Pajdla and J. Sivic. + +For more information check out the project [[website](http://www.di.ens.fr/willow/research/ncnet/)] and the paper on [[arXiv](https://arxiv.org/abs/1810.10510)]. + + +## Getting started + +### Dependencies + +The code is implemented using Python 3 and PyTorch 0.3. All dependencies should be included in the standard Anaconda distribution. + +### Getting the datasets + +The PF-Pascal dataset can be downloaded and unzipped by browsing to the `datasets/pf-pascal/` folder and running `download.sh`. + +The IVD dataset (used for training for the InLoc benchmark) can be downloaded and unzipped by browsing to the `datasets/ivd/` folder and first running `make_dirs.sh` and then `download.sh`. + +The InLoc dataset (used for evaluation) an be downloaded by browsing to the `datasets/inloc/` folder and running `download.sh`. + +### Getting the trained models + +The trained models trained on PF-Pascal (`ncnet_pfpascal.pth.tar`) and IVD (`ncnet_ivd.pth.tar`) can be dowloaded by browsing to the `trained_models/` folder and running `download.sh`. + +### Keypoint transfer demo + +The demo Jupyter notebook file `point_transfer_demo.py` illustrates how to evaluate the model and use it for keypoint transfer on the PF-Pascal dataset. For this, previously download the PF-Pascal dataset and trained model as indicated above. + +### Training + +To train a model, run `train.py` with the desired model architecture and the path to the training dataset. + +Eg. For PF-Pascal: + +```bash +python main.py --ncons_kernel_sizes 5 5 5 --ncons_channels 16 16 1 --dataset_image_path datasets/pf-pascal --dataset_csv_path datasets/pf-pascal/image_pairs/ +``` + +Eg. For InLoc: + +```bash +python main.py --ncons_kernel_sizes 3 3 --ncons_channels 16 1 --dataset_image_path datasets/ivd --dataset_csv_path datasets/ivd/image_pairs/ +``` + +### Evaluation on PF-Pascal + +Evaluation for PF-Pascal is implemented in the `eval_pf_pascal.py` file. You can run the evaluation in the following way: + +```bash +python eval_pf_pascal.py --checkpoint trained_models/[checkpoint name] +``` + +### Evaluation on InLoc + +Evaluation for PF-Pascal is implemented in the `eval_inloc.py` file. You can run the evaluation in the following way: + +```bash +python eval_inloc.py --checkpoint trained_models/[checkpoint name] +``` + +This will generate a series of matches files in the `matches/` folder that then need to be fed to the InLoc evaluation Matlab code. + + +## BibTeX + +If you use this code in your project, please cite our paper: +```` +@InProceedings{Rocco18b, + author = "Rocco, I. and Cimpoi, M. and Arandjelovi\'c, R. and Torii, A. and Pajdla, T. and Sivic, J." + title = "Neighbourhood Consensus Networks", + booktitle = "Proceedings of the 32nd Conference on Neural Information Processing Systems", + year = "2018", + } +```` + + diff --git a/datasets/inloc/LICENCE b/datasets/inloc/LICENCE new file mode 100644 index 0000000..c240927 --- /dev/null +++ b/datasets/inloc/LICENCE @@ -0,0 +1,35 @@ +InLoc dataset is made available under the Open Database License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in individual contents of the database are licensed under the Database Contents License: http://opendatacommons.org/licenses/dbcl/1.0/ +It contains information from Wustl Indoor RGBD dataset, which is made available here under the Open Database License http://opendatacommons.org/licenses/odbl/1.0/. +If you use our data, please cite our paper: + +@inproceedings{taira2018inloc, + title={{InLoc}: Indoor Visual Localization with Dense Matching and View Synthesis}, + author={Taira, Hajime and Okutomi, Masatoshi and Sattler, Torsten and Cimpoi, Mircea and Pollefeys, Marc and Sivic, Josef and Pajdla, Tomas and Torii, Akihiko}, + booktitle={{CVPR}}, + year={2018} +} + +and the paper presenting original Wustl Indoor RGBD dataset: + +@inproceedings{wijmans17rgbd, + author = {Erik Wijmans and + Yasutaka Furukawa}, + title = {Exploiting 2D Floorplan for Building-scale Panorama RGBD Alignment}, + booktitle = {Computer Vision and Pattern Recognition, {CVPR}}, + year = {2017}, + url = {http://cvpr17.wijmans.xyz/CVPR2017-0111.pdf} +} + + +Wustl Indoor RGBD dataset is made available under the Open Database License: http://opendatacommons.org/licenses/odbl/1.0/. Any rights in individual contents of the database are licensed under the Database Contents License: http://opendatacommons.org/licenses/dbcl/1.0/ + +If you use their data, please cite their paper: + +@inproceedings{wijmans17rgbd, + author = {Erik Wijmans and + Yasutaka Furukawa}, + title = {Exploiting 2D Floorplan for Building-scale Panorama RGBD Alignment}, + booktitle = {Computer Vision and Pattern Recognition, {CVPR}}, + year = {2017}, + url = {http://cvpr17.wijmans.xyz/CVPR2017-0111.pdf} +} \ No newline at end of file diff --git a/datasets/inloc/densePE_top100_shortlist_cvpr18.mat b/datasets/inloc/densePE_top100_shortlist_cvpr18.mat new file mode 100644 index 0000000..b9f8af6 Binary files /dev/null and b/datasets/inloc/densePE_top100_shortlist_cvpr18.mat differ diff --git a/datasets/inloc/download.sh b/datasets/inloc/download.sh new file mode 100644 index 0000000..d89367e --- /dev/null +++ b/datasets/inloc/download.sh @@ -0,0 +1,2 @@ +wget http://www.ok.sc.e.titech.ac.jp/INLOC/materials/cutouts.tar.gz +wget http://www.ok.sc.e.titech.ac.jp/INLOC/materials/iphone7.tar.gz \ No newline at end of file diff --git a/datasets/ivd/.gitignore b/datasets/ivd/.gitignore new file mode 100644 index 0000000..cfb4495 --- /dev/null +++ b/datasets/ivd/.gitignore @@ -0,0 +1,6 @@ +be/ +cz/ +dk/ +fr/ +gb/ +nl/ diff --git a/datasets/ivd/dirs.txt b/datasets/ivd/dirs.txt new file mode 100644 index 0000000..3bfa605 --- /dev/null +++ b/datasets/ivd/dirs.txt @@ -0,0 +1,89 @@ +be/Brussels/ChIJ0Yp2ZYDDw0cRhsIm9JySp4w +be/Brussels/ChIJ4Q93mHjEw0cRw_GTsvKSJts +be/Brussels/ChIJ4UP6DX_Ew0cRekV7szQb5cc +be/Brussels/ChIJ56wRXYfDw0cRYxIKrhOO91M +be/Brussels/ChIJ5ZZmOn_Ew0cRudnhY_vjyrM +be/Brussels/ChIJ7Z2QnYjDw0cRrOzR3G4prM8 +be/Brussels/ChIJa5YBW4fEw0cRXEdEmmrHNzM +be/Brussels/ChIJBb27mIDDw0cRLFEv29XVFKM +be/Brussels/ChIJKf3XZ4fDw0cRat9jjYgAuUQ +be/Brussels/ChIJob4Rz4fDw0cRxUKDwIISIT4 +be/Brussels/ChIJPYlgS4fEw0cRhva9IKvp0iQ +be/Brussels/ChIJV1d24pnEw0cRPiHMOM4Bv5g +be/Brussels/ChIJvTZ4_3_Dw0cRzSOE0556hYQ +be/Brussels/ChIJw7onk4DEw0cRgfFbQNy80II +be/Brussels/ChIJwQ0CZX_Dw0cRAgyG-NX_zKA +be/Brussels/ChIJXSgSyXnEw0cRC5dTsT6TDNw +be/Brussels/ChIJxVcg8nnEw0cR7HSIC7jELKM +cz/Prague/ChIJ23fPA_CUC0cR8r0Zdb5P65M +cz/Prague/ChIJ5xu1deqUC0cRABd7DkCu1wI +cz/Prague/ChIJ97RdLIOUC0cRw6synCh9ywk +cz/Prague/ChIJB2XzV_KUC0cR2XDxkOqS2IE +cz/Prague/ChIJgXj2so-UC0cR6fYoBN3omkc +cz/Prague/ChIJi1yKt5KUC0cRd7MVbEd2xi8 +cz/Prague/ChIJj5XMEO6UC0cRSdD6zoOKd3k +cz/Prague/ChIJJQeVZI-UC0cREeV8jNifDCs +cz/Prague/ChIJK9mieYGUC0cR0Ynne3yTYB4 +cz/Prague/ChIJpdPa4JSUC0cRL2SbDI32MKQ +cz/Prague/ChIJqW2dWIiUC0cRlRmF5kfyZCE +cz/Prague/ChIJQxyaBeGUC0cRZjpStOMuVMs +cz/Prague/ChIJS7Lkm52UC0cRrwqLxO9gZDo +cz/Prague/ChIJu2niIWeTC0cRHEJGY5xf_Io +cz/Prague/ChIJua9Ogo2UC0cRGmG8vsSar_I +cz/Prague/ChIJW08COB6VC0cRoonZ8lA4rWk +cz/Prague/ChIJwbOybpWUC0cR0Ie0VH2PcqY +cz/Prague/ChIJXXFEO-KUC0cRXxm7CSQYrzM +dk/Copenhagen/ChIJ36KzuxVTUkYRDDCgC3HCTGw +dk/Copenhagen/ChIJ6a9VvnNTUkYR70EJ8UFFlv0 +dk/Copenhagen/ChIJb1Q_gRBTUkYRBX_THfQTZqk +dk/Copenhagen/ChIJB57HZxBTUkYRognketO_9qs +dk/Copenhagen/ChIJCbqRvxZTUkYRGWI2eOd3tiw +dk/Copenhagen/ChIJfXQRBBNTUkYRoec4408un1k +dk/Copenhagen/ChIJGWMBpQ1TUkYRzYR5oWDqDhM +dk/Copenhagen/ChIJMTzE6yFTUkYR90_sHEhzRqc +dk/Copenhagen/ChIJoxxTLRFTUkYRJaF1B3HO14Y +dk/Copenhagen/ChIJPQeIbRdTUkYRs36mNmYz77Q +dk/Copenhagen/ChIJrfd4pHNTUkYRxMf6Mns9ZPk +dk/Copenhagen/ChIJU3W3ZBFTUkYRR1sx91IE5FM +dk/Copenhagen/ChIJvYWnuhhTUkYR3m95N7vDrmo +dk/Copenhagen/ChIJwdrCyAVTUkYRLM0WFavcxfY +dk/Copenhagen/ChIJxYb1Og5TUkYRWKm9JRjAiN8 +dk/Copenhagen/ChIJy84GHRFTUkYRY-FdhFM-nKI +dk/Copenhagen/ChIJye06RjlTUkYRK7RPt-oBGME +fr/Paris/ChIJ3_e_BiVu5kcRrhLcUCoJGnE +fr/Paris/ChIJ4bki89px5kcRVMlK4LFJbrU +fr/Paris/ChIJ65TvOyJw5kcRaLuvK3Qgz7E +fr/Paris/ChIJ_7ZXHuFx5kcRs1LnTeCsOBM +fr/Paris/ChIJ9wPDGP1t5kcRuU-2tWgnWOQ +fr/Paris/ChIJ9XyV5B5u5kcRA2PRdiGh4uY +fr/Paris/ChIJAVjEb9tx5kcRxWEv0cQd29s +fr/Paris/ChIJG5Qwtitu5kcR2CNEsYy9cdA +fr/Paris/ChIJjfAnTnFl5kcR0nn0H9Jwpz0 +fr/Paris/ChIJk0iY0udx5kcRzQmiht_HW6g +fr/Paris/ChIJoyC4CRxu5kcRRTPcWX5srLc +fr/Paris/ChIJqZ1K4UYN5kcR8GlGQjFFvzw +fr/Paris/ChIJryQ0vfxx5kcRwTFL9nbYZTU +fr/Paris/ChIJXUi-ScJv5kcRaUX9yJaj4ys +gb/Edinburgh/ChIJ1U2TFYbHh0gRLC_ZKcPAopo +gb/Edinburgh/ChIJ68bm6kjGh0gRkyF0XlT5Rww +gb/Edinburgh/ChIJ7xHasgG4h0gRdMGn6H6V9e8 +gb/Edinburgh/ChIJBXwTKpHHh0gRcN4_XRiKV7I +gb/Edinburgh/ChIJgYCnl3e4h0gRnTr0EPT_2zo +gb/Edinburgh/ChIJIeS60YTHh0gRw7W-8gMnzIg +gb/Edinburgh/ChIJJ21nqojHh0gRqelG4UPQbXU +gb/Edinburgh/ChIJQRw3B5HHh0gRGokny3GM2JY +gb/Edinburgh/ChIJsbrmBZHHh0gRzJntEk_0L50 +gb/Edinburgh/ChIJU0zUuprHh0gR7w-z7QSk85E +gb/Edinburgh/ChIJW9Jx15HHh0gRl1m9r1vbfS8 +nl/Amsterdam/ChIJ5Ra7we4JxkcRhYVAaq5zQ9U +nl/Amsterdam/ChIJ74XcqrgJxkcR9g0UqSG4KPU +nl/Amsterdam/ChIJO5oH0t0JxkcRKkXlC7IYHMA +nl/Amsterdam/ChIJS4P1Hb4JxkcRIphGLOfikzU +nl/Amsterdam/ChIJSxklPO0JxkcRCqxBkavK008 +nl/Amsterdam/ChIJtWMWEeAJxkcR7PV7zX9aRh0 +nl/Amsterdam/ChIJU2qVoLkJxkcRB8mgtNMmmEc +nl/Amsterdam/ChIJU9-Lo94JxkcRBzlvVAQV7n8 +nl/Amsterdam/ChIJV-jqPbkJxkcRVwprv5lxPkg +nl/Amsterdam/ChIJX1rTlu8JxkcRGsV8-a4oKMI +nl/Amsterdam/ChIJx_aU48UJxkcRxOEtx6d5Lng +nl/Amsterdam/ChIJySp1EbkJxkcRc3bwx1UJxcE diff --git a/datasets/ivd/download.sh b/datasets/ivd/download.sh new file mode 100644 index 0000000..34360d9 --- /dev/null +++ b/datasets/ivd/download.sh @@ -0,0 +1,2 @@ +1: + corr4d,delta4d=model({'source_image':src,'target_image':tgt}) + else: + corr4d=model({'source_image':src,'target_image':tgt}) + delta4d=None + + # reshape corr tensor and get matches for each point in image B + batch_size,ch,fs1,fs2,fs3,fs4 = corr4d.size() + + # pad image and plot + if plot: + h_max=int(np.max([src.shape[2],tgt.shape[2]])) + im=plot_image(torch.cat((padim(src,h_max),padim(tgt,h_max)),dim=3),return_im=True) + plt.imshow(im) + + if matching_both_directions: + (xA_,yA_,xB_,yB_,score_)=corr_to_matches(corr4d,scale='positive',do_softmax=do_softmax,delta4d=delta4d,k_size=k_size) + (xA2_,yA2_,xB2_,yB2_,score2_)=corr_to_matches(corr4d,scale='positive',do_softmax=do_softmax,delta4d=delta4d,k_size=k_size,invert_matching_direction=True) + xA_=torch.cat((xA_,xA2_),1) + yA_=torch.cat((yA_,yA2_),1) + xB_=torch.cat((xB_,xB2_),1) + yB_=torch.cat((yB_,yB2_),1) + score_=torch.cat((score_,score2_),1) + # sort in descending score (this will keep the max-score instance in the duplicate removal step) + sorted_index=torch.sort(-score_)[1].squeeze() + xA_=xA_.squeeze()[sorted_index].unsqueeze(0) + yA_=yA_.squeeze()[sorted_index].unsqueeze(0) + xB_=xB_.squeeze()[sorted_index].unsqueeze(0) + yB_=yB_.squeeze()[sorted_index].unsqueeze(0) + score_=score_.squeeze()[sorted_index].unsqueeze(0) + # remove duplicates + concat_coords=np.concatenate((xA_.cpu().data.numpy(),yA_.cpu().data.numpy(),xB_.cpu().data.numpy(),yB_.cpu().data.numpy()),0) + _,unique_index=np.unique(concat_coords,axis=1,return_index=True) + xA_=xA_.squeeze()[torch.cuda.LongTensor(unique_index)].unsqueeze(0) + yA_=yA_.squeeze()[torch.cuda.LongTensor(unique_index)].unsqueeze(0) + xB_=xB_.squeeze()[torch.cuda.LongTensor(unique_index)].unsqueeze(0) + yB_=yB_.squeeze()[torch.cuda.LongTensor(unique_index)].unsqueeze(0) + score_=score_.squeeze()[torch.cuda.LongTensor(unique_index)].unsqueeze(0) + elif flip_matching_direction: + (xA_,yA_,xB_,yB_,score_)=corr_to_matches(corr4d,scale='positive',do_softmax=do_softmax,delta4d=delta4d,k_size=k_size,invert_matching_direction=True) + else: + (xA_,yA_,xB_,yB_,score_)=corr_to_matches(corr4d,scale='positive',do_softmax=do_softmax,delta4d=delta4d,k_size=k_size) + + # recenter + if k_size>1: + yA_=yA_*(fs1*k_size-1)/(fs1*k_size)+0.5/(fs1*k_size) + xA_=xA_*(fs2*k_size-1)/(fs2*k_size)+0.5/(fs2*k_size) + yB_=yB_*(fs3*k_size-1)/(fs3*k_size)+0.5/(fs3*k_size) + xB_=xB_*(fs4*k_size-1)/(fs4*k_size)+0.5/(fs4*k_size) + else: + yA_=yA_*(fs1-1)/fs1+0.5/fs1 + xA_=xA_*(fs2-1)/fs2+0.5/fs2 + yB_=yB_*(fs3-1)/fs3+0.5/fs3 + xB_=xB_*(fs4-1)/fs4+0.5/fs4 + + xA = xA_.view(-1).data.cpu().float().numpy() + yA = yA_.view(-1).data.cpu().float().numpy() + xB = xB_.view(-1).data.cpu().float().numpy() + yB = yB_.view(-1).data.cpu().float().numpy() + score = score_.view(-1).data.cpu().float().numpy() + + Npts=len(xA) + if Npts>0: + matches[0,idx,:Npts,0]=xA + matches[0,idx,:Npts,1]=yA + matches[0,idx,:Npts,2]=xB + matches[0,idx,:Npts,3]=yB + matches[0,idx,:Npts,4]=score + + # plot top N matches + if plot: + c=numpy.random.rand(Npts,3) + for i in range(Npts): + if score[i]>0.75: + ax = plt.gca() + ax.add_artist(plt.Circle((float(xA[i])*src.shape[3],float(yA[i])*src.shape[2]), radius=3, color=c[i,:])) + ax.add_artist(plt.Circle((float(xB[i])*tgt.shape[3]+src.shape[3] ,float(yB[i])*tgt.shape[2]), radius=3, color=c[i,:])) + #plt.plot([float(xA[i])*src.shape[3], float(xB[i])*tgt.shape[3]+src.shape[3]], [float(yA[i])*src.shape[2], float(yB[i])*tgt.shape[2]], c='g', linestyle='-', linewidth=0.1) + + corr4d=None + delta4d=None + + if idx%10==0: + print(">>>"+str(idx)) + + savemat(os.path.join('matches/',output_folder,str(q+1)+'.mat'),{'matches':matches,'query_fn':db[q][0].item(),'pano_fn':pano_fn_all},do_compression=True) + +if plot: + plt.gcf().set_dpi(200) + plt.show() + diff --git a/eval_pf_pascal.py b/eval_pf_pascal.py new file mode 100644 index 0000000..c7b1328 --- /dev/null +++ b/eval_pf_pascal.py @@ -0,0 +1,89 @@ +from __future__ import print_function, division +import os +from os.path import exists +import numpy as np +import torch +import torch.nn as nn +from torch.utils.data import Dataset, DataLoader +from collections import OrderedDict + +from lib.model import ImMatchNet +from lib.pf_dataset import PFPascalDataset +from lib.normalization import NormalizeImageDict +from lib.torch_util import BatchTensorToVars, str_to_bool +from lib.point_tnf import corr_to_matches +from lib.eval_util import pck_metric +from lib.dataloader import default_collate +from lib.torch_util import collate_custom + +import argparse + + +print('NCNet evaluation script - PF Pascal dataset') + +use_cuda = torch.cuda.is_available() + +# Argument parsing +parser = argparse.ArgumentParser(description='Compute PF Pascal matches') +parser.add_argument('--checkpoint', type=str, default='') +parser.add_argument('--image_size', type=int, default=400) +parser.add_argument('--eval_dataset_path', type=str, default='datasets/pf-pascal/', help='path to PF Pascal dataset') + +args = parser.parse_args() + +# Create model +print('Creating CNN model...') +model = ImMatchNet(use_cuda=use_cuda, + checkpoint=args.checkpoint) + +# Dataset and dataloader +Dataset = PFPascalDataset +collate_fn = default_collate +csv_file = 'image_pairs/test_pairs.csv' + +cnn_image_size=(args.image_size,args.image_size) + +dataset = Dataset(csv_file=os.path.join(args.eval_dataset_path, csv_file), + dataset_path=args.eval_dataset_path, + transform=NormalizeImageDict(['source_image','target_image']), + output_size=cnn_image_size) +dataset.pck_procedure='scnet' + +# Only batch_size=1 is supported for evaluation +batch_size=1 + +dataloader = DataLoader(dataset, batch_size=batch_size, + shuffle=False, num_workers=0, + collate_fn=collate_fn) + +batch_tnf = BatchTensorToVars(use_cuda=use_cuda) + +model.eval() + +# initialize vector for storing results +stats={} +stats['point_tnf']={} +stats['point_tnf']['pck'] = np.zeros((len(dataset),1)) + +# Compute +for i, batch in enumerate(dataloader): + batch = batch_tnf(batch) + batch_start_idx=batch_size*i + + corr4d = model(batch) + + # get matches + xA,yA,xB,yB,sB=corr_to_matches(corr4d,do_softmax=True) + + matches=(xA,yA,xB,yB) + stats = pck_metric(batch,batch_start_idx,matches,stats,args,use_cuda) + + print('Batch: [{}/{} ({:.0f}%)]'.format(i, len(dataloader), 100. * i / len(dataloader))) + +# Print results +results=stats['point_tnf']['pck'] +good_idx = np.flatnonzero((results!=-1) * ~np.isnan(results)) +print('Total: '+str(results.size)) +print('Valid: '+str(good_idx.size)) +filtered_results = results[good_idx] +print('PCK:','{:.2%}'.format(np.mean(filtered_results))) \ No newline at end of file diff --git a/lib/conv4d.py b/lib/conv4d.py new file mode 100644 index 0000000..99a5e57 --- /dev/null +++ b/lib/conv4d.py @@ -0,0 +1,82 @@ +import math +import torch +from torch.nn.parameter import Parameter +import torch.nn.functional as F +from torch.nn import Module +from torch.nn.modules.conv import _ConvNd +from torch.nn.modules.utils import _quadruple +from torch.autograd import Variable +from torch.nn import Conv2d + +def conv4d(data,filters,bias=None,permute_filters=True,use_half=False): + b,c,h,w,d,t=data.size() + + data=data.permute(2,0,1,3,4,5).contiguous() # permute to avoid making contiguous inside loop + + # Same permutation is done with filters, unless already provided with permutation + if permute_filters: + filters=filters.permute(2,0,1,3,4,5).contiguous() # permute to avoid making contiguous inside loop + + c_out=filters.size(1) + if use_half: + output = Variable(torch.HalfTensor(h,b,c_out,w,d,t),requires_grad=data.requires_grad) + else: + output = Variable(torch.zeros(h,b,c_out,w,d,t),requires_grad=data.requires_grad) + + padding=filters.size(0)//2 + if use_half: + Z=Variable(torch.zeros(padding,b,c,w,d,t).half()) + else: + Z=Variable(torch.zeros(padding,b,c,w,d,t)) + + if data.is_cuda: + Z=Z.cuda(data.get_device()) + output=output.cuda(data.get_device()) + + data_padded = torch.cat((Z,data,Z),0) + + + for i in range(output.size(0)): # loop on first feature dimension + # convolve with center channel of filter (at position=padding) + output[i,:,:,:,:,:]=F.conv3d(data_padded[i+padding,:,:,:,:,:], + filters[padding,:,:,:,:,:], bias=bias, stride=1, padding=padding) + # convolve with upper/lower channels of filter (at postions [:padding] [padding+1:]) + for p in range(1,padding+1): + output[i,:,:,:,:,:]=output[i,:,:,:,:,:]+F.conv3d(data_padded[i+padding-p,:,:,:,:,:], + filters[padding-p,:,:,:,:,:], bias=None, stride=1, padding=padding) + output[i,:,:,:,:,:]=output[i,:,:,:,:,:]+F.conv3d(data_padded[i+padding+p,:,:,:,:,:], + filters[padding+p,:,:,:,:,:], bias=None, stride=1, padding=padding) + + output=output.permute(1,2,0,3,4,5).contiguous() + return output + +class Conv4d(_ConvNd): + """Applies a 4D convolution over an input signal composed of several input + planes. + """ + + def __init__(self, in_channels, out_channels, kernel_size, bias=True, pre_permuted_filters=True): + # stride, dilation and groups !=1 functionality not tested + stride=1 + dilation=1 + groups=1 + # zero padding is added automatically in conv4d function to preserve tensor size + padding = 0 + kernel_size = _quadruple(kernel_size) + stride = _quadruple(stride) + padding = _quadruple(padding) + dilation = _quadruple(dilation) + super(Conv4d, self).__init__( + in_channels, out_channels, kernel_size, stride, padding, dilation, + False, _quadruple(0), groups, bias) + # weights will be sliced along one dimension during convolution loop + # make the looping dimension to be the first one in the tensor, + # so that we don't need to call contiguous() inside the loop + self.pre_permuted_filters=pre_permuted_filters + if self.pre_permuted_filters: + self.weight.data=self.weight.data.permute(2,0,1,3,4,5).contiguous() + self.use_half=False + + + def forward(self, input): + return conv4d(input, self.weight, bias=self.bias,permute_filters=not self.pre_permuted_filters,use_half=self.use_half) # filters pre-permuted in constructor diff --git a/lib/dataloader.py b/lib/dataloader.py new file mode 100644 index 0000000..5a4cd76 --- /dev/null +++ b/lib/dataloader.py @@ -0,0 +1,316 @@ +import torch +import torch.multiprocessing as multiprocessing +from torch.utils.data.sampler import SequentialSampler, RandomSampler, BatchSampler +import collections +import sys +import traceback +import threading +import numpy as np +import numpy.random + +#from torch._six import string_classes +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 + +if PY2: + string_classes = basestring +else: + string_classes = (str, bytes) + + +if sys.version_info[0] == 2: + import Queue as queue +else: + import queue + + +_use_shared_memory = False +"""Whether to use shared memory in default_collate""" + + +class ExceptionWrapper(object): + "Wraps an exception plus traceback to communicate across threads" + + def __init__(self, exc_info): + self.exc_type = exc_info[0] + self.exc_msg = "".join(traceback.format_exception(*exc_info)) + + +def _worker_loop(dataset, index_queue, data_queue, collate_fn, rng_seed): + global _use_shared_memory + _use_shared_memory = True + + np.random.seed(rng_seed) + torch.set_num_threads(1) + while True: + r = index_queue.get() + if r is None: + data_queue.put(None) + break + idx, batch_indices = r + try: + samples = collate_fn([dataset[i] for i in batch_indices]) + except Exception: + data_queue.put((idx, ExceptionWrapper(sys.exc_info()))) + else: + data_queue.put((idx, samples)) + + +def _pin_memory_loop(in_queue, out_queue, done_event): + while True: + try: + r = in_queue.get() + except: + if done_event.is_set(): + return + raise + if r is None: + break + if isinstance(r[1], ExceptionWrapper): + out_queue.put(r) + continue + idx, batch = r + try: + batch = pin_memory_batch(batch) + except Exception: + out_queue.put((idx, ExceptionWrapper(sys.exc_info()))) + else: + out_queue.put((idx, batch)) + + +numpy_type_map = { + 'float64': torch.DoubleTensor, + 'float32': torch.FloatTensor, + 'float16': torch.HalfTensor, + 'int64': torch.LongTensor, + 'int32': torch.IntTensor, + 'int16': torch.ShortTensor, + 'int8': torch.CharTensor, + 'uint8': torch.ByteTensor, +} + + +def default_collate(batch): + "Puts each data field into a tensor with outer dimension batch size" + if torch.is_tensor(batch[0]): + out = None + if _use_shared_memory: + # If we're in a background process, concatenate directly into a + # shared memory tensor to avoid an extra copy + numel = sum([x.numel() for x in batch]) + storage = batch[0].storage()._new_shared(numel) + out = batch[0].new(storage) + return torch.stack(batch, 0, out=out) + elif type(batch[0]).__module__ == 'numpy': + elem = batch[0] + if type(elem).__name__ == 'ndarray': + return torch.stack([torch.from_numpy(b) for b in batch], 0) + if elem.shape == (): # scalars + py_type = float if elem.dtype.name.startswith('float') else int + return numpy_type_map[elem.dtype.name](list(map(py_type, batch))) + elif isinstance(batch[0], int): + return torch.LongTensor(batch) + elif isinstance(batch[0], float): + return torch.DoubleTensor(batch) + elif isinstance(batch[0], string_classes): + return batch + elif isinstance(batch[0], collections.Mapping): + return {key: default_collate([d[key] for d in batch]) for key in batch[0]} + elif isinstance(batch[0], collections.Sequence): + transposed = zip(*batch) + return [default_collate(samples) for samples in transposed] + + raise TypeError(("batch must contain tensors, numbers, dicts or lists; found {}" + .format(type(batch[0])))) + + +def pin_memory_batch(batch): + if torch.is_tensor(batch): + return batch.pin_memory() + elif isinstance(batch, string_classes): + return batch + elif isinstance(batch, collections.Mapping): + return {k: pin_memory_batch(sample) for k, sample in batch.items()} + elif isinstance(batch, collections.Sequence): + return [pin_memory_batch(sample) for sample in batch] + else: + return batch + + +class DataLoaderIter(object): + "Iterates once over the DataLoader's dataset, as specified by the sampler" + + def __init__(self, loader): + self.dataset = loader.dataset + self.collate_fn = loader.collate_fn + self.batch_sampler = loader.batch_sampler + self.num_workers = loader.num_workers + self.pin_memory = loader.pin_memory + self.done_event = threading.Event() + + self.sample_iter = iter(self.batch_sampler) + + if self.num_workers > 0: + self.index_queue = multiprocessing.SimpleQueue() + self.data_queue = multiprocessing.SimpleQueue() + self.batches_outstanding = 0 + self.shutdown = False + self.send_idx = 0 + self.rcvd_idx = 0 + self.reorder_dict = {} + + self.workers = [ + multiprocessing.Process( + target=_worker_loop, + args=(self.dataset, self.index_queue, self.data_queue, self.collate_fn, np.random.randint(0, 4294967296, dtype='uint32'))) + for _ in range(self.num_workers)] + + for w in self.workers: + w.daemon = True # ensure that the worker exits on process exit + w.start() + + if self.pin_memory: + in_data = self.data_queue + self.data_queue = queue.Queue() + self.pin_thread = threading.Thread( + target=_pin_memory_loop, + args=(in_data, self.data_queue, self.done_event)) + self.pin_thread.daemon = True + self.pin_thread.start() + + # prime the prefetch loop + for _ in range(2 * self.num_workers): + self._put_indices() + + def __len__(self): + return len(self.batch_sampler) + + def __next__(self): + if self.num_workers == 0: # same-process loading + indices = next(self.sample_iter) # may raise StopIteration + batch = self.collate_fn([self.dataset[i] for i in indices]) + if self.pin_memory: + batch = pin_memory_batch(batch) + return batch + + # check if the next sample has already been generated + if self.rcvd_idx in self.reorder_dict: + batch = self.reorder_dict.pop(self.rcvd_idx) + return self._process_next_batch(batch) + + if self.batches_outstanding == 0: + self._shutdown_workers() + raise StopIteration + + while True: + assert (not self.shutdown and self.batches_outstanding > 0) + idx, batch = self.data_queue.get() + self.batches_outstanding -= 1 + if idx != self.rcvd_idx: + # store out-of-order samples + self.reorder_dict[idx] = batch + continue + return self._process_next_batch(batch) + + next = __next__ # Python 2 compatibility + + def __iter__(self): + return self + + def _put_indices(self): + assert self.batches_outstanding < 2 * self.num_workers + indices = next(self.sample_iter, None) + if indices is None: + return + self.index_queue.put((self.send_idx, indices)) + self.batches_outstanding += 1 + self.send_idx += 1 + + def _process_next_batch(self, batch): + self.rcvd_idx += 1 + self._put_indices() + if isinstance(batch, ExceptionWrapper): + raise batch.exc_type(batch.exc_msg) + return batch + + def __getstate__(self): + # TODO: add limited pickling support for sharing an iterator + # across multiple threads for HOGWILD. + # Probably the best way to do this is by moving the sample pushing + # to a separate thread and then just sharing the data queue + # but signalling the end is tricky without a non-blocking API + raise NotImplementedError("DataLoaderIterator cannot be pickled") + + def _shutdown_workers(self): + if not self.shutdown: + self.shutdown = True + self.done_event.set() + for _ in self.workers: + self.index_queue.put(None) + + def __del__(self): + if self.num_workers > 0: + self._shutdown_workers() + + +class DataLoader(object): + """ + Data loader. Combines a dataset and a sampler, and provides + single- or multi-process iterators over the dataset. + + Arguments: + dataset (Dataset): dataset from which to load the data. + batch_size (int, optional): how many samples per batch to load + (default: 1). + shuffle (bool, optional): set to ``True`` to have the data reshuffled + at every epoch (default: False). + sampler (Sampler, optional): defines the strategy to draw samples from + the dataset. If specified, ``shuffle`` must be False. + batch_sampler (Sampler, optional): like sampler, but returns a batch of + indices at a time. Mutually exclusive with batch_size, shuffle, + sampler, and drop_last. + num_workers (int, optional): how many subprocesses to use for data + loading. 0 means that the data will be loaded in the main process + (default: 0) + collate_fn (callable, optional): merges a list of samples to form a mini-batch. + pin_memory (bool, optional): If ``True``, the data loader will copy tensors + into CUDA pinned memory before returning them. + drop_last (bool, optional): set to ``True`` to drop the last incomplete batch, + if the dataset size is not divisible by the batch size. If False and + the size of dataset is not divisible by the batch size, then the last batch + will be smaller. (default: False) + """ + + def __init__(self, dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, + num_workers=0, collate_fn=default_collate, pin_memory=False, drop_last=False): + self.dataset = dataset + self.batch_size = batch_size + self.num_workers = num_workers + self.collate_fn = collate_fn + self.pin_memory = pin_memory + self.drop_last = drop_last + + if batch_sampler is not None: + if batch_size > 1 or shuffle or sampler is not None or drop_last: + raise ValueError('batch_sampler is mutually exclusive with ' + 'batch_size, shuffle, sampler, and drop_last') + + if sampler is not None and shuffle: + raise ValueError('sampler is mutually exclusive with shuffle') + + if batch_sampler is None: + if sampler is None: + if shuffle: + sampler = RandomSampler(dataset) + else: + sampler = SequentialSampler(dataset) + batch_sampler = BatchSampler(sampler, batch_size, drop_last) + + self.sampler = sampler + self.batch_sampler = batch_sampler + + def __iter__(self): + return DataLoaderIter(self) + + def __len__(self): + return len(self.batch_sampler) \ No newline at end of file diff --git a/lib/eval_util.py b/lib/eval_util.py new file mode 100644 index 0000000..e1d669f --- /dev/null +++ b/lib/eval_util.py @@ -0,0 +1,51 @@ +import torch +import torch.nn +import numpy as np +import os +from skimage import draw +import torch.nn.functional as F +from torch.autograd import Variable +from lib.pf_dataset import PFPascalDataset +from lib.point_tnf import PointsToUnitCoords, PointsToPixelCoords, bilinearInterpPointTnf + + +def pck(source_points,warped_points,L_pck,alpha=0.1): + # compute precentage of correct keypoints + batch_size=source_points.size(0) + pck=torch.zeros((batch_size)) + for i in range(batch_size): + p_src = source_points[i,:] + p_wrp = warped_points[i,:] + N_pts = torch.sum(torch.ne(p_src[0,:],-1)*torch.ne(p_src[1,:],-1)) + point_distance = torch.pow(torch.sum(torch.pow(p_src[:,:N_pts]-p_wrp[:,:N_pts],2),0),0.5) + L_pck_mat = L_pck[i].expand_as(point_distance) + correct_points = torch.le(point_distance,L_pck_mat*alpha) + pck[i]=torch.mean(correct_points.float()) + return pck + + +def pck_metric(batch,batch_start_idx,matches,stats,args,use_cuda=True): + + source_im_size = batch['source_im_size'] + target_im_size = batch['target_im_size'] + + source_points = batch['source_points'] + target_points = batch['target_points'] + + # warp points with estimated transformations + target_points_norm = PointsToUnitCoords(target_points,target_im_size) + + # compute points stage 1 only + warped_points_norm = bilinearInterpPointTnf(matches,target_points_norm) + warped_points = PointsToPixelCoords(warped_points_norm,source_im_size) + + L_pck = batch['L_pck'].data + + current_batch_size=batch['source_im_size'].size(0) + indices = range(batch_start_idx,batch_start_idx+current_batch_size) + + # compute PCK + pck_batch = pck(source_points.data, warped_points.data, L_pck) + stats['point_tnf']['pck'][indices] = pck_batch.unsqueeze(1).cpu().numpy() + + return stats \ No newline at end of file diff --git a/lib/im_pair_dataset.py b/lib/im_pair_dataset.py new file mode 100644 index 0000000..6174698 --- /dev/null +++ b/lib/im_pair_dataset.py @@ -0,0 +1,94 @@ +from __future__ import print_function, division +import os +import torch +from torch.autograd import Variable +from torch.utils.data import Dataset +from skimage import io +import pandas as pd +import numpy as np +from lib.transformation import AffineTnf + +class ImagePairDataset(Dataset): + + """ + + Image pair dataset used for weak supervision + + + Args: + csv_file (string): Path to the csv file with image names and transformations. + training_image_path (string): Directory with the images. + output_size (2-tuple): Desired output size + transform (callable): Transformation for post-processing the training pair (eg. image normalization) + + """ + + def __init__(self, dataset_csv_path, dataset_csv_file, dataset_image_path, dataset_size=0,output_size=(240,240),transform=None,random_crop=False): + self.random_crop=random_crop + self.out_h, self.out_w = output_size + self.train_data = pd.read_csv(os.path.join(dataset_csv_path,dataset_csv_file)) + if dataset_size is not None and dataset_size!=0: + dataset_size = min((dataset_size,len(self.train_data))) + self.train_data = self.train_data.iloc[0:dataset_size,:] + self.img_A_names = self.train_data.iloc[:,0] + self.img_B_names = self.train_data.iloc[:,1] + self.set = self.train_data.iloc[:,2].as_matrix() + self.flip = self.train_data.iloc[:, 3].as_matrix().astype('int') + self.dataset_image_path = dataset_image_path + self.transform = transform + # no cuda as dataset is called from CPU threads in dataloader and produces confilct + self.affineTnf = AffineTnf(out_h=self.out_h, out_w=self.out_w, use_cuda = False) + + def __len__(self): + return len(self.img_A_names) + + def __getitem__(self, idx): + # get pre-processed images + image_A,im_size_A = self.get_image(self.img_A_names,idx,self.flip[idx]) + image_B,im_size_B = self.get_image(self.img_B_names,idx,self.flip[idx]) + + image_set = self.set[idx] + + sample = {'source_image': image_A, 'target_image': image_B, 'source_im_size': im_size_A, 'target_im_size': im_size_B, 'set':image_set} + + if self.transform: + sample = self.transform(sample) + + return sample + + def get_image(self,img_name_list,idx,flip): + img_name = os.path.join(self.dataset_image_path, img_name_list.iloc[idx]) + image = io.imread(img_name) + + # if grayscale convert to 3-channel image + if image.ndim==2: + image=np.repeat(np.expand_dims(image,2),axis=2,repeats=3) + + # do random crop + if self.random_crop: + h,w,c=image.shape + top=np.random.randint(h/4) + bottom=int(3*h/4+np.random.randint(h/4)) + left=np.random.randint(w/4) + right=int(3*w/4+np.random.randint(w/4)) + image = image[top:bottom,left:right,:] + + # flip horizontally if needed + if flip: + image=np.flip(image,1) + + # get image size + im_size = np.asarray(image.shape) + + # convert to torch Variable + image = np.expand_dims(image.transpose((2,0,1)),0) + image = torch.Tensor(image.astype(np.float32)) + image_var = Variable(image,requires_grad=False) + + # Resize image using bilinear sampling with identity affine tnf + image = self.affineTnf(image_var).data.squeeze(0) + + im_size = torch.Tensor(im_size.astype(np.float32)) + + return (image, im_size) + diff --git a/lib/model.py b/lib/model.py new file mode 100644 index 0000000..ea3eb16 --- /dev/null +++ b/lib/model.py @@ -0,0 +1,283 @@ +from __future__ import print_function, division +from collections import OrderedDict +import torch +import torch.nn as nn +from torch.autograd import Variable +import torchvision.models as models +import numpy as np +import numpy.matlib +import pickle + +from lib.torch_util import Softmax1D +from lib.conv4d import Conv4d + +def featureL2Norm(feature): + epsilon = 1e-6 + norm = torch.pow(torch.sum(torch.pow(feature,2),1)+epsilon,0.5).unsqueeze(1).expand_as(feature) + return torch.div(feature,norm) + +class FeatureExtraction(torch.nn.Module): + def __init__(self, train_fe=False, feature_extraction_cnn='resnet101', feature_extraction_model_file='', normalization=True, last_layer='', use_cuda=True): + super(FeatureExtraction, self).__init__() + self.normalization = normalization + self.feature_extraction_cnn=feature_extraction_cnn + if feature_extraction_cnn == 'vgg': + self.model = models.vgg16(pretrained=True) + # keep feature extraction network up to indicated layer + vgg_feature_layers=['conv1_1','relu1_1','conv1_2','relu1_2','pool1','conv2_1', + 'relu2_1','conv2_2','relu2_2','pool2','conv3_1','relu3_1', + 'conv3_2','relu3_2','conv3_3','relu3_3','pool3','conv4_1', + 'relu4_1','conv4_2','relu4_2','conv4_3','relu4_3','pool4', + 'conv5_1','relu5_1','conv5_2','relu5_2','conv5_3','relu5_3','pool5'] + if last_layer=='': + last_layer = 'pool4' + last_layer_idx = vgg_feature_layers.index(last_layer) + self.model = nn.Sequential(*list(self.model.features.children())[:last_layer_idx+1]) + # for resnet below + resnet_feature_layers = ['conv1','bn1','relu','maxpool','layer1','layer2','layer3','layer4'] + if feature_extraction_cnn=='resnet101': + self.model = models.resnet101(pretrained=True) + if last_layer=='': + last_layer = 'layer3' + resnet_module_list = [getattr(self.model,l) for l in resnet_feature_layers] + last_layer_idx = resnet_feature_layers.index(last_layer) + self.model = nn.Sequential(*resnet_module_list[:last_layer_idx+1]) + + if feature_extraction_cnn=='resnet101fpn': + if feature_extraction_model_file!='': + resnet = models.resnet101(pretrained=True) + # swap stride (2,2) and (1,1) in first layers (PyTorch ResNet is slightly different to caffe2 ResNet) + # this is required for compatibility with caffe2 models + resnet.layer2[0].conv1.stride=(2,2) + resnet.layer2[0].conv2.stride=(1,1) + resnet.layer3[0].conv1.stride=(2,2) + resnet.layer3[0].conv2.stride=(1,1) + resnet.layer4[0].conv1.stride=(2,2) + resnet.layer4[0].conv2.stride=(1,1) + else: + resnet = models.resnet101(pretrained=True) + resnet_module_list = [getattr(resnet,l) for l in resnet_feature_layers] + conv_body = nn.Sequential(*resnet_module_list) + self.model = fpn_body(conv_body, + resnet_feature_layers, + fpn_layers=['layer1','layer2','layer3'], + normalize=normalization, + hypercols=True) + if feature_extraction_model_file!='': + self.model.load_pretrained_weights(feature_extraction_model_file) + + if feature_extraction_cnn == 'densenet201': + self.model = models.densenet201(pretrained=True) + # keep feature extraction network up to denseblock3 + # self.model = nn.Sequential(*list(self.model.features.children())[:-3]) + # keep feature extraction network up to transitionlayer2 + self.model = nn.Sequential(*list(self.model.features.children())[:-4]) + if train_fe==False: + # freeze parameters + for param in self.model.parameters(): + param.requires_grad = False + # move to GPU + if use_cuda: + self.model = self.model.cuda() + + def forward(self, image_batch): + features = self.model(image_batch) + if self.normalization and not self.feature_extraction_cnn=='resnet101fpn': + features = featureL2Norm(features) + return features + +class FeatureCorrelation(torch.nn.Module): + def __init__(self,shape='3D',normalization=True): + super(FeatureCorrelation, self).__init__() + self.normalization = normalization + self.shape=shape + self.ReLU = nn.ReLU() + + def forward(self, feature_A, feature_B): + if self.shape=='3D': + b,c,h,w = feature_A.size() + # reshape features for matrix multiplication + feature_A = feature_A.transpose(2,3).contiguous().view(b,c,h*w) + feature_B = feature_B.view(b,c,h*w).transpose(1,2) + # perform matrix mult. + feature_mul = torch.bmm(feature_B,feature_A) + # indexed [batch,idx_A=row_A+h*col_A,row_B,col_B] + correlation_tensor = feature_mul.view(b,h,w,h*w).transpose(2,3).transpose(1,2) + elif self.shape=='4D': + b,c,hA,wA = feature_A.size() + b,c,hB,wB = feature_B.size() + # reshape features for matrix multiplication + feature_A = feature_A.view(b,c,hA*wA).transpose(1,2) # size [b,c,h*w] + feature_B = feature_B.view(b,c,hB*wB) # size [b,c,h*w] + # perform matrix mult. + feature_mul = torch.bmm(feature_A,feature_B) + # indexed [batch,row_A,col_A,row_B,col_B] + correlation_tensor = feature_mul.view(b,hA,wA,hB,wB).unsqueeze(1) + + if self.normalization: + correlation_tensor = featureL2Norm(self.ReLU(correlation_tensor)) + + return correlation_tensor + +class NeighConsensus(torch.nn.Module): + def __init__(self, use_cuda=True, kernel_sizes=[3,3,3], channels=[10,10,1], symmetric_mode=True): + super(NeighConsensus, self).__init__() + self.symmetric_mode = symmetric_mode + self.kernel_sizes = kernel_sizes + self.channels = channels + num_layers = len(kernel_sizes) + nn_modules = list() + for i in range(num_layers): + if i==0: + ch_in = 1 + else: + ch_in = channels[i-1] + ch_out = channels[i] + k_size = kernel_sizes[i] + nn_modules.append(Conv4d(in_channels=ch_in,out_channels=ch_out,kernel_size=k_size,bias=True)) + nn_modules.append(nn.ReLU(inplace=True)) + self.conv = nn.Sequential(*nn_modules) + if use_cuda: + self.conv.cuda() + + def forward(self, x): + if self.symmetric_mode: + # apply network on the input and its "transpose" (swapping A-B to B-A ordering of the correlation tensor), + # this second result is "transposed back" to the A-B ordering to match the first result and be able to add together + x = self.conv(x)+self.conv(x.permute(0,1,4,5,2,3)).permute(0,1,4,5,2,3) + # because of the ReLU layers in between linear layers, + # this operation is different than convolving a single time with the filters+filters^T + # and therefore it makes sense to do this. + else: + x = self.conv(x) + return x + +def MutualMatching(corr4d): + # mutual matching + batch_size,ch,fs1,fs2,fs3,fs4 = corr4d.size() + + corr4d_B=corr4d.view(batch_size,fs1*fs2,fs3,fs4) # [batch_idx,k_A,i_B,j_B] + corr4d_A=corr4d.view(batch_size,fs1,fs2,fs3*fs4) + + # get max + corr4d_B_max,_=torch.max(corr4d_B,dim=1,keepdim=True) + corr4d_A_max,_=torch.max(corr4d_A,dim=3,keepdim=True) + + eps = 1e-5 + corr4d_B=corr4d_B/(corr4d_B_max+eps) + corr4d_A=corr4d_A/(corr4d_A_max+eps) + + corr4d_B=corr4d_B.view(batch_size,1,fs1,fs2,fs3,fs4) + corr4d_A=corr4d_A.view(batch_size,1,fs1,fs2,fs3,fs4) + + corr4d=corr4d*(corr4d_A*corr4d_B) # parenthesis are important for symmetric output + + return corr4d + +def maxpool4d(corr4d_hres,k_size=4): + slices=[] + for i in range(k_size): + for j in range(k_size): + for k in range(k_size): + for l in range(k_size): + slices.append(corr4d_hres[:,0,i::k_size,j::k_size,k::k_size,l::k_size].unsqueeze(0)) + slices=torch.cat(tuple(slices),dim=1) + corr4d,max_idx=torch.max(slices,dim=1,keepdim=True) + max_l=torch.fmod(max_idx,k_size) + max_k=torch.fmod(max_idx.sub(max_l).div(k_size),k_size) + max_j=torch.fmod(max_idx.sub(max_l).div(k_size).sub(max_k).div(k_size),k_size) + max_i=max_idx.sub(max_l).div(k_size).sub(max_k).div(k_size).sub(max_j).div(k_size) + # i,j,k,l represent the *relative* coords of the max point in the box of size k_size*k_size*k_size*k_size + return (corr4d,max_i,max_j,max_k,max_l) + +class ImMatchNet(nn.Module): + def __init__(self, + feature_extraction_cnn='resnet101', + feature_extraction_last_layer='', + feature_extraction_model_file=None, + return_correlation=False, + ncons_kernel_sizes=[3,3,3], + ncons_channels=[10,10,1], + normalize_features=True, + train_fe=False, + use_cuda=True, + relocalization_k_size=0, + half_precision=False, + checkpoint=None, + ): + + super(ImMatchNet, self).__init__() + # Load checkpoint + if checkpoint is not None and checkpoint is not '': + print('Loading checkpoint...') + checkpoint = torch.load(checkpoint, map_location=lambda storage, loc: storage) + checkpoint['state_dict'] = OrderedDict([(k.replace('vgg', 'model'), v) for k, v in checkpoint['state_dict'].items()]) + # override relevant parameters + print('Using checkpoint parameters: ') + ncons_channels=checkpoint['args'].ncons_channels + print(' ncons_channels: '+str(ncons_channels)) + ncons_kernel_sizes=checkpoint['args'].ncons_kernel_sizes + print(' ncons_kernel_sizes: '+str(ncons_kernel_sizes)) + + self.use_cuda = use_cuda + self.normalize_features = normalize_features + self.return_correlation = return_correlation + self.relocalization_k_size = relocalization_k_size + self.half_precision = half_precision + + self.FeatureExtraction = FeatureExtraction(train_fe=train_fe, + feature_extraction_cnn=feature_extraction_cnn, + feature_extraction_model_file=feature_extraction_model_file, + last_layer=feature_extraction_last_layer, + normalization=normalize_features, + use_cuda=self.use_cuda) + + self.FeatureCorrelation = FeatureCorrelation(shape='4D',normalization=False) + + self.NeighConsensus = NeighConsensus(use_cuda=self.use_cuda, + kernel_sizes=ncons_kernel_sizes, + channels=ncons_channels) + + # Load weights + if checkpoint is not None and checkpoint is not '': + print('Copying weights...') + for name, param in self.FeatureExtraction.state_dict().items(): + if 'num_batches_tracked' not in name: + self.FeatureExtraction.state_dict()[name].copy_(checkpoint['state_dict']['FeatureExtraction.' + name]) + for name, param in self.NeighConsensus.state_dict().items(): + self.NeighConsensus.state_dict()[name].copy_(checkpoint['state_dict']['NeighConsensus.' + name]) + print('Done!') + + self.FeatureExtraction.eval() + + if self.half_precision: + for p in self.NeighConsensus.parameters(): + p.data=p.data.half() + for l in self.NeighConsensus.conv: + if isinstance(l,Conv4d): + l.use_half=True + + # used only for foward pass at eval and for training with strong supervision + def forward(self, tnf_batch): + # feature extraction + feature_A = self.FeatureExtraction(tnf_batch['source_image']) + feature_B = self.FeatureExtraction(tnf_batch['target_image']) + if self.half_precision: + feature_A=feature_A.half() + feature_B=feature_B.half() + # feature correlation + corr4d = self.FeatureCorrelation(feature_A,feature_B) + # do 4d maxpooling for relocalization + if self.relocalization_k_size>1: + corr4d,max_i,max_j,max_k,max_l=maxpool4d(corr4d,k_size=self.relocalization_k_size) + # run match processing model + corr4d = MutualMatching(corr4d) + corr4d = self.NeighConsensus(corr4d) + corr4d = MutualMatching(corr4d) + + if self.relocalization_k_size>1: + delta4d=(max_i,max_j,max_k,max_l) + return (corr4d,delta4d) + else: + return corr4d + diff --git a/lib/normalization.py b/lib/normalization.py new file mode 100644 index 0000000..5be83e2 --- /dev/null +++ b/lib/normalization.py @@ -0,0 +1,50 @@ +import torch +from torchvision import transforms +from torch.autograd import Variable + +class NormalizeImageDict(object): + """ + + Normalizes Tensor images in dictionary + + Args: + image_keys (list): dict. keys of the images to be normalized + normalizeRange (bool): if True the image is divided by 255.0s + + """ + + def __init__(self,image_keys,normalizeRange=True): + self.image_keys = image_keys + self.normalizeRange=normalizeRange + self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) + + def __call__(self, sample): + for key in self.image_keys: + if self.normalizeRange: + sample[key] /= 255.0 + sample[key] = self.normalize(sample[key]) + return sample + +def normalize_image(image, forward=True, mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]): + im_size = image.size() + mean=torch.FloatTensor(mean).unsqueeze(1).unsqueeze(2) + std=torch.FloatTensor(std).unsqueeze(1).unsqueeze(2) + if image.is_cuda: + mean = mean.cuda() + std = std.cuda() + if isinstance(image,torch.autograd.variable.Variable): + mean = Variable(mean,requires_grad=False) + std = Variable(std,requires_grad=False) + if forward: + if len(im_size)==3: + result = image.sub(mean.expand(im_size)).div(std.expand(im_size)) + elif len(im_size)==4: + result = image.sub(mean.unsqueeze(0).expand(im_size)).div(std.unsqueeze(0).expand(im_size)) + else: + if len(im_size)==3: + result = image.mul(std.expand(im_size)).add(mean.expand(im_size)) + elif len(im_size)==4: + result = image.mul(std.unsqueeze(0).expand(im_size)).add(mean.unsqueeze(0).expand(im_size)) + + return result \ No newline at end of file diff --git a/lib/pf_dataset.py b/lib/pf_dataset.py new file mode 100644 index 0000000..325dce1 --- /dev/null +++ b/lib/pf_dataset.py @@ -0,0 +1,114 @@ +from __future__ import print_function, division +import os +import torch +from torch.autograd import Variable +from skimage import io +import pandas as pd +import numpy as np +from torch.utils.data import Dataset +from lib.transformation import AffineTnf + +class PFPascalDataset(Dataset): + + """ + + Proposal Flow PASCAL image pair dataset + + + Args: + csv_file (string): Path to the csv file with image names and transformations. + dataset_path (string): Directory with the images. + output_size (2-tuple): Desired output size + transform (callable): Transformation for post-processing the training pair (eg. image normalization) + + """ + + def __init__(self, csv_file, dataset_path, output_size=(240,240), transform=None, category=None, pck_procedure='pf'): + + self.category_names=['aeroplane','bicycle','bird','boat','bottle','bus','car','cat','chair','cow','diningtable','dog','horse','motorbike','person','pottedplant','sheep','sofa','train','tvmonitor'] + self.out_h, self.out_w = output_size + self.pairs = pd.read_csv(csv_file) + self.category = self.pairs.iloc[:,2].as_matrix().astype('float') + if category is not None: + cat_idx = np.nonzero(self.category==category)[0] + self.category=self.category[cat_idx] + self.pairs=self.pairs.iloc[cat_idx,:] + self.img_A_names = self.pairs.iloc[:,0] + self.img_B_names = self.pairs.iloc[:,1] + self.point_A_coords = self.pairs.iloc[:, 3:5] + self.point_B_coords = self.pairs.iloc[:, 5:] + self.dataset_path = dataset_path + self.transform = transform + # no cuda as dataset is called from CPU threads in dataloader and produces confilct + self.affineTnf = AffineTnf(out_h=self.out_h, out_w=self.out_w, use_cuda = False) + self.pck_procedure = pck_procedure + + def __len__(self): + return len(self.pairs) + + def __getitem__(self, idx): + # get pre-processed images + image_A,im_size_A = self.get_image(self.img_A_names,idx) + image_B,im_size_B = self.get_image(self.img_B_names,idx) + + # get pre-processed point coords + point_A_coords = self.get_points(self.point_A_coords,idx) + point_B_coords = self.get_points(self.point_B_coords,idx) + + # compute PCK reference length L_pck (equal to max bounding box side in image_A) + #L_pck = torch.FloatTensor([torch.max(point_A_coords.max(1)[0]-point_A_coords.min(1)[0])]) + N_pts = torch.sum(torch.ne(point_A_coords[0,:],-1)) + + if self.pck_procedure=='pf': + L_pck = torch.FloatTensor([torch.max(point_A_coords[:,:N_pts].max(1)[0]-point_A_coords[:,:N_pts].min(1)[0])]) + elif self.pck_procedure=='scnet': + #modification to follow the evaluation procedure of SCNet + point_A_coords[0,0:N_pts]=point_A_coords[0,0:N_pts]*224/im_size_A[1] + point_A_coords[1,0:N_pts]=point_A_coords[1,0:N_pts]*224/im_size_A[0] + + point_B_coords[0,0:N_pts]=point_B_coords[0,0:N_pts]*224/im_size_B[1] + point_B_coords[1,0:N_pts]=point_B_coords[1,0:N_pts]*224/im_size_B[0] + + im_size_A[0:2]=torch.FloatTensor([224,224]) + im_size_B[0:2]=torch.FloatTensor([224,224]) + + L_pck = torch.FloatTensor([224.0]) + + sample = {'source_image': image_A, 'target_image': image_B, 'source_im_size': im_size_A, 'target_im_size': im_size_B, 'source_points': point_A_coords, 'target_points': point_B_coords, 'L_pck': L_pck} + + if self.transform: + sample = self.transform(sample) + + return sample + + def get_image(self,img_name_list,idx): + img_name = os.path.join(self.dataset_path, img_name_list.iloc[idx]) + image = io.imread(img_name) + + # get image size + im_size = np.asarray(image.shape) + + # convert to torch Variable + image = np.expand_dims(image.transpose((2,0,1)),0) + image = torch.Tensor(image.astype(np.float32)) + image_var = Variable(image,requires_grad=False) + + # Resize image using bilinear sampling with identity affine tnf + image = self.affineTnf(image_var).data.squeeze(0) + + im_size = torch.Tensor(im_size.astype(np.float32)) + + return (image, im_size) + + def get_points(self,point_coords_list,idx): + X=np.fromstring(point_coords_list.iloc[idx,0],sep=';') + Y=np.fromstring(point_coords_list.iloc[idx,1],sep=';') + Xpad = -np.ones(20); Xpad[:len(X)]=X + Ypad = -np.ones(20); Ypad[:len(X)]=Y + point_coords = np.concatenate((Xpad.reshape(1,20),Ypad.reshape(1,20)),axis=0) + + # make arrays float tensor for subsequent processing + point_coords = torch.Tensor(point_coords.astype(np.float32)) + return point_coords + + \ No newline at end of file diff --git a/lib/plot.py b/lib/plot.py new file mode 100644 index 0000000..b51f276 --- /dev/null +++ b/lib/plot.py @@ -0,0 +1,29 @@ +import torch +from torch.autograd import Variable +import matplotlib.pyplot as plt +import numpy as np + +def plot_image(im,batch_idx=0,return_im=False): + if im.dim()==4: + im=im[batch_idx,:,:,:] + mean=Variable(torch.FloatTensor([0.485, 0.456, 0.406]).view(3,1,1)) + std=Variable(torch.FloatTensor([0.229, 0.224, 0.225]).view(3,1,1)) + if im.is_cuda: + mean=mean.cuda() + std=std.cuda() + im=im.mul(std).add(mean)*255.0 + im=im.permute(1,2,0).data.cpu().numpy().astype(np.uint8) + if return_im: + return im + plt.imshow(im) + plt.show() + +def save_plot(filename): + plt.gca().set_axis_off() + plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, + hspace = 0, wspace = 0) + plt.margins(0,0) + plt.gca().xaxis.set_major_locator(plt.NullLocator()) + plt.gca().yaxis.set_major_locator(plt.NullLocator()) + plt.savefig(filename, bbox_inches = 'tight', + pad_inches = 0) \ No newline at end of file diff --git a/lib/point_tnf.py b/lib/point_tnf.py new file mode 100644 index 0000000..3a17eb4 --- /dev/null +++ b/lib/point_tnf.py @@ -0,0 +1,167 @@ +import torch +import torch.nn +from torch.autograd import Variable +import numpy as np + +def normalize_axis(x,L): + return (x-1-(L-1)/2)*2/(L-1) + +def unnormalize_axis(x,L): + return x*(L-1)/2+1+(L-1)/2 + +def corr_to_matches(corr4d, delta4d=None, k_size=1, do_softmax=False, scale='centered', return_indices=False, invert_matching_direction=False): + to_cuda = lambda x: x.cuda() if corr4d.is_cuda else x + batch_size,ch,fs1,fs2,fs3,fs4 = corr4d.size() + + if scale=='centered': + XA,YA=np.meshgrid(np.linspace(-1,1,fs2*k_size),np.linspace(-1,1,fs1*k_size)) + XB,YB=np.meshgrid(np.linspace(-1,1,fs4*k_size),np.linspace(-1,1,fs3*k_size)) + elif scale=='positive': + XA,YA=np.meshgrid(np.linspace(0,1,fs2*k_size),np.linspace(0,1,fs1*k_size)) + XB,YB=np.meshgrid(np.linspace(0,1,fs4*k_size),np.linspace(0,1,fs3*k_size)) + + JA,IA=np.meshgrid(range(fs2),range(fs1)) + JB,IB=np.meshgrid(range(fs4),range(fs3)) + + XA,YA=Variable(to_cuda(torch.FloatTensor(XA))),Variable(to_cuda(torch.FloatTensor(YA))) + XB,YB=Variable(to_cuda(torch.FloatTensor(XB))),Variable(to_cuda(torch.FloatTensor(YB))) + + JA,IA=Variable(to_cuda(torch.LongTensor(JA).view(1,-1))),Variable(to_cuda(torch.LongTensor(IA).view(1,-1))) + JB,IB=Variable(to_cuda(torch.LongTensor(JB).view(1,-1))),Variable(to_cuda(torch.LongTensor(IB).view(1,-1))) + + if invert_matching_direction: + nc_A_Bvec=corr4d.view(batch_size,fs1,fs2,fs3*fs4) + + if do_softmax: + nc_A_Bvec=torch.nn.functional.softmax(nc_A_Bvec,dim=3) + + match_A_vals,idx_A_Bvec=torch.max(nc_A_Bvec,dim=3) + score=match_A_vals.view(batch_size,-1) + + iB=IB.view(-1)[idx_A_Bvec.view(-1)].view(batch_size,-1) + jB=JB.view(-1)[idx_A_Bvec.view(-1)].view(batch_size,-1) + iA=IA.expand_as(iB) + jA=JA.expand_as(jB) + + else: + nc_B_Avec=corr4d.view(batch_size,fs1*fs2,fs3,fs4) # [batch_idx,k_A,i_B,j_B] + if do_softmax: + nc_B_Avec=torch.nn.functional.softmax(nc_B_Avec,dim=1) + + match_B_vals,idx_B_Avec=torch.max(nc_B_Avec,dim=1) + score=match_B_vals.view(batch_size,-1) + + iA=IA.view(-1)[idx_B_Avec.view(-1)].view(batch_size,-1) + jA=JA.view(-1)[idx_B_Avec.view(-1)].view(batch_size,-1) + iB=IB.expand_as(iA) + jB=JB.expand_as(jA) + + if delta4d is not None: # relocalization + delta_iA,delta_jA,delta_iB,delta_jB = delta4d + + diA=delta_iA.squeeze(0).squeeze(0)[iA.view(-1),jA.view(-1),iB.view(-1),jB.view(-1)] + djA=delta_jA.squeeze(0).squeeze(0)[iA.view(-1),jA.view(-1),iB.view(-1),jB.view(-1)] + diB=delta_iB.squeeze(0).squeeze(0)[iA.view(-1),jA.view(-1),iB.view(-1),jB.view(-1)] + djB=delta_jB.squeeze(0).squeeze(0)[iA.view(-1),jA.view(-1),iB.view(-1),jB.view(-1)] + + iA=iA*k_size+diA.expand_as(iA) + jA=jA*k_size+djA.expand_as(jA) + iB=iB*k_size+diB.expand_as(iB) + jB=jB*k_size+djB.expand_as(jB) + + xA=XA[iA.view(-1),jA.view(-1)].view(batch_size,-1) + yA=YA[iA.view(-1),jA.view(-1)].view(batch_size,-1) + xB=XB[iB.view(-1),jB.view(-1)].view(batch_size,-1) + yB=YB[iB.view(-1),jB.view(-1)].view(batch_size,-1) + + if return_indices: + return (xA,yA,xB,yB,score,iA,jA,iB,jB) + else: + return (xA,yA,xB,yB,score) + +def nearestNeighPointTnf(matches,target_points_norm): + xA,yA,xB,yB=matches + + # match target points to grid + deltaX=target_points_norm[:,0,:].unsqueeze(1)-xB.unsqueeze(2) + deltaY=target_points_norm[:,1,:].unsqueeze(1)-yB.unsqueeze(2) + distB=torch.sqrt(torch.pow(deltaX,2)+torch.pow(deltaY,2)) + vals,idx=torch.min(distB,dim=1) + + warped_points_x = xA.view(-1)[idx.view(-1)].view(1,1,-1) + warped_points_y = yA.view(-1)[idx.view(-1)].view(1,1,-1) + warped_points_norm = torch.cat((warped_points_x,warped_points_y),dim=1) + return warped_points_norm + +def bilinearInterpPointTnf(matches,target_points_norm): + xA,yA,xB,yB=matches + + feature_size=int(np.sqrt(xB.shape[-1])) + + b,_,N=target_points_norm.size() + + X_=xB.view(-1) + Y_=yB.view(-1) + + grid = torch.FloatTensor(np.linspace(-1,1,feature_size)).unsqueeze(0).unsqueeze(2) + if xB.is_cuda: + grid=grid.cuda() + if isinstance(xB,Variable): + grid=Variable(grid) + + x_minus = torch.sum(((target_points_norm[:,0,:]-grid)>0).long(),dim=1,keepdim=True)-1 + x_minus[x_minus<0]=0 # fix edge case + x_plus = x_minus+1 + + y_minus = torch.sum(((target_points_norm[:,1,:]-grid)>0).long(),dim=1,keepdim=True)-1 + y_minus[y_minus<0]=0 # fix edge case + y_plus = y_minus+1 + + toidx = lambda x,y,L: y*L+x + + m_m_idx = toidx(x_minus,y_minus,feature_size) + p_p_idx = toidx(x_plus,y_plus,feature_size) + p_m_idx = toidx(x_plus,y_minus,feature_size) + m_p_idx = toidx(x_minus,y_plus,feature_size) + + topoint = lambda idx, X, Y: torch.cat((X[idx.view(-1)].view(b,1,N).contiguous(), + Y[idx.view(-1)].view(b,1,N).contiguous()),dim=1) + + P_m_m = topoint(m_m_idx,X_,Y_) + P_p_p = topoint(p_p_idx,X_,Y_) + P_p_m = topoint(p_m_idx,X_,Y_) + P_m_p = topoint(m_p_idx,X_,Y_) + + multrows = lambda x: x[:,0,:]*x[:,1,:] + + f_p_p=multrows(torch.abs(target_points_norm-P_m_m)) + f_m_m=multrows(torch.abs(target_points_norm-P_p_p)) + f_m_p=multrows(torch.abs(target_points_norm-P_p_m)) + f_p_m=multrows(torch.abs(target_points_norm-P_m_p)) + + Q_m_m = topoint(m_m_idx,xA.view(-1),yA.view(-1)) + Q_p_p = topoint(p_p_idx,xA.view(-1),yA.view(-1)) + Q_p_m = topoint(p_m_idx,xA.view(-1),yA.view(-1)) + Q_m_p = topoint(m_p_idx,xA.view(-1),yA.view(-1)) + + warped_points_norm = (Q_m_m*f_m_m+Q_p_p*f_p_p+Q_m_p*f_m_p+Q_p_m*f_p_m)/(f_p_p+f_m_m+f_m_p+f_p_m) + return warped_points_norm + + +def PointsToUnitCoords(P,im_size): + h,w = im_size[:,0],im_size[:,1] + P_norm = P.clone() + # normalize Y + P_norm[:,0,:] = normalize_axis(P[:,0,:],w.unsqueeze(1).expand_as(P[:,0,:])) + # normalize X + P_norm[:,1,:] = normalize_axis(P[:,1,:],h.unsqueeze(1).expand_as(P[:,1,:])) + return P_norm + +def PointsToPixelCoords(P,im_size): + h,w = im_size[:,0],im_size[:,1] + P_norm = P.clone() + # normalize Y + P_norm[:,0,:] = unnormalize_axis(P[:,0,:],w.unsqueeze(1).expand_as(P[:,0,:])) + # normalize X + P_norm[:,1,:] = unnormalize_axis(P[:,1,:],h.unsqueeze(1).expand_as(P[:,1,:])) + return P_norm \ No newline at end of file diff --git a/lib/py_util.py b/lib/py_util.py new file mode 100644 index 0000000..678168f --- /dev/null +++ b/lib/py_util.py @@ -0,0 +1,10 @@ +import os +import errno + +def create_file_path(filename): + if not os.path.exists(os.path.dirname(filename)): + try: + os.makedirs(os.path.dirname(filename)) + except OSError as exc: # Guard against race condition + if exc.errno != errno.EEXIST: + raise \ No newline at end of file diff --git a/lib/torch_util.py b/lib/torch_util.py new file mode 100644 index 0000000..7b6a0cb --- /dev/null +++ b/lib/torch_util.py @@ -0,0 +1,76 @@ +import shutil +import torch +from torch.autograd import Variable +from os import makedirs, remove +from os.path import exists, join, basename, dirname +import collections +from lib.dataloader import default_collate + +def collate_custom(batch): + """ Custom collate function for the Dataset class + * It doesn't convert numpy arrays to stacked-tensors, but rather combines them in a list + * This is useful for processing annotations of different sizes + """ + # this case will occur in first pass, and will convert a + # list of dictionaries (returned by the threads by sampling dataset[idx]) + # to a unified dictionary of collated values + if isinstance(batch[0], collections.Mapping): + return {key: collate_custom([d[key] for d in batch]) for key in batch[0]} + # these cases will occur in recursion + elif torch.is_tensor(batch[0]): # for tensors, use standrard collating function + return default_collate(batch) + else: # for other types (i.e. lists), return as is + return batch + +class BatchTensorToVars(object): + """Convert tensors in dict batch to vars + """ + def __init__(self, use_cuda=True): + self.use_cuda=use_cuda + + def __call__(self, batch): + batch_var = {} + for key,value in batch.items(): + if isinstance(value,torch.Tensor) and not self.use_cuda: + batch_var[key] = Variable(value,requires_grad=False) + elif isinstance(value,torch.Tensor) and self.use_cuda: + batch_var[key] = Variable(value,requires_grad=False).cuda() + else: + batch_var[key] = value + return batch_var + +def Softmax1D(x,dim): + x_k = torch.max(x,dim)[0].unsqueeze(dim) + x -= x_k.expand_as(x) + exp_x = torch.exp(x) + return torch.div(exp_x,torch.sum(exp_x,dim).unsqueeze(dim).expand_as(x)) + +def save_checkpoint(state, is_best, file, save_all_epochs=False): + model_dir = dirname(file) + model_fn = basename(file) + # make dir if needed (should be non-empty) + if model_dir!='' and not exists(model_dir): + makedirs(model_dir) + if save_all_epochs: + torch.save(state, join(model_dir,str(state['epoch'])+'_' + model_fn)) + if is_best: + shutil.copyfile(join(model_dir,str(state['epoch'])+'_' + model_fn), join(model_dir,'best_' + model_fn)) + else: + torch.save(state, file) + if is_best: + shutil.copyfile(file, join(model_dir,'best_' + model_fn)) + + +def str_to_bool(v): + if v.lower() in ('yes', 'true', 't', 'y', '1'): + return True + elif v.lower() in ('no', 'false', 'f', 'n', '0'): + return False + else: + raise argparse.ArgumentTypeError('Boolean value expected.') + +def expand_dim(tensor,dim,desired_dim_len): + sz = list(tensor.size()) + sz[dim]=desired_dim_len + return tensor.expand(tuple(sz)) + \ No newline at end of file diff --git a/lib/transformation.py b/lib/transformation.py new file mode 100644 index 0000000..26a6af0 --- /dev/null +++ b/lib/transformation.py @@ -0,0 +1,63 @@ +from __future__ import print_function, division +import os +import sys +from skimage import io +import pandas as pd +import numpy as np +import torch +from torch.nn.modules.module import Module +from torch.utils.data import Dataset +from torch.autograd import Variable +import torch.nn.functional as F + +from lib.torch_util import expand_dim + +class AffineTnf(object): + def __init__(self, out_h=240, out_w=240, use_cuda=True): + self.out_h = out_h + self.out_w = out_w + self.use_cuda = use_cuda + self.gridGen = AffineGridGen(out_h=out_h, out_w=out_w, use_cuda=use_cuda) + self.theta_identity = torch.Tensor(np.expand_dims(np.array([[1,0,0],[0,1,0]]),0).astype(np.float32)) + if use_cuda: + self.theta_identity = self.theta_identity.cuda() + + def __call__(self, image_batch, theta_batch=None, out_h=None, out_w=None): + if image_batch is None: + b=1 + else: + b=image_batch.size(0) + if theta_batch is None: + theta_batch = self.theta_identity + theta_batch = theta_batch.expand(b,2,3).contiguous() + theta_batch = Variable(theta_batch,requires_grad=False) + + # check if output dimensions have been specified at call time and have changed + if (out_h is not None and out_w is not None) and (out_h!=self.out_h or out_w!=self.out_w): + gridGen = AffineGridGen(out_h, out_w) + else: + gridGen = self.gridGen + + sampling_grid = gridGen(theta_batch) + + # sample transformed image + warped_image_batch = F.grid_sample(image_batch, sampling_grid) + + return warped_image_batch + + +class AffineGridGen(Module): + def __init__(self, out_h=240, out_w=240, out_ch = 3, use_cuda=True): + super(AffineGridGen, self).__init__() + self.out_h = out_h + self.out_w = out_w + self.out_ch = out_ch + + def forward(self, theta): + b=theta.size()[0] + if not theta.size()==(b,2,3): + theta = theta.view(-1,2,3) + theta = theta.contiguous() + batch_size = theta.size()[0] + out_size = torch.Size((batch_size,self.out_ch,self.out_h,self.out_w)) + return F.affine_grid(theta, out_size) diff --git a/point_transfer_demo.ipynb b/point_transfer_demo.ipynb new file mode 100644 index 0000000..2db3bda --- /dev/null +++ b/point_transfer_demo.ipynb @@ -0,0 +1,218 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from __future__ import print_function, division\n", + "import os\n", + "from os.path import exists, join, basename\n", + "import numpy as np\n", + "import scipy as sc\n", + "import scipy.misc\n", + "from collections import OrderedDict\n", + "import matplotlib.pyplot as plt\n", + "from scipy.io import loadmat\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.autograd import Variable\n", + "from torch.utils.data import Dataset\n", + "\n", + "from lib.model import ImMatchNet,MutualMatching\n", + "from lib.normalization import NormalizeImageDict\n", + "from lib.torch_util import save_checkpoint, str_to_bool\n", + "from lib.point_tnf import corr_to_matches\n", + "from lib.point_tnf import normalize_axis, unnormalize_axis, bilinearInterpPointTnf\n", + "from lib.plot import plot_image\n", + "\n", + "# CUDA\n", + "use_cuda = torch.cuda.is_available()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load pretrained model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading checkpoint...\n", + "Using checkpoint parameters: \n", + " ncons_channels: [16, 16, 1]\n", + " ncons_kernel_sizes: [5, 5, 5]\n", + "Copying weights...\n", + "Done!\n", + "Done\n" + ] + } + ], + "source": [ + "checkpoint='trained_models/ncnet_pfpascal.pth.tar'\n", + "model = ImMatchNet(use_cuda=use_cuda,\n", + " checkpoint=checkpoint)\n", + "\n", + "model.FeatureExtraction.eval()\n", + "for param in model.NeighConsensus.parameters():\n", + " param.requires_grad = False\n", + "print('Done')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from lib.pf_dataset import PFPascalDataset\n", + "Dataset = PFPascalDataset\n", + "csv_file = 'image_pairs/test_pairs.csv' \n", + "eval_dataset_path='datasets/pf-pascal/'\n", + "image_size=400\n", + "feature_size=int(image_size*0.0625)\n", + "\n", + "dataset = Dataset(csv_file=os.path.join(eval_dataset_path, csv_file),\n", + " dataset_path=eval_dataset_path,\n", + " transform=NormalizeImageDict(['source_image','target_image']),\n", + " output_size=(image_size,image_size))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluate model" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAADKCAYAAABDsfw/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "31\n" + ] + } + ], + "source": [ + "# draw sample\n", + "idx=np.random.randint(len(dataset))\n", + "sample=dataset[idx]\n", + "src=sample['source_image']\n", + "tgt=sample['target_image']\n", + "tgt_pts = Variable(sample['target_points'],requires_grad=False)\n", + "src_pts = Variable(sample['source_points'],requires_grad=False)\n", + "\n", + "# ground truth annotations\n", + "valid_pts=tgt_pts[0,:]!=-1\n", + "tgt_pts=torch.cat((tgt_pts[0,:][valid_pts].view(1,1,-1),tgt_pts[1,:][valid_pts].view(1,1,-1)),1)\n", + "tgt_pts[0,0,:]=normalize_axis(tgt_pts[0,0,:],sample['target_im_size'][1])\n", + "tgt_pts[0,1,:]=normalize_axis(tgt_pts[0,1,:],sample['target_im_size'][0])\n", + "\n", + "valid_pts=src_pts[0,:]!=-1\n", + "src_pts=torch.cat((src_pts[0,:][valid_pts].view(1,1,-1),src_pts[1,:][valid_pts].view(1,1,-1)),1)\n", + "src_pts[0,0,:]=normalize_axis(src_pts[0,0,:],sample['source_im_size'][1])\n", + "src_pts[0,1,:]=normalize_axis(src_pts[0,1,:],sample['source_im_size'][0])\n", + "\n", + "# evaluate model on image pair\n", + "batch_tnf={'source_image':Variable(src.unsqueeze(0)),'target_image':Variable(tgt.unsqueeze(0))}\n", + "\n", + "if use_cuda:\n", + " src_pts = src_pts.cuda()\n", + " tgt_pts = tgt_pts.cuda()\n", + " batch_tnf['source_image']=batch_tnf['source_image'].cuda()\n", + " batch_tnf['target_image']=batch_tnf['target_image'].cuda()\n", + " \n", + "corr4d=model(batch_tnf)\n", + "\n", + "# compute matches from output\n", + "c2m=corr_to_matches\n", + "xA,yA,xB,yB,sB=c2m(corr4d,do_softmax=True)\n", + "warped_points = bilinearInterpPointTnf((xA,yA,xB,yB),tgt_pts)\n", + "\n", + "# display result\n", + "im=plot_image(torch.cat((batch_tnf['target_image'],batch_tnf['source_image']),3),0,return_im=True)\n", + "plt.imshow(im)\n", + "tgt_pts[0,0,:] = unnormalize_axis(tgt_pts[0,0,:],tgt.shape[2])\n", + "tgt_pts[0,1,:] = unnormalize_axis(tgt_pts[0,1,:],tgt.shape[1])\n", + "warped_points[0,0,:] = unnormalize_axis(warped_points[0,0,:],src.shape[2])\n", + "warped_points[0,1,:] = unnormalize_axis(warped_points[0,1,:],src.shape[1])\n", + "\n", + "for i in range(tgt_pts.shape[2]):\n", + " xa = float(tgt_pts[0,0,i])\n", + " ya = float(tgt_pts[0,1,i])\n", + " xb = float(warped_points[0,0,i])+tgt.shape[2]\n", + " yb = float(warped_points[0,1,i])\n", + " c=np.random.rand(3)\n", + " plt.gca().add_artist(plt.Circle((xa,ya), radius=5, color=c))\n", + " plt.gca().add_artist(plt.Circle((xb,yb), radius=5, color=c))\n", + " plt.plot([xa, xb], [ya, yb], c=c, linestyle='-', linewidth=1.5) \n", + " \n", + "plt.show()\n", + "print(idx)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/train.py b/train.py new file mode 100644 index 0000000..b11af18 --- /dev/null +++ b/train.py @@ -0,0 +1,208 @@ +from __future__ import print_function, division +import os +from os.path import exists, join, basename +from collections import OrderedDict +import numpy as np +import numpy.random +import datetime +import torch +import torch.nn as nn +import torch.optim as optim +from torch.nn.functional import relu +from torch.utils.data import Dataset + +from lib.dataloader import DataLoader # modified dataloader +from lib.model import ImMatchNet +from lib.im_pair_dataset import ImagePairDataset +from lib.normalization import NormalizeImageDict +from lib.torch_util import save_checkpoint, str_to_bool +from lib.torch_util import BatchTensorToVars, str_to_bool + +import argparse + + +# Seed and CUDA +use_cuda = torch.cuda.is_available() +torch.manual_seed(1) +if use_cuda: + torch.cuda.manual_seed(1) +np.random.seed(1) + +print('ImMatchNet training script') + +# Argument parsing +parser = argparse.ArgumentParser(description='Compute PF Pascal matches') +parser.add_argument('--checkpoint', type=str, default='') +parser.add_argument('--image_size', type=int, default=400) +parser.add_argument('--dataset_image_path', type=str, default='datasets/pf-pascal/', help='path to PF Pascal dataset') +parser.add_argument('--dataset_csv_path', type=str, default='datasets/pf-pascal/image_pairs/', help='path to PF Pascal training csv') +parser.add_argument('--num_epochs', type=int, default=5, help='number of training epochs') +parser.add_argument('--batch_size', type=int, default=16, help='training batch size') +parser.add_argument('--lr', type=float, default=0.0005, help='learning rate') +parser.add_argument('--ncons_kernel_sizes', nargs='+', type=int, default=[5,5,5], help='kernels sizes in neigh. cons.') +parser.add_argument('--ncons_channels', nargs='+', type=int, default=[16,16,1], help='channels in neigh. cons') +parser.add_argument('--result_model_fn', type=str, default='checkpoint_adam', help='trained model filename') +parser.add_argument('--result-model-dir', type=str, default='trained_models', help='path to trained models folder') +parser.add_argument('--fe_finetune_params', type=int, default=0, help='number of layers to finetune') + + +args = parser.parse_args() +print(args) + +# Create model +print('Creating CNN model...') +model = ImMatchNet(use_cuda=use_cuda, + checkpoint=args.checkpoint, + ncons_kernel_sizes=args.ncons_kernel_sizes, + ncons_channels=args.ncons_channels) + +# Set which parts of the model to train +if args.fe_finetune_params>0: + for i in range(args.fe_finetune_params): + for p in model.FeatureExtraction.model[-1][-(i+1)].parameters(): + p.requires_grad=True + +print('Trainable parameters:') +for i,p in enumerate(filter(lambda p: p.requires_grad, model.parameters())): + print(str(i+1)+": "+str(p.shape)) + +# Optimizer +print('using Adam optimizer') +optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr) + +cnn_image_size=(args.image_size,args.image_size) + +Dataset = ImagePairDataset +train_csv = 'train_pairs.csv' +test_csv = 'val_pairs.csv' +normalization_tnf = NormalizeImageDict(['source_image','target_image']) +batch_preprocessing_fn = BatchTensorToVars(use_cuda=use_cuda) + +# Dataset and dataloader +dataset = Dataset(transform=normalization_tnf, + dataset_image_path=args.dataset_image_path, + dataset_csv_path=args.dataset_csv_path, + dataset_csv_file = train_csv, + output_size=cnn_image_size) + +dataloader = DataLoader(dataset, batch_size=args.batch_size, + shuffle=True, + num_workers=0) + +dataset_test = Dataset(transform=normalization_tnf, + dataset_image_path=args.dataset_image_path, + dataset_csv_path=args.dataset_csv_path, + dataset_csv_file=test_csv, + output_size=cnn_image_size) + +dataloader_test = DataLoader(dataset_test, batch_size=args.batch_size, + shuffle=True, num_workers=4) + +# Define checkpoint name +checkpoint_name = os.path.join(args.result_model_dir, + datetime.datetime.now().strftime("%Y-%m-%d_%H:%M")+'_'+args.result_model_fn + '.pth.tar') + +print('Checkpoint name: '+checkpoint_name) + +# Train +best_test_loss = float("inf") + +def weak_loss(model,batch,normalization='softmax',alpha=30): + if normalization is None: + normalize = lambda x: x + elif normalization=='softmax': + normalize = lambda x: torch.nn.functional.softmax(x,1) + elif normalization=='l1': + normalize = lambda x: x/(torch.sum(x,dim=1,keepdim=True)+0.0001) + + b = batch['source_image'].size(0) + # positive + #corr4d = model({'source_image':batch['source_image'], 'target_image':batch['target_image']}) + corr4d = model(batch) + + batch_size = corr4d.size(0) + feature_size = corr4d.size(2) + nc_B_Avec=corr4d.view(batch_size,feature_size*feature_size,feature_size,feature_size) # [batch_idx,k_A,i_B,j_B] + nc_A_Bvec=corr4d.view(batch_size,feature_size,feature_size,feature_size*feature_size).permute(0,3,1,2) # + + nc_B_Avec = normalize(nc_B_Avec) + nc_A_Bvec = normalize(nc_A_Bvec) + + # compute matching scores + scores_B,_= torch.max(nc_B_Avec,dim=1) + scores_A,_= torch.max(nc_A_Bvec,dim=1) + score_pos = torch.mean(scores_A+scores_B)/2 + + # negative + batch['source_image']=batch['source_image'][np.roll(np.arange(b),-1),:] # roll + corr4d = model(batch) + #corr4d = model({'source_image':batch['source_image'], 'target_image':batch['negative_image']}) + + batch_size = corr4d.size(0) + feature_size = corr4d.size(2) + nc_B_Avec=corr4d.view(batch_size,feature_size*feature_size,feature_size,feature_size) # [batch_idx,k_A,i_B,j_B] + nc_A_Bvec=corr4d.view(batch_size,feature_size,feature_size,feature_size*feature_size).permute(0,3,1,2) # + + nc_B_Avec = normalize(nc_B_Avec) + nc_A_Bvec = normalize(nc_A_Bvec) + + # compute matching scores + scores_B,_= torch.max(nc_B_Avec,dim=1) + scores_A,_= torch.max(nc_A_Bvec,dim=1) + score_neg = torch.mean(scores_A+scores_B)/2 + + # loss + loss = score_neg - score_pos + return loss + +loss_fn = lambda model,batch: weak_loss(model,batch,normalization='softmax') + +# define epoch function +def process_epoch(mode,epoch,model,loss_fn,optimizer,dataloader,batch_preprocessing_fn,use_cuda=True,log_interval=50): + epoch_loss = 0 + for batch_idx, batch in enumerate(dataloader): + if mode=='train': + optimizer.zero_grad() + tnf_batch = batch_preprocessing_fn(batch) + loss = loss_fn(model,tnf_batch) + loss_np = loss.data.cpu().numpy()[0] + #loss_np = loss.data.cpu().numpy() + epoch_loss += loss_np + if mode=='train': + loss.backward() + optimizer.step() + else: + loss=None + if batch_idx % log_interval == 0: + print(mode.capitalize()+' Epoch: {} [{}/{} ({:.0f}%)]\t\tLoss: {:.6f}'.format( + epoch, batch_idx , len(dataloader), + 100. * batch_idx / len(dataloader), loss_np)) + epoch_loss /= len(dataloader) + print(mode.capitalize()+' set: Average loss: {:.4f}'.format(epoch_loss)) + return epoch_loss + +train_loss = np.zeros(args.num_epochs) +test_loss = np.zeros(args.num_epochs) + +print('Starting training...') + +model.FeatureExtraction.eval() + +for epoch in range(1, args.num_epochs+1): + train_loss[epoch-1] = process_epoch('train',epoch,model,loss_fn,optimizer,dataloader,batch_preprocessing_fn,log_interval=1) + test_loss[epoch-1] = process_epoch('test',epoch,model,loss_fn,optimizer,dataloader_test,batch_preprocessing_fn,log_interval=1) + + # remember best loss + is_best = test_loss[epoch-1] < best_test_loss + best_test_loss = min(test_loss[epoch-1], best_test_loss) + save_checkpoint({ + 'epoch': epoch, + 'args': args, + 'state_dict': model.state_dict(), + 'best_test_loss': best_test_loss, + 'optimizer' : optimizer.state_dict(), + 'train_loss': train_loss, + 'test_loss': test_loss, + }, is_best,checkpoint_name) + +print('Done!') diff --git a/trained_models/.gitignore b/trained_models/.gitignore new file mode 100644 index 0000000..7181595 --- /dev/null +++ b/trained_models/.gitignore @@ -0,0 +1,5 @@ +# Ignore everything in this directory +* +# Except this file +!.gitignore +!download.sh diff --git a/trained_models/download.sh b/trained_models/download.sh new file mode 100755 index 0000000..d3593d7 --- /dev/null +++ b/trained_models/download.sh @@ -0,0 +1,2 @@ +wget https://www.di.ens.fr/willow/research/ncnet/models/ncnet_pfpascal.pth.tar +wget https://www.di.ens.fr/willow/research/ncnet/models/ncnet_ivd.pth.tar