├── .gitignore ├── DepthPredictor_TB.ipynb ├── README.md ├── build_dataset_directory.py ├── create_lmdb_from_directory.sh ├── depth_predictor.py ├── error_analysis.ipynb ├── image_handling.py ├── image_handling_tb.ipynb ├── index_file_functions.ipynb ├── make_db_mean.sh ├── models └── unary_depth_regressor │ ├── solver_softmax_dir.prototxt │ ├── solver_udr_euclidean_lmdb.prototxt │ ├── solver_udr_softmax_lmdb.prototxt │ ├── udr_euclidean_deploy.prototxt │ ├── udr_euclidean_lmdb.prototxt │ ├── udr_softmax_deploy_2.prototxt │ ├── udr_softmax_dir.prototxt │ └── udr_softmax_lmdb.prototxt ├── parse_log.sh ├── plot_training_info.ipynb └── train.sh /.gitignore: -------------------------------------------------------------------------------- 1 | # for now, ignore model directory 2 | # models/ 3 | 4 | 5 | # Byte-compiled / optimized / DLL files 6 | __pycache__/ 7 | *.py[cod] 8 | 9 | # C extensions 10 | *.so 11 | 12 | # Distribution / packaging 13 | .Python 14 | env/ 15 | build/ 16 | develop-eggs/ 17 | dist/ 18 | downloads/ 19 | eggs/ 20 | lib/ 21 | lib64/ 22 | parts/ 23 | sdist/ 24 | var/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .coverage 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | 47 | # Translations 48 | *.mo 49 | *.pot 50 | 51 | # Django stuff: 52 | *.log 53 | 54 | # Sphinx documentation 55 | docs/_build/ 56 | 57 | # PyBuilder 58 | target/ 59 | 60 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # DepthPrediction 2 | A tool to predict the depth field of a 2-dimensional image based on 3 | "Deep convolutional neural fields for depth estimation from a single image" by Liu et al. 4 | which can be found [here on arViX](http://arxiv.org/abs/1411.6387). 5 | 6 | The ipython notebooks for the project can be viewed [here](http://nbviewer.ipython.org/github/asousa/DepthPrediction/tree/master/). 7 | 8 | 9 | # 2019 comments: 10 | Hi there, ML students! We never quite got this working right. But feel free to message me, I'm happy to discuss! --Austin 11 | -------------------------------------------------------------------------------- /build_dataset_directory.py: -------------------------------------------------------------------------------- 1 | # Creates dataset directories (jpegs with an index file) 2 | 3 | import numpy as np 4 | import sys 5 | import matplotlib.pyplot as plt 6 | 7 | from image_handling import load_dataset 8 | from image_handling import segment_image 9 | 10 | # Generate full datasets, using splits file: 11 | import scipy.io 12 | 13 | # Load splits 14 | splits_path = '/home/vlf/Projects/DepthPrediction/train/NYUv2/splits.mat' 15 | splits = scipy.io.loadmat(splits_path) 16 | train_inds = splits['trainNdxs'] 17 | test_inds = splits['testNdxs'] 18 | 19 | from image_handling import create_segments_dataset 20 | from image_handling import create_segments_directory 21 | 22 | min_depth = 0.7; 23 | max_depth = 10; 24 | depth_bins = 32; 25 | 26 | window_size = 83; # 167x167~NYUv2 paper # 227x227, imagenet standard 27 | n_superpixels = 400; 28 | 29 | output_images=False 30 | average_type=1 # 0: center val, 1:superpixel avg, 2:patch avg 31 | # Generate training set 32 | 33 | # matlab file 34 | input_file = 'train/nyu_depth_v2_labeled.mat' 35 | # Directory of images 36 | img_filepath_train = '/home/vlf/Projects/DepthPrediction/train/NYUv2/train_full_167_v3' 37 | img_filepath_test = '/home/vlf/Projects/DepthPrediction/train/NYUv2/test_full_167_v3' 38 | 39 | train_slices = np.array_split(train_inds - 1,10) 40 | test_slices = np.array_split(test_inds - 1, 10) 41 | 42 | ## THESE LINES FOR BUILDING A FRESH SET 43 | # print 'Building training set...' 44 | # for s in train_slices: 45 | # images = tuple(s) 46 | # data_file = create_segments_directory(input_filename=input_file, image_output_filepath=img_filepath_train, 47 | # no_superpixels=n_superpixels, x_window_size=window_size, y_window_size=window_size, images=images, 48 | # depth_bins=depth_bins,depth_min=min_depth, depth_max=max_depth) 49 | 50 | # print 'Building validation set...' 51 | # for s in test_slices: 52 | # images = tuple(s) 53 | # data_file = create_segments_directory(input_filename=input_file, image_output_filepath=img_filepath_test, 54 | # no_superpixels=n_superpixels, x_window_size=113, y_window_size=113, images=images, 55 | # depth_bins=depth_bins,depth_min=min_depth, depth_max=max_depth) 56 | 57 | print "nBins = ",depth_bins 58 | print "Avg Type = ",average_type 59 | 60 | print 'Building training set...' 61 | for s in train_slices: 62 | images = tuple(s) 63 | create_segments_directory(input_filename=input_file, image_output_filepath=img_filepath_train, 64 | no_superpixels=n_superpixels, x_window_size=window_size, y_window_size=window_size, images=images, 65 | depth_bins=depth_bins,depth_min=min_depth, depth_max=max_depth, depth_type=average_type, 66 | output_images=output_images, index_name='index_' + str(depth_bins) + '_' + str(average_type) + '.txt') 67 | 68 | print 'Building validation set...' 69 | for s in test_slices: 70 | images = tuple(s) 71 | create_segments_directory(input_filename=input_file, image_output_filepath=img_filepath_test, 72 | no_superpixels=n_superpixels, x_window_size=window_size, y_window_size=window_size, images=images, 73 | depth_bins=depth_bins,depth_min=min_depth, depth_max=max_depth, depth_type=average_type, 74 | output_images=output_images, index_name='index_' + str(depth_bins) + '_' + str(average_type) + '.txt') 75 | 76 | 77 | -------------------------------------------------------------------------------- /create_lmdb_from_directory.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | # Create the imagenet lmdb inputs 3 | # N.B. set the path to the imagenet train + val data dirs 4 | 5 | OUTDIR=~/Projects/DepthPrediction 6 | TOOLS=$CAFFE_HOME/build/tools 7 | 8 | TRAIN_DATA_ROOT=make_mean_hack/ 9 | #VAL_DATA_ROOT=/home/vlf/Projects/DepthPrediction/train/NYUv2/test_full_167_v2/ 10 | 11 | IND_NAME=index.txt 12 | OUT_NAME=mean_hack_lmdb 13 | 14 | RESIZE=true 15 | if $RESIZE; then 16 | RESIZE_HEIGHT=227 17 | RESIZE_WIDTH=227 18 | else 19 | RESIZE_HEIGHT=0 20 | RESIZE_WIDTH=0 21 | fi 22 | 23 | if [ ! -d "$TRAIN_DATA_ROOT" ]; then 24 | echo "Error: TRAIN_DATA_ROOT is not a path to a directory: $TRAIN_DATA_ROOT" 25 | echo "Set the TRAIN_DATA_ROOT variable in create_imagenet.sh to the path" \ 26 | "where the ImageNet training data is stored." 27 | exit 1 28 | fi 29 | 30 | #if [ ! -d "$VAL_DATA_ROOT" ]; then 31 | # echo "Error: VAL_DATA_ROOT is not a path to a directory: $VAL_DATA_ROOT" 32 | # echo "Set the VAL_DATA_ROOT variable in create_imagenet.sh to the path" \ 33 | # "where the ImageNet validation data is stored." 34 | # exit 1 35 | #fi 36 | 37 | echo "Creating train lmdb..." 38 | 39 | GLOG_logtostderr=1 $TOOLS/convert_imageset \ 40 | --resize_height=$RESIZE_HEIGHT \ 41 | --resize_width=$RESIZE_WIDTH \ 42 | --shuffle \ 43 | $TRAIN_DATA_ROOT \ 44 | $TRAIN_DATA_ROOT/$IND_NAME \ 45 | $OUTDIR/$OUT_NAME 46 | 47 | #echo "Creating val lmdb..." 48 | 49 | #GLOG_logtostderr=1 $TOOLS/convert_imageset \ 50 | # --resize_height=$RESIZE_HEIGHT \ 51 | # --resize_width=$RESIZE_WIDTH \ 52 | # --shuffle \ 53 | # $VAL_DATA_ROOT \ 54 | # $VAL_DATA_ROOT/$IND_NAME \ 55 | # $oOUTDIR/NYUv2_test_$OUT_NAME 56 | 57 | echo "Done." 58 | -------------------------------------------------------------------------------- /depth_predictor.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import caffe 3 | import image_handling 4 | import matplotlib.pyplot as plt 5 | from gco_python import pygco 6 | 7 | class DepthPredictor(): 8 | def __init__(self): 9 | self.unaryCNN=None 10 | 11 | def load(self,model_file=None,pretrained_file=None, meanfile=None, image_dims=(227,227)): 12 | """ Load pretrained classifiers 13 | model_file = model descripton file (*.prototxt) 14 | pretrained_file = pretrained weights (*.caffemodel) 15 | mean = 2D array of training data means 16 | """ 17 | # Instantiate net 18 | 19 | self.unaryCNN = caffe.Net(model_file,pretrained_file) 20 | 21 | # Params (Likely constant for image sets) 22 | self.unaryCNN.set_raw_scale(self.unaryCNN.inputs[0], 255) 23 | # order of channels: RGB, BGR, etc? 24 | 25 | #self.unaryCNN.set_channel_swap(self.unaryCNN.inputs[0], (2,1,0)) 26 | #print self.unaryCNN.inputs 27 | # mean file? 28 | if meanfile is None: 29 | self.mean = np.zeros((image_dims[0],image_dims[1],3)) 30 | else: 31 | self.mean = 255* caffe.io.resize_image(meanfile, image_dims) 32 | 33 | # print "Mean is: ",meanfile.shape 34 | # mean_resize = caffe.io.resize_image(meanfile, image_dims).astype('uint8') 35 | # print "Mean_resize is: ",mean_resize.shape 36 | # self.unaryCNN.set_mean(self.unaryCNN.inputs[0], mean_resize.transpose(2,1,0)) 37 | 38 | #self.unaryCNN.crop_dims = np.array(self.unaryCNN.blobs[self.unaryCNN.inputs[0]].data.shape[2:]) 39 | self.unaryCNN.image_dims = image_dims 40 | 41 | 42 | def predict(self, input_img, no_superpixels=400, true_depths=None, graphcut=False, single_mode=False): 43 | """ Predict a depth field """ 44 | #return self.unaryCNN.predict(images) 45 | # Scale to standardize input dimensions. 46 | oversample = False # Flip it, shift it, crop it, etc 47 | 48 | input_segments = [] 49 | self.window_size = 83 # 167x167 50 | if not single_mode: 51 | print "image dims: ",self.unaryCNN.image_dims 52 | # Preprocess image: should return segment patches, depth map, etc. 53 | [segs, mask] = image_handling.preprocess_image(input_img, true_depth=None, 54 | no_superpixels=no_superpixels, x_window_size=self.window_size, y_window_size=self.window_size) 55 | 56 | print "seg length = ", len(segs) 57 | input_ = np.zeros((len(segs),self.unaryCNN.image_dims[0], self.unaryCNN.image_dims[1],3),dtype=np.float32) 58 | 59 | 60 | # Resize & subtract mean 61 | for ix, in_ in enumerate(segs): 62 | # input_[ix] = caffe.io.resize_image(in_.transpose(2,1,0), self.unaryCNN.image_dims).astype('uint8') #- self.mean 63 | 64 | input_[ix] = caffe.io.resize_image(in_.transpose(2,1,0), self.unaryCNN.image_dims) - self.mean 65 | 66 | else: # just classifying one frame 67 | segs = input_img 68 | tmp_img = caffe.io.resize_image(input_img, self.unaryCNN.image_dims) - self.mean 69 | input_= np.zeros([1,tmp_img.shape[0],tmp_img.shape[1],tmp_img.shape[2]]) 70 | input_[0,:,:,:] = tmp_img 71 | #print "max inp: ",np.max(input_[1]) 72 | #print "max avg: ",np.max(self.mean) 73 | # print segs[1,:,:,:].shape 74 | # print input_[1,:,:,:].shape 75 | # plt.subplot(211) 76 | # plt.imshow(segs[1,:,:,:].transpose(2,1,0)) 77 | # plt.subplot(212) 78 | # plt.imshow(input_[1,:,:,:]) 79 | # plt.show() 80 | 81 | 82 | 83 | 84 | # Classify 85 | # Allocate memory 86 | caffe_in = np.zeros(np.array(input_.shape)[[0,3,1,2]], 87 | dtype=np.float32) 88 | 89 | # Preprocess 90 | for ix, in_ in enumerate(input_): 91 | caffe_in[ix] = self.unaryCNN.preprocess(self.unaryCNN.inputs[0], in_) 92 | 93 | # Run through CNN 94 | out = self.unaryCNN.forward_all(**{self.unaryCNN.inputs[0]: caffe_in}) 95 | 96 | #print "inp label is: ",self.unaryCNN.inputs[0] 97 | # Sum over R, G, B layers (kept separate?) 98 | predictions = out[self.unaryCNN.outputs[0]].squeeze(axis=(2,3)) 99 | 100 | 101 | if graphcut: 102 | print "heyo" 103 | 104 | else: 105 | out = self.unaryCNN.forward_all(**{self.unaryCNN.inputs[0]: caffe_in}) 106 | 107 | 108 | #print "inp label is: ",self.unaryCNN.inputs[0] 109 | predictions = out[self.unaryCNN.outputs[0]].squeeze(axis=(2,3)) 110 | #plt.imshow(predictions) 111 | #plt.show() 112 | #print np.argmax(predictions,axis=1) 113 | 114 | #if not single_mode: 115 | # Softmax output 116 | #print predictions 117 | #return image_handling.apply_depths(np.argmax(predictions,axis=1), mask), predictions, segs, mask 118 | 119 | # Regression output 120 | return image_handling.apply_depths(predictions, mask), predictions, segs, mask 121 | #else: 122 | # return predictions 123 | 124 | def train(self,solver_path=None): 125 | """ 126 | Trains the convnet, using the solver defined in solver_path.prototxt 127 | """ 128 | if self.unaryCNN==None: 129 | print 'Please load a model file first!' 130 | 131 | 132 | S = SGDSolver(solver_path) 133 | 134 | print type(S) 135 | 136 | 137 | 138 | -------------------------------------------------------------------------------- /error_analysis.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "", 4 | "signature": "sha256:6764515fff13a224bd2906f12ebd072de952204e87b4464d43fb6e5deb42aef1" 5 | }, 6 | "nbformat": 3, 7 | "nbformat_minor": 0, 8 | "worksheets": [ 9 | { 10 | "cells": [ 11 | { 12 | "cell_type": "code", 13 | "collapsed": false, 14 | "input": [ 15 | "# Calculate error metrics across validation set:\n", 16 | "# Import and setup:\n", 17 | "import numpy as np\n", 18 | "import scipy as sp\n", 19 | "import csv\n", 20 | "import matplotlib.pyplot as plt\n", 21 | "import sys\n", 22 | "import caffe\n", 23 | "from image_handling import load_dataset\n", 24 | "from image_handling import segment_image\n", 25 | "from image_handling import preprocess_image\n", 26 | "from image_handling import apply_depths\n", 27 | "from image_handling import real_world_values\n", 28 | "caffe.set_mode_gpu()\n", 29 | "\n", 30 | "# --------------- Latex Plot Beautification --------------------------\n", 31 | "fig_width_pt = 246.0 # Get this from LaTeX using \\showthe\\columnwidth\n", 32 | "inches_per_pt = 1.0/72.27 # Convert pt to inch\n", 33 | "golden_mean = (np.sqrt(5)-1.0)/2.0 # Aesthetic ratio\n", 34 | "fig_width = fig_width_pt*inches_per_pt # width in inches\n", 35 | "fig_height = fig_width*golden_mean # height in inches\n", 36 | "fig_size = [fig_width+1,fig_height+1]\n", 37 | "params = {'backend': 'ps',\n", 38 | " 'axes.labelsize': 12,\n", 39 | " 'text.fontsize': 10,\n", 40 | " 'legend.fontsize': 10,\n", 41 | " 'xtick.labelsize': 8,\n", 42 | " 'ytick.labelsize': 8,\n", 43 | " 'text.usetex': False,\n", 44 | " 'figure.figsize': fig_size}\n", 45 | "plt.rcParams.update(params)\n", 46 | "# --------------- Latex Plot Beautification --------------------------\n", 47 | "\n", 48 | "%matplotlib inline\n", 49 | "%load_ext autoreload\n", 50 | "%autoreload 2" 51 | ], 52 | "language": "python", 53 | "metadata": {}, 54 | "outputs": [], 55 | "prompt_number": 3 56 | }, 57 | { 58 | "cell_type": "code", 59 | "collapsed": false, 60 | "input": [ 61 | "# Classify single patches -- no preprocessing. Hmmm... hmm.\n", 62 | "\n", 63 | "import csv\n", 64 | "from depth_predictor import DepthPredictor\n", 65 | "in_file = 'train/NYUv2/test_full_167_v3/index_16_1_norm_randomized.txt'\n", 66 | "prefile ='models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_superpixel_avg_iter_20000.caffemodel'\n", 67 | "prefile2 = 'models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_norm_realmean_iter_20000.caffemodel'\n", 68 | "\n", 69 | "#modfile = 'models/unary_depth_regressor/udr_euclidean_no_softmax_deploy.prototxt'\n", 70 | "modfile = 'models/unary_depth_regressor/udr_euclidean_deploy.prototxt'\n", 71 | "modfile2 = 'models/unary_depth_regressor/udr_euclidean_deploy.prototxt'\n", 72 | "meanfile = 'train/NYUv2/Mean.jpg'\n", 73 | "setmean = caffe.io.load_image(meanfile)\n", 74 | "\n", 75 | "\n", 76 | "DP = DepthPredictor()\n", 77 | "DP2 = DepthPredictor()\n", 78 | "# Load pre-trained model\n", 79 | "DP.load(model_file=modfile,pretrained_file=prefile,meanfile=setmean)\n", 80 | "DP2.load(model_file=modfile2, pretrained_file=prefile2,meanfile=setmean)\n", 81 | "\n", 82 | "# Load index file, loop over it:\n", 83 | "f = open(in_file,'r')\n", 84 | "csvf = csv.reader(f)\n", 85 | "true_depths = []\n", 86 | "paths = []\n", 87 | "predicted_depths = []\n", 88 | "predicted_depths_2 = []\n", 89 | "true_depths_measured = []\n", 90 | "\n", 91 | "image_segs = []\n", 92 | "for row in csvf:\n", 93 | " #row = csvf.next()\n", 94 | " tmp = row[0].split(' ',1)\n", 95 | " true_depths.append(float(tmp[1]))\n", 96 | " paths.append(tmp[0])\n", 97 | "\n", 98 | "for index in np.random.choice(np.arange(0,len(true_depths)),5000): \n", 99 | "#for index in range(0,5000):\n", 100 | " if not np.mod(index,100):\n", 101 | " print \"Classifying frame \", index\n", 102 | " #print paths[index]\n", 103 | " inp_img = caffe.io.load_image(paths[index])\n", 104 | " # Predict!\n", 105 | " classified = DP.predict(inp_img, graphcut=False, single_mode = True)\n", 106 | " classified_2 = DP2.predict(inp_img, graphcut=False, single_mode = True)\n", 107 | " true_depths_measured.append(float(true_depths[index]))\n", 108 | " \n", 109 | " #print classified[0]\n", 110 | " predicted_depths.append(float(classified[0]))\n", 111 | " predicted_depths_2.append(float(classified_2[0]))" 112 | ], 113 | "language": "python", 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "ename": "UnboundLocalError", 118 | "evalue": "local variable 'mask' referenced before assignment", 119 | "output_type": "pyerr", 120 | "traceback": [ 121 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", 122 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 41\u001b[0m \u001b[0minp_img\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcaffe\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mio\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload_image\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpaths\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 42\u001b[0m \u001b[1;31m# Predict!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 43\u001b[1;33m \u001b[0mclassified\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDP\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minp_img\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgraphcut\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msingle_mode\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 44\u001b[0m \u001b[0mclassified_2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDP2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minp_img\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgraphcut\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msingle_mode\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 45\u001b[0m \u001b[0mtrue_depths_measured\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrue_depths\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 123 | "\u001b[1;32m/home/vlf/Projects/DepthPrediction/depth_predictor.py\u001b[0m in \u001b[0;36mpredict\u001b[1;34m(self, input_img, no_superpixels, true_depths, graphcut, single_mode)\u001b[0m\n\u001b[0;32m 120\u001b[0m \u001b[1;31m#return image_handling.apply_depths(predictions, mask), predictions, segs, mask\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 121\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 122\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mimage_handling\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_depths\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpredictions\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmask\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;31m#, predictions, segs, mask\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 123\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 124\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msolver_path\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 124 | "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'mask' referenced before assignment" 125 | ] 126 | } 127 | ], 128 | "prompt_number": 113 129 | }, 130 | { 131 | "cell_type": "code", 132 | "collapsed": false, 133 | "input": [ 134 | "import csv\n", 135 | "from depth_predictor import DepthPredictor\n", 136 | "\n", 137 | "[images, depths] = load_dataset('train/nyu_depth_v2_labeled.mat')\n", 138 | "\n", 139 | "in_file = 'train/NYUv2/test_full_167_v3/index_16_1_norm_randomized.txt'\n", 140 | "prefile ='models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_superpixel_avg_iter_5000.caffemodel'\n", 141 | "prefile2 = 'models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_norm_realmean_iter_5000.caffemodel'\n", 142 | "\n", 143 | "#modfile = 'models/unary_depth_regressor/udr_euclidean_no_softmax_deploy.prototxt'\n", 144 | "modfile = 'models/unary_depth_regressor/udr_euclidean_deploy.prototxt'\n", 145 | "modfile2 = 'models/unary_depth_regressor/udr_euclidean_deploy.prototxt'\n", 146 | "meanfile = 'train/NYUv2/Mean.jpg'\n", 147 | "setmean = caffe.io.load_image(meanfile)\n", 148 | "\n", 149 | "n_pix = 600\n", 150 | "\n", 151 | "DP = DepthPredictor()\n", 152 | "DP2 = DepthPredictor()\n", 153 | "# Load pre-trained model\n", 154 | "DP.load(model_file=modfile,pretrained_file=prefile,meanfile=setmean)\n", 155 | "DP2.load(model_file=modfile2, pretrained_file=prefile2,meanfile=setmean)\n", 156 | "\n", 157 | "\n", 158 | "#for index in np.random.choice(np.arange(0,len(true_depths)),10): \n", 159 | "#for index in range(0,5000):\n", 160 | "\n", 161 | "\n", 162 | "img_ind = 193#1305 #193 #920# 600 #1337\n", 163 | "\n", 164 | "[segs, masks, true_depths] = preprocess_image(images[img_ind], no_superpixels=n_pix, x_window_size=83,y_window_size=83,\n", 165 | " depth_bins=16, depth_min = 0.7, depth_max=10,true_depth=depths[img_ind])\n", 166 | "\n", 167 | "pred_img, pred_depths, _, _ = DP.predict(images[img_ind], no_superpixels=n_pix, graphcut=False)\n", 168 | "pred_img_2, pred_depths_2,_, _ = DP2.predict(images[img_ind], no_superpixels=n_pix, graphcut=False)\n" 169 | ], 170 | "language": "python", 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "output_type": "stream", 175 | "stream": "stdout", 176 | "text": [ 177 | "image dims: (227, 227)\n", 178 | "seg length = " 179 | ] 180 | }, 181 | { 182 | "output_type": "stream", 183 | "stream": "stdout", 184 | "text": [ 185 | " 588\n", 186 | "image dims: " 187 | ] 188 | }, 189 | { 190 | "output_type": "stream", 191 | "stream": "stdout", 192 | "text": [ 193 | " (227, 227)\n", 194 | "seg length = " 195 | ] 196 | }, 197 | { 198 | "output_type": "stream", 199 | "stream": "stdout", 200 | "text": [ 201 | " 588\n" 202 | ] 203 | } 204 | ], 205 | "prompt_number": 153 206 | }, 207 | { 208 | "cell_type": "code", 209 | "collapsed": false, 210 | "input": [ 211 | "depth_image = apply_depths(true_depths, masks)\n", 212 | "\n", 213 | "# plt.subplot(311)\n", 214 | "# plt.imshow(images[img_ind].transpose(2,1,0))\n", 215 | "# plt.title('Original image')\n", 216 | "# frame=plt.gca()\n", 217 | "# frame.axes.get_xaxis().set_visible(False)\n", 218 | "# frame.axes.get_yaxis().set_visible(False)\n", 219 | "#plt.show()\n", 220 | "plt.subplot(131)\n", 221 | "plt.imshow(depths[img_ind].transpose(1,0))\n", 222 | "plt.title('Ground Truth')\n", 223 | "frame=plt.gca()\n", 224 | "frame.axes.get_xaxis().set_visible(False)\n", 225 | "frame.axes.get_yaxis().set_visible(False)\n", 226 | "\n", 227 | "#plt.colorbar()\n", 228 | "#plt.show()\n", 229 | "plt.subplot(132)\n", 230 | "plt.imshow((real_world_values(pred_img.transpose(1,0),0.7,10,16)))\n", 231 | "plt.clim(1,16)\n", 232 | "#plt.colorbar()\n", 233 | "plt.title('Superpixel Avg')\n", 234 | "frame=plt.gca()\n", 235 | "frame.axes.get_xaxis().set_visible(False)\n", 236 | "frame.axes.get_yaxis().set_visible(False)\n", 237 | "#plt.show()\n", 238 | "\n", 239 | "# vis_square(segs.transpose(0,2,3,1))\n", 240 | "# plt.show()\n", 241 | "plt.subplot(133)\n", 242 | "plt.imshow((real_world_values(pred_img_2.transpose(1,0),0.7,10,16)))\n", 243 | "#plt.imshow(pred_img_2.transpose(1,0))\n", 244 | "\n", 245 | "#plt.colorbar()\n", 246 | "\n", 247 | "plt.title('Center Depth Only')\n", 248 | "\n", 249 | "frame=plt.gca()\n", 250 | "frame.axes.get_xaxis().set_visible(False)\n", 251 | "frame.axes.get_yaxis().set_visible(False)\n", 252 | "\n", 253 | "#plt.show()\n", 254 | "plt.savefig('center_vs_average.pdf')" 255 | ], 256 | "language": "python", 257 | "metadata": {}, 258 | "outputs": [ 259 | { 260 | "metadata": {}, 261 | "output_type": "display_data", 262 | "png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAABnCAYAAADVJCNDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nvNMZAAAAAElFTkSuQmCC\n", 263 | "text": [ 264 | "" 265 | ] 266 | } 267 | ], 268 | "prompt_number": 154 269 | }, 270 | { 271 | "cell_type": "code", 272 | "collapsed": false, 273 | "input": [ 274 | "# Histograms for 10 random tests:\n", 275 | "\n", 276 | "import csv\n", 277 | "from depth_predictor import DepthPredictor\n", 278 | "\n", 279 | "[images, depths] = load_dataset('train/nyu_depth_v2_labeled.mat')\n", 280 | "\n", 281 | "in_file = 'train/NYUv2/test_full_167_v3/index_16_1_norm_randomized.txt'\n", 282 | "prefile ='models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_superpixel_avg_iter_5000.caffemodel'\n", 283 | "prefile2 = 'models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_norm_realmean_iter_5000.caffemodel'\n", 284 | "\n", 285 | "#modfile = 'models/unary_depth_regressor/udr_euclidean_no_softmax_deploy.prototxt'\n", 286 | "modfile = 'models/unary_depth_regressor/udr_euclidean_deploy.prototxt'\n", 287 | "modfile2 = 'models/unary_depth_regressor/udr_euclidean_deploy.prototxt'\n", 288 | "meanfile = 'train/NYUv2/Mean.jpg'\n", 289 | "setmean = caffe.io.load_image(meanfile)\n", 290 | "\n", 291 | "n_pix = 600\n", 292 | "\n", 293 | "DP = DepthPredictor()\n", 294 | "DP2 = DepthPredictor()\n", 295 | "# Load pre-trained model\n", 296 | "DP.load(model_file=modfile,pretrained_file=prefile,meanfile=setmean)\n", 297 | "DP2.load(model_file=modfile2, pretrained_file=prefile2,meanfile=setmean)\n", 298 | "\n", 299 | "\n", 300 | "#for index in np.random.choice(np.arange(0,len(true_depths)),10): \n", 301 | "#for index in range(0,5000):\n", 302 | "\n", 303 | "\n", 304 | "img_ind = 193#1305 #193 #920# 600 #1337\n", 305 | "\n", 306 | "[segs, masks, true_depths] = preprocess_image(images[img_ind], no_superpixels=n_pix, x_window_size=83,y_window_size=83,\n", 307 | " depth_bins=16, depth_min = 0.7, depth_max=10,true_depth=depths[img_ind])\n", 308 | "\n", 309 | "pred_img, pred_depths, _, _ = DP.predict(images[img_ind], no_superpixels=n_pix, graphcut=False)\n", 310 | "pred_img_2, pred_depths_2,_, _ = DP2.predict(images[img_ind], no_superpixels=n_pix, graphcut=False)\n" 311 | ], 312 | "language": "python", 313 | "metadata": {}, 314 | "outputs": [] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "collapsed": false, 319 | "input": [ 320 | "#plt.plot(pred_depths,'g.')\n", 321 | "plt.plot(pred_depths_2 - 5, 'b.')\n", 322 | "plt.plot(true_depths,'rx')\n", 323 | "plt.ylim(1,16)\n", 324 | "\n" 325 | ], 326 | "language": "python", 327 | "metadata": {}, 328 | "outputs": [ 329 | { 330 | "metadata": {}, 331 | "output_type": "pyout", 332 | "prompt_number": 156, 333 | "text": [ 334 | "(1, 16)" 335 | ] 336 | }, 337 | { 338 | "metadata": {}, 339 | "output_type": "display_data", 340 | "png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAAD/CAYAAAAHSua4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhmEYhmEYhmEYhpma/H97lwBVtOxwPQAAAABJRU5ErkJggg==\n", 341 | "text": [ 342 | "" 343 | ] 344 | } 345 | ], 346 | "prompt_number": 156 347 | } 348 | ], 349 | "metadata": {} 350 | } 351 | ] 352 | } -------------------------------------------------------------------------------- /image_handling.py: -------------------------------------------------------------------------------- 1 | import h5py 2 | import numpy as np 3 | from skimage.segmentation import slic 4 | from skimage.segmentation import mark_boundaries 5 | from skimage.feature import local_binary_pattern 6 | import os 7 | import scipy 8 | import matplotlib.pyplot as plt 9 | 10 | def load_dataset(filename=None): 11 | """ 12 | Load in the hdf5 dataset from the specified filename with the labels 13 | 'images' and 'depths'. Return these two hdf5 objects as a tuple. 14 | """ 15 | nyu_set = h5py.File(filename, 'r') 16 | images = nyu_set['images'] 17 | depths = nyu_set['depths'] 18 | return [images, depths] 19 | 20 | def log_pixelate_values(array, min_val, max_val, bins): 21 | """ 22 | Given an array or an hdf5 object, log_pixelate_values takes the values along 23 | the array and bins them into integer values representing bins that are log 24 | spaced from the min to the max value. This should work on any dimension of 25 | array. 26 | """ 27 | cuts = np.logspace(np.log(min_val), np.log(max_val), num=(bins+1), base=np.e) 28 | array_vals = np.array(array[:]) 29 | val = np.reshape(np.digitize(array_vals.flatten(), cuts) - 1, array.shape) 30 | return val.astype(int) 31 | 32 | def real_world_values(array, min_val, max_val, bins): 33 | """ 34 | Take a log pixelated array in integer values or otherwise, and convert it 35 | back into real world coordinates. 36 | """ 37 | return min_val * np.exp(array * np.log(max_val / min_val) / (bins - 1)) 38 | 39 | def segment_image(image=None, no_segments=500): 40 | """ 41 | Break the images into no_segments parts using the SLIC algorithm. The 42 | algorithm does not guarantee no_segments will be found. 43 | """ 44 | if len(image.shape) != 3: 45 | raise ValueError('Dimension of image is not 3') 46 | if image.shape[0] != 3: 47 | raise ValueError('First dimension of image is not 3') 48 | mask = slic(np.transpose(image, (1, 2, 0)), n_segments=no_segments, compactness=15, sigma=1) 49 | return mask 50 | 51 | def calculate_sp_centroids(mask=None): 52 | """ 53 | Generates an average position of each superpixel in x and y. Return a 54 | 2 x n array with x in (0, :) and y in (1, :) 55 | """ 56 | pixel_ids = np.unique(mask) 57 | 58 | centroids = np.zeros((2, len(pixel_ids))) 59 | weight_x = np.array(range(0, mask.shape[0])) 60 | weight_y = np.array(range(0, mask.shape[1])) 61 | 62 | for pixel in pixel_ids: 63 | total = np.sum(mask == pixel, axis=None, dtype=float) 64 | centroids[0, pixel] = np.sum(weight_x * np.sum(mask == pixel, axis=1, dtype=float) / total) 65 | centroids[1, pixel] = np.sum(weight_y * np.sum(mask == pixel, axis=0, dtype=float) / total) 66 | 67 | return centroids 68 | 69 | def gather_regions(image=None, centroids=None, x_window_size=10, y_window_size=10, zero_pad=True): 70 | """ 71 | Generate an np.ndarray containing a box around all of the superpixels 72 | within the image. The box is 1 + 2 * window_size in the x and y 73 | directions. If zero_pad is True (default), the images whos boxes overhang 74 | the edges of the image are zero padded. If zero_pad is False, images whos 75 | boxes would hang over the edge of the image are moved up to the boundary 76 | edge, so that the centroid sits off-center closer to the edge of the image. 77 | """ 78 | x_width = 2 * x_window_size + 1 79 | y_width = 2 * y_window_size + 1 80 | regions = np.zeros((centroids.shape[1], 3, x_width, y_width), dtype=image.dtype) 81 | center_pixels = np.array(centroids, dtype=int) 82 | for pixel in range(0, center_pixels.shape[1]): 83 | x = center_pixels[0, pixel] 84 | y = center_pixels[1, pixel] 85 | x_left = x - x_window_size - 1 86 | x_right = x + x_window_size 87 | y_left = y - y_window_size - 1 88 | y_right = y + y_window_size 89 | 90 | if zero_pad: 91 | # Pull out the region from the image, but make sure it doesn't 92 | # extend beyond the boundaries of the image. 93 | image_region = image[:, max(x_left,0):min(x_right, image.shape[1]-1), 94 | max(y_left,0):min(y_right, image.shape[2]-1)] 95 | 96 | # Fill in with zeros on the appropriate side if necessary. 97 | # Deal with the x size first and then handle any adjustments 98 | # necessary in y 99 | if x_left < 0: 100 | image_region = np.concatenate((np.zeros((image_region.shape[0], x_width - image_region.shape[1], image_region.shape[2])), image_region), axis=1) 101 | elif x_right >= image.shape[1]: 102 | image_region = np.concatenate((image_region, np.zeros((image_region.shape[0], x_width - image_region.shape[1], image_region.shape[2]))), axis=1) 103 | 104 | if y_left < 0: 105 | image_region = np.concatenate((np.zeros((image_region.shape[0], image_region.shape[1], y_width - image_region.shape[2])), image_region), axis=2) 106 | elif y_right >= image.shape[2]: 107 | image_region = np.concatenate((image_region, np.zeros((image_region.shape[0], image_region.shape[1], y_width - image_region.shape[2]))), axis=2) 108 | # Save into our return array 109 | regions[pixel, ...] = image_region 110 | 111 | else: 112 | # Old Shifting implementation 113 | if x_left < 0: 114 | x_left = 0 115 | x_right = 2 * x_window_size + 1 116 | x_left_hit = True 117 | elif x_right >= image.shape[1]: 118 | x_left = image.shape[1] - 2 * x_window_size - 2 119 | x_right = image.shape[1] - 1 120 | x_right_hit = True 121 | 122 | if y_left < 0: 123 | y_left = 0 124 | y_right = 2 * y_window_size + 1 125 | y_left_hit = True 126 | elif y_right >= image.shape[2]: 127 | y_left = image.shape[2] - 2 * y_window_size - 2 128 | y_right = image.shape[2] - 1 129 | y_right_hit = True 130 | 131 | regions[pixel, ...] = image[:, x_left:x_right, y_left:y_right] 132 | 133 | return regions 134 | 135 | def gather_depths(depths, centroids=None, 136 | depth_bins=None, depth_min=None, depth_max=None, 137 | mask=None, 138 | x_window_size=None, y_window_size=None, 139 | depth_type=0): 140 | """ 141 | Pulls out the needed depths from a given depth map. If given a superpixel 142 | mask, it will average the depths over each superpixel. Otherwise, if given 143 | a list of centroids, it will gather the depths at that those points or 144 | average across a window of a given size if x_window_size and y_window_size 145 | are both specified. All arguments can be provided if depth_type is 146 | specified. For depth_type = 0, the depth at the centroid is returned. For 147 | depth_type = 1, the superpixel average is returned, and if depth_type = 2, 148 | the window average is returned. If depth_bins, depth_min, and depth_max 149 | are provided, the log pixelated depth values are returned. 150 | """ 151 | 152 | if (depth_type is not 0) and (depth_type is not 1) and (depth_type is not 2): 153 | raise ValueError('Invalid depth_type value of %d' % depth_type) 154 | 155 | # if depth_type == 0: 156 | # mask = None 157 | # x_window_size = None 158 | # y_window_size = None 159 | # elif depth_type == 1: 160 | # centroids = None 161 | # x_window_size = None 162 | # y_window_size = None 163 | # elif depth_type == 2: 164 | # mask = None 165 | # else: 166 | # raise ValueError('Invalid depth_type value of %d' % depth_type) 167 | # print "depth type: ", depth_type 168 | #if mask is not None: 169 | if depth_type==1: 170 | mask_vals = np.unique(mask) 171 | no_segments = len(mask_vals) 172 | mask_flat = mask.ravel() 173 | depths_flat = depths.ravel() 174 | if not np.all(mask_vals == range(0, no_segments)): 175 | raise ValueError('Mask does not contain values between 0 and %d' % (no_segments-1)) 176 | #elif centroids is not None: 177 | elif (depth_type==0) or (depth_type==2): 178 | no_segments = centroids.shape[1] 179 | center_pixels = np.array(centroids, dtype=int) 180 | 181 | #else: 182 | # raise ValueError('Neither mask nor centroids provided') 183 | 184 | # window_average = False 185 | # if (x_window_size is not None) and (y_window_size is not None): 186 | # window_average = True 187 | 188 | # preallocate space for the depth values 189 | segment_depths = np.zeros((no_segments, 1)) 190 | 191 | for depth_idx in range(0, no_segments): 192 | #if mask is not None: 193 | if depth_type==1: # Superpixel average 194 | segment_depths[depth_idx] = np.average(depths_flat[mask_flat == depth_idx]) 195 | elif depth_type==2: # Window average 196 | segment_depths[depth_idx] = np.average(depths[ 197 | max(center_pixels[0, depth_idx] - x_window_size, 0): 198 | min(center_pixels[0, depth_idx] + x_window_size, depths.shape[0] - 1), 199 | max(center_pixels[1, depth_idx] - y_window_size, 0): 200 | min(center_pixels[1, depth_idx] + y_window_size, depths.shape[1] - 1)]) 201 | else: # Center-value (no average) 202 | segment_depths[depth_idx] = depths[center_pixels[0, depth_idx], 203 | center_pixels[1, depth_idx]] 204 | 205 | # Convert depths to quantized logspace: 206 | if (depth_bins is not None) and (depth_min is not None) and (depth_max is not None): 207 | segment_depths = \ 208 | log_pixelate_values(segment_depths, bins=depth_bins, min_val=depth_min, max_val=depth_max) 209 | 210 | return segment_depths 211 | 212 | 213 | def load_dataset_segments( 214 | filename=None, 215 | no_superpixels=500, 216 | images=None, 217 | x_window_size=10, 218 | y_window_size=10, 219 | depth_bins=None, depth_min = None, depth_max=None, 220 | depth_type=0): 221 | """ 222 | Combines all of the above to load images segments and their associated 223 | depths from a dataset and and return them as a tuple of ndarrays. 224 | """ 225 | if images == None: 226 | images = range(0, images.shape[0]) 227 | if ((type(images) is not tuple) and (type(images) is not list)): 228 | images = range(0, images) 229 | 230 | [image_set, depths] = load_dataset(filename) 231 | no_segments = no_superpixels * len(images) 232 | segment_depths = np.zeros((no_segments, 1)) 233 | image_segments = np.ndarray((no_segments, 234 | image_set.shape[1], 235 | 2 * x_window_size + 1, 236 | 2 * y_window_size + 1)) 237 | masks = np.zeros((len(images), depths.shape[1], depths.shape[2])) 238 | 239 | current_image = 0 240 | current_segment = 0 241 | for image_idx in images: 242 | image = np.array(image_set[image_idx, ...]) 243 | mask = segment_image(image, no_segments=no_superpixels) 244 | masks[current_image, ...] = mask 245 | centroids = calculate_sp_centroids(mask) 246 | center_pixels = np.array(centroids, dtype=int) 247 | 248 | end_index = current_segment + centroids.shape[1] 249 | if end_index >= image_segments.shape[0]: 250 | image_segments.resize((end_index + 1,) + image_segments.shape[1:]) 251 | if end_index >= segment_depths.shape[0]: 252 | segment_depths.resize((end_index + 1,) + segment_depths.shape[1:]) 253 | 254 | image_segments[current_segment:(current_segment+centroids.shape[1]), ...] = \ 255 | gather_regions(image, centroids, x_window_size=x_window_size, y_window_size=y_window_size) 256 | 257 | segment_depths[current_segment:(current_segment+centroids.shape[1]), ...] = \ 258 | gather_depths(depths[image_idx, ...], 259 | centroids=centroids, 260 | mask=mask, 261 | x_window_size=x_window_size, 262 | y_window_size=y_window_size, 263 | depth_type=depth_type, 264 | depth_bins=depth_bins, 265 | depth_min=depth_min, 266 | depth_max=depth_max) 267 | 268 | current_segment = current_segment + centroids.shape[1] 269 | current_image = current_image + 1 270 | 271 | return image_segments[0:current_segment, ...], segment_depths[0:current_segment, ...], masks 272 | 273 | 274 | 275 | def create_segments_dataset( 276 | input_filename=None, 277 | output_filename=None, 278 | no_superpixels=500, 279 | x_window_size=10, 280 | y_window_size=10, 281 | images=None, 282 | image_output_filepath=None, 283 | depth_bins=None, depth_min = None, depth_max=None, 284 | depth_type=0): 285 | """ 286 | Combines all of the above to load images segments and their associated 287 | depths from a dataset and and return them as a tuple of ndarrays. 288 | 289 | -To output a directory of images w/ index file, provide image_output_filepath. 290 | -To quantize delivered depths into bins, provide depth_bins, depth_min, depth_max 291 | 292 | See gather_depths for depth_type behavior. 293 | """ 294 | 295 | if images == None: 296 | images = range(0, image_set.shape[0]) 297 | if type(images) is not tuple: 298 | images = range(0, images) 299 | 300 | [image_set, depths] = load_dataset(input_filename) 301 | no_segments = no_superpixels * len(images) 302 | 303 | # Check whether to output individual images 304 | indiv_output = (image_output_filepath is not None) 305 | if indiv_output: 306 | if not os.path.exists(image_output_filepath): 307 | os.makedirs(image_output_filepath) 308 | out_log = open(image_output_filepath + '/index.txt','w+') 309 | 310 | # Check if exporting an hdf5 file 311 | hdf5_output = (output_filename is not None) 312 | if hdf5_output: 313 | output_file = h5py.File(output_filename, 'w') 314 | image_segments = output_file.create_dataset("data", 315 | (no_segments, image_set.shape[1], 2 * x_window_size + 1, 2 * y_window_size + 1), 316 | chunks=(1, image_set.shape[1], 2 * x_window_size + 1, 2 * y_window_size + 1)) 317 | 318 | 319 | segment_depths = output_file.create_dataset("label", (no_segments, 1), chunks=True) 320 | segment_image_index = output_file.create_dataset("image", (no_segments, 1), chunks=True) 321 | segment_superpixel_index = output_file.create_dataset("pixel", (no_segments, 1), chunks=True) 322 | else: 323 | segment_image_index = [] 324 | segment_superpixel_index = [] 325 | image_segments = [] 326 | 327 | current_segment = 0 328 | for image_idx in images: 329 | image = np.array(image_set[image_idx, ...]) 330 | mask = segment_image(image, no_segments=no_superpixels) 331 | centroids = calculate_sp_centroids(mask) 332 | center_pixels = np.array(centroids, dtype=int) 333 | 334 | # Resize the arrays if they ended up being too small. 335 | # Will probably only be called on the last image if at all. 336 | end_index = current_segment+centroids.shape[1] 337 | 338 | if (hdf5_output): 339 | if end_index >= image_segments.shape[0]: 340 | image_segments.resize((end_index + 1,) + image_segments.shape[1:]) 341 | segment_depths.resize((end_index + 1,) + segment_depths.shape[1:]) 342 | segment_image_index.resize((end_index + 1,) + segment_image_index.shape[1:]) 343 | segment_superpixel_index.resize((end_index + 1,) + segment_superpixel_index.shape[1:]) 344 | 345 | # Pull out sections around the centroid of the superpixel 346 | image_segments[current_segment:end_index, ...] = \ 347 | gather_regions(image, centroids, 348 | x_window_size=x_window_size, 349 | y_window_size=y_window_size) 350 | 351 | segment_depths[current_segment:(current_segment+centroids.shape[1]), ...] = \ 352 | gather_depths(depths[image_idx, ...], 353 | centroids=centroids, 354 | mask=mask, 355 | x_window_size=x_window_size, 356 | y_window_size=y_window_size, 357 | depth_type=depth_type, 358 | depth_bins=depth_bins, 359 | depth_min=depth_min, 360 | depth_max=depth_max) 361 | 362 | if indiv_output: 363 | for i in range(current_segment,end_index): 364 | name = image_output_filepath + '/' + str(image_idx) + '_' + str(i) + '.jpg' 365 | # write image 366 | scipy.misc.imsave(name,np.transpose(image_segments[i, ...],(0,2,1))) 367 | # append to log 368 | out_log.write(name + ' ' + str(int(segment_depths[i][0])) + '\n') 369 | 370 | 371 | current_segment = current_segment + centroids.shape[1] 372 | # If the number of superpixels was smaller than we expected, resize the 373 | # arrays before returning them 374 | if current_segment != image_segments.shape[0]: 375 | image_segments.resize((current_segment,) + image_segments.shape[1:]) 376 | segment_depths.resize((current_segment,) + segment_depths.shape[1:]) 377 | segment_image_index.resize((current_segment,) + segment_image_index.shape[1:]) 378 | segment_superpixel_index.resize((current_segment,) + segment_superpixel_index.shape[1:]) 379 | return output_file 380 | 381 | 382 | def apply_depths(segment_depths, mask): 383 | depth_image = np.zeros(mask.shape, dtype=segment_depths.dtype) 384 | for depth_index in range(0, len(segment_depths)): 385 | depth_image += segment_depths[depth_index] * (mask == depth_index) 386 | return depth_image 387 | 388 | def create_segments_directory( 389 | input_filename=None, 390 | image_output_filepath=None, 391 | no_superpixels=200, 392 | x_window_size=10, 393 | y_window_size=10, 394 | images=None, 395 | depth_bins=None, depth_min = None, depth_max=None, depth_type=0, 396 | output_images=True, index_name='index.txt'): 397 | """ 398 | outputs a directory of image segments, with index file. 399 | """ 400 | # Select which images to work with 401 | if images == None: 402 | images = range(0, image_set.shape[0]) 403 | if type(images) is not tuple: 404 | images = range(0, images) 405 | 406 | [image_set, depths] = load_dataset(input_filename) 407 | # no_segments = no_superpixels * len(images) 408 | 409 | print "image_set shape: ", image_set.shape 410 | # Create output directory 411 | if not os.path.exists(image_output_filepath): 412 | os.makedirs(image_output_filepath) 413 | out_log = open(image_output_filepath + '/' + index_name,'a') 414 | 415 | for image_idx in images: 416 | 417 | print 'processing image', image_idx 418 | 419 | # Preprocess image 420 | [image_segments, mask, segment_depths] = preprocess_image(image_set[image_idx[0]],true_depth=depths[image_idx[0]], 421 | no_superpixels=no_superpixels, x_window_size=x_window_size,y_window_size=y_window_size, 422 | depth_bins=depth_bins,depth_min=depth_min,depth_max=depth_max,depth_type=depth_type); 423 | 424 | for i in range(image_segments.shape[0]): 425 | name = str(image_idx) + '_' + str(i) + '.jpg' 426 | 427 | # write image 428 | if output_images: 429 | scipy.misc.imsave(image_output_filepath + '/' + name,np.transpose(image_segments[i, ...],(0,2,1))) 430 | 431 | out_log.write(image_output_filepath + '/' + name + ' ' + str(int(segment_depths[i])) + '\n') 432 | 433 | 434 | def find_neighbors(mask): 435 | """ 436 | Generates a list of edges that connect neighboring superpixels that 437 | connect each other from a segmentation mask. 438 | Returns a Nx2 np.array of edges. 439 | """ 440 | # Generate a symmetric matrix with a one representing a neighboring 441 | # connection 442 | no_pixels=len(np.unique(mask)) 443 | adjacent = np.zeros((no_pixels,no_pixels), dtype=bool) 444 | for idx_x in range(0, mask.shape[0]-1): 445 | for idx_y in range(0, mask.shape[1]-1): 446 | # Check left to right 447 | if mask[idx_x][idx_y] != mask[idx_x+1][idx_y]: 448 | adjacent[mask[idx_x][idx_y], mask[idx_x+1][idx_y]] = 1 449 | adjacent[mask[idx_x+1][idx_y], mask[idx_x][idx_y]] = 1 450 | # Check Top-Down 451 | if mask[idx_x][idx_y] != mask[idx_x][idx_y+1]: 452 | adjacent[mask[idx_x][idx_y], mask[idx_x][idx_y+1]] = 1 453 | adjacent[mask[idx_x][idx_y+1], mask[idx_x][idx_y]] = 1 454 | 455 | # From the upper triangle of the matrix list out a unique set of 456 | # edges for the pixels 457 | edges = np.zeros((np.sum(adjacent) / 2, 2)) 458 | idx_edge = 0 459 | for idx_x in range(0, adjacent.shape[0]): 460 | for idx_y in range(idx_x, adjacent.shape[1]): 461 | if adjacent[idx_x, idx_y]: 462 | edges[idx_edge, 0] = idx_x 463 | edges[idx_edge, 1] = idx_y 464 | idx_edge += 1 465 | return edges 466 | 467 | def preprocess_image( 468 | image, true_depth=None, 469 | no_superpixels=200, 470 | x_window_size=10, 471 | y_window_size=10, 472 | depth_bins=None, depth_min = None, depth_max=None, depth_type=0): 473 | """ 474 | Returns image segments, etc. 475 | Depth_type: 476 | 0: Center value only 477 | 1: Average over superpixel 478 | 2: Average over patch 479 | """ 480 | no_segments = no_superpixels 481 | 482 | 483 | image_segments = np.ndarray([no_segments,3,2*x_window_size+1, 2*y_window_size+1]) 484 | segment_depths = np.ndarray(no_segments) 485 | 486 | masks = segment_image(image, no_segments=no_superpixels) 487 | centroids = calculate_sp_centroids(masks) 488 | center_pixels = np.array(centroids, dtype=int) 489 | 490 | # Pull out sections around the centroid of the superpixel 491 | image_segments = \ 492 | gather_regions(image, centroids, 493 | x_window_size=x_window_size, 494 | y_window_size=y_window_size) 495 | 496 | # # If provided depth maps, quantize and return those too 497 | if true_depth is not None: 498 | segment_depths = \ 499 | gather_depths(true_depth, 500 | centroids=centroids, 501 | mask=masks, 502 | x_window_size=x_window_size, 503 | y_window_size=y_window_size, 504 | depth_type=depth_type, 505 | depth_bins=depth_bins, 506 | depth_min=depth_min, 507 | depth_max=depth_max) 508 | 509 | if true_depth is not None: 510 | return image_segments, masks, segment_depths 511 | else: 512 | return image_segments, masks 513 | 514 | def logistic_vector_dist(vector1, vector2, gamma=1): 515 | """ 516 | Take two vectors, take their L2 norm, and then logistically regress that 517 | value to keep the result between 0 and 1. gamma is a parameter that 518 | controls the scaling between 0 and 1 (although 0 only reached 519 | asymmtotically). 520 | """ 521 | if not np.all(vector1.shape == vector2.shape): 522 | raise ValueError('Inputs are not the same shape.') 523 | return np.exp(-gamma * np.linalg.norm(vector2.ravel() - vector1.ravel())) 524 | 525 | def hist_colors(image, color_bins=256, color_min=0, color_max=255): 526 | """ 527 | Generate histograms of the colors contained within an image, which 528 | are assumed to be in the first axis. Any number of colors are allowed. 529 | """ 530 | color_hist = np.zeros((image.shape[0], color_bins)) 531 | color_flat = np.reshape(image, (image.shape[0], -1)) 532 | for color_idx in range(0, image.shape[0]): 533 | color_hist[color_idx, :] = np.histogram(color_flat[color_idx, :], 534 | color_bins, 535 | (color_min, color_max))[0] 536 | return color_hist 537 | 538 | 539 | def logistic_color_hist_diff( 540 | image1, 541 | image2, 542 | color_bins=256, 543 | color_min=0, 544 | color_max=255, 545 | gamma=1e-4): 546 | """ 547 | Compare the logistically regressed distance between the color content of 548 | two images by taking the histograms of the provided images, assuming the 549 | color is placed in axis=0. gamma chosen purely hearuistically to provide 550 | decent dynamic range as seen in image_handling_tb.ipynb, figure 14. 551 | """ 552 | return logistic_vector_dist( 553 | hist_colors(image1, color_bins, color_min, color_max), 554 | hist_colors(image2, color_bins, color_min, color_max), 555 | gamma) 556 | 557 | 558 | def logistic_color_diff(image1, image2, gamma=4e-5): 559 | """ 560 | Generate a logistically regressed distance between two color images. 561 | gamma chosen purely hearuistically to provide decent dynamic range 562 | as seen in image_handling_tb.ipynb, figure 14. 563 | """ 564 | return logistic_vector_dist(image1, image2, gamma) 565 | 566 | 567 | def logistic_lbp_diff(image1, image2, gamma=1e-3, points=4, radius=2): 568 | """ 569 | Generate local binary patterns (LBP) for each of the images by taking the 570 | average across the color components (assumed to be axis = 0), and then 571 | generating a LBP using a given number of points and comparing at a given 572 | radius away from the center of the image. The distance between the LBPs 573 | is regressed. gamma, points, and radius defaults chosen purely 574 | hearuistically to provide decent dynamic range as seen in 575 | image_handling_tb.ipynb, figure 14. 576 | """ 577 | return logistic_vector_dist( 578 | local_binary_pattern(np.average(image1, axis=0), points, radius), 579 | local_binary_pattern(np.average(image2, axis=0), points, radius), 580 | gamma) 581 | 582 | 583 | def pairwise_distance_matrices(segments, edges=None, mask=None): 584 | """ 585 | Given a number of segments and the edges that connect them, or a mask from 586 | which a set of edges that connect neighbors can be defined, this generates 587 | a 3xlen(segments)xlen(segments) listing the distance between all of the 588 | different segments. The [i, j, k] value of the returned array represents 589 | the ith type of distance metric between segments j and k. If the segments 590 | are not neighbors then the distance is left as zero. The 3 distance 591 | metrics are, 1, the logistic color difference, 2, the logistic color 592 | histogram difference, and, 3, the local binary pattern difference. 593 | """ 594 | no_segments = len(segments) 595 | distances = np.zeros((3, no_segments, no_segments)) 596 | 597 | if edges is None: 598 | if mask is None: 599 | raise ValueError('Neither edges nor mask provided') 600 | else: 601 | edges = find_neighbors(mask) 602 | 603 | for edge in edges: 604 | distances[0, edge[0], edge[1]] = \ 605 | logistic_color_diff(segments[edge[0], ...], 606 | segments[edge[1], ...]) 607 | distances[1, edge[0], edge[1]] = \ 608 | logistic_color_hist_diff(segments[edge[0], ...], 609 | segments[edge[1], ...]) 610 | distances[2, edge[0], edge[1]] = \ 611 | logistic_lbp_diff(segments[edge[0], ...], 612 | segments[edge[1], ...]) 613 | 614 | return distances 615 | 616 | 617 | def graph_cut_pairwise_array( 618 | segments, 619 | edges=None, 620 | mask=None, 621 | distance_type=1): 622 | """ 623 | Given a number of segments and the edges that connect them, or a mask from 624 | which a set of edges that connect neighbors can be defined, this generates 625 | an array len(edges)x3 listing the distance between all of the edges. The 626 | first two columns represent the edges of the graph and the third column is 627 | the edge weight. The 3 distance metrics are, 0, the logistic color 628 | difference, 1, the logistic color histogram difference (default), and, 2, 629 | the local binary pattern difference. 630 | """ 631 | no_segments = len(segments) 632 | 633 | if edges is None: 634 | if mask is None: 635 | raise ValueError('Neither edges nor mask provided') 636 | else: 637 | edges = find_neighbors(mask) 638 | 639 | graph_cut_array = np.zeros((edges.shape[0], edges.shape[1] + 1)) 640 | graph_cut_array[:, 0:edges.shape[1]] = edges 641 | 642 | edge_idx = 0 643 | for edge in edges: 644 | if distance_type == 0: 645 | graph_cut_array[edge_idx, -1] = \ 646 | logistic_color_diff(segments[edge[0], ...], 647 | segments[edge[1], ...]) 648 | elif distance_type == 1: 649 | graph_cut_array[edge_idx, -1] = \ 650 | logistic_color_hist_diff(segments[edge[0], ...], 651 | segments[edge[1], ...]) 652 | elif distance_type == 2: 653 | graph_cut_array[edge_idx, -1] = \ 654 | logistic_lbp_diff(segments[edge[0], ...], 655 | segments[edge[1], ...]) 656 | else: 657 | raise ValueError('Invalid distance_type of %d given' % distance_type) 658 | edge_idx += 1 659 | return graph_cut_array 660 | 661 | -------------------------------------------------------------------------------- /make_db_mean.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | # Compute the mean image from a training database 3 | 4 | 5 | TRAIN_DB_PATH=mean_hack_lmdb 6 | OUTPUT_PATH=mean.binaryproto 7 | 8 | compute_image_mean $TRAIN_DB_PATH \ 9 | $OUTPUT_PATH 10 | 11 | echo "Done." 12 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/solver_softmax_dir.prototxt: -------------------------------------------------------------------------------- 1 | net: "models/unary_depth_regressor/udr_softmax_dir.prototxt" 2 | test_iter: 100 # Test set: 125,569 images (~490x256 batches) 3 | test_interval:1000 4 | #solver_type: ADAGRAD # Sure, let's try this! 5 | # lr for fine-tuning should be lower than when starting from scratch 6 | base_lr: 0.001 7 | lr_policy: "step" 8 | gamma: 0.5 9 | # stepsize should also be lower, as we're closer to being done 10 | stepsize: 5000 # Interval between learning_rate drops 11 | display: 20 12 | max_iter: 40000 13 | momentum: 0.9 14 | weight_decay: 0.0005 15 | snapshot: 1000 16 | snapshot_prefix: "models/unary_depth_regressor/snapshots_softmax/softmax_centerdepth" 17 | # uncomment the following to default to CPU mode solving 18 | # solver_mode: CPU 19 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/solver_udr_euclidean_lmdb.prototxt: -------------------------------------------------------------------------------- 1 | net: "models/unary_depth_regressor/udr_euclidean_lmdb.prototxt" 2 | test_iter: 100 # Test set: 125,569 images (~490x256 batches) 3 | test_interval:10000 4 | # solver_type: ADAGRAD # Sure, let's try this! 5 | # lr for fine-tuning should be lower than when starting from scratch 6 | base_lr: 0.0001 7 | lr_policy: "step" 8 | gamma: 0.4 9 | # stepsize should also be lower, as we're closer to being done 10 | stepsize: 12000 # Interval between learning_rate drops 11 | display: 20 12 | max_iter: 40000 13 | momentum: 0.9 14 | weight_decay: 0.0005 15 | snapshot: 1000 16 | snapshot_prefix: "models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_d128_slowlearn_snapshot" 17 | # uncomment the following to default to CPU mode solving 18 | # solver_mode: CPU 19 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/solver_udr_softmax_lmdb.prototxt: -------------------------------------------------------------------------------- 1 | net: "models/unary_depth_regressor/udr_softmax_lmdb.prototxt" 2 | test_iter: 100 # Test set: 125,569 images (~490x256 batches) 3 | test_interval:1000 4 | # solver_type: ADAGRAD # Sure, let's try this! 5 | # lr for fine-tuning should be lower than when starting from scratch 6 | base_lr: 0.01 7 | lr_policy: "step" 8 | gamma: 0.1 9 | # stepsize should also be lower, as we're closer to being done 10 | stepsize: 10000 # Interval between learning_rate drops 11 | display: 20 12 | max_iter: 100000 13 | momentum: 0.9 14 | weight_decay: 0.0005 15 | snapshot: 1000 16 | snapshot_prefix: "models/unary_depth_regressor/snapshots/udr_softmax_lmdb_167_snapshot" 17 | # uncomment the following to default to CPU mode solving 18 | # solver_mode: CPU 19 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/udr_euclidean_deploy.prototxt: -------------------------------------------------------------------------------- 1 | # Pretrained via softmax classifier; now stepping forward to Euclidean 2 | name: "Unary depth regressor, euclidean version, deploy" 3 | 4 | # use this style for running mode 5 | input: "data" 6 | input_dim: 1 7 | input_dim: 3 8 | input_dim: 227 9 | input_dim: 227 10 | 11 | layers { 12 | name: "conv1" 13 | type: CONVOLUTION 14 | bottom: "data" 15 | top: "conv1" 16 | blobs_lr: 0 # learning rate multiplier for the filters 17 | blobs_lr: 0 # learning rate multiplier for the biases 18 | weight_decay: 1 # weight decay multiplier for the filters 19 | weight_decay: 0 # weight decay multiplier for the biases 20 | convolution_param { 21 | num_output: 96 # learn 96 filters 22 | kernel_size: 11 # each filter is 11x11 23 | stride: 4 # step 4 pixels between each filter application 24 | weight_filler { 25 | type: "gaussian" # initialize the filters from a Gaussian 26 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 27 | } 28 | bias_filler { 29 | type: "constant" # initialize the biases to zero (0) 30 | value: 0 31 | } 32 | } 33 | } 34 | 35 | layers { 36 | name: "relu1" 37 | type: RELU 38 | bottom: "conv1" 39 | top: "conv1" 40 | } 41 | layers { 42 | name: "pool1" 43 | type: POOLING 44 | bottom: "conv1" 45 | top: "pool1" 46 | pooling_param { 47 | pool: MAX 48 | kernel_size: 3 49 | stride: 2 50 | } 51 | } 52 | layers { 53 | name: "norm1" 54 | type: LRN 55 | bottom: "pool1" 56 | top: "norm1" 57 | lrn_param { 58 | local_size: 5 59 | alpha: 0.0001 60 | beta: 0.75 61 | } 62 | } 63 | 64 | layers { 65 | name: "conv2" 66 | type: CONVOLUTION 67 | bottom: "norm1" 68 | top: "conv2" 69 | blobs_lr: 0 # learning rate multiplier for the filters 70 | blobs_lr: 0 # learning rate multiplier for the biases 71 | convolution_param { 72 | num_output: 256 73 | pad: 2 74 | kernel_size: 5 75 | group: 2 76 | weight_filler { 77 | type: "gaussian" # initialize the filters from a Gaussian 78 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 79 | } 80 | bias_filler { 81 | type: "constant" 82 | value: 1.0 83 | } 84 | } 85 | } 86 | layers { 87 | name: "relu2" 88 | type: RELU 89 | bottom: "conv2" 90 | top: "conv2" 91 | } 92 | layers { 93 | name: "pool2" 94 | type: POOLING 95 | bottom: "conv2" 96 | top: "pool2" 97 | pooling_param { 98 | pool: MAX 99 | kernel_size: 3 100 | stride: 2 101 | } 102 | } 103 | layers { 104 | name: "norm2" 105 | type: LRN 106 | bottom: "pool2" 107 | top: "norm2" 108 | lrn_param { 109 | local_size: 5 110 | alpha: 0.0001 111 | beta: 0.75 112 | } 113 | } 114 | 115 | layers { 116 | name: "conv3" 117 | type: CONVOLUTION 118 | bottom: "norm2" 119 | top: "conv3" 120 | blobs_lr: 0 # learning rate multiplier for the filters 121 | blobs_lr: 0 # learning rate multiplier for the biases 122 | convolution_param { 123 | num_output: 384 124 | pad: 1 125 | kernel_size: 3 126 | } 127 | } 128 | layers { 129 | name: "relu3" 130 | type: RELU 131 | bottom: "conv3" 132 | top: "conv3" 133 | } 134 | layers { 135 | name: "conv4" 136 | type: CONVOLUTION 137 | bottom: "conv3" 138 | top: "conv4" 139 | blobs_lr: 0 # learning rate multiplier for the filters 140 | blobs_lr: 0 # learning rate multiplier for the biases 141 | convolution_param { 142 | num_output: 384 143 | pad: 1 144 | kernel_size: 3 145 | group: 2 146 | } 147 | } 148 | layers { 149 | name: "relu4" 150 | type: RELU 151 | bottom: "conv4" 152 | top: "conv4" 153 | } 154 | 155 | layers { 156 | name: "conv5" 157 | type: CONVOLUTION 158 | bottom: "conv4" 159 | top: "conv5" 160 | blobs_lr: 0 # learning rate multiplier for the filters 161 | blobs_lr: 0 # learning rate multiplier for the biases 162 | convolution_param { 163 | num_output: 256 164 | pad: 1 165 | kernel_size: 3 166 | group: 2 167 | } 168 | } 169 | layers { 170 | name: "relu5" 171 | type: RELU 172 | bottom: "conv5" 173 | top: "conv5" 174 | } 175 | 176 | layers { 177 | name: "pool5" 178 | type: POOLING 179 | bottom: "conv5" 180 | top: "pool5" 181 | pooling_param { 182 | pool: MAX 183 | kernel_size: 3 184 | stride: 2 185 | } 186 | } 187 | 188 | layers { 189 | name: "fc6" 190 | type: INNER_PRODUCT 191 | bottom: "pool5" 192 | top: "fc6" 193 | inner_product_param { 194 | num_output: 4096 195 | } 196 | } 197 | layers { 198 | name: "relu6" 199 | type: RELU 200 | bottom: "fc6" 201 | top: "fc6" 202 | } 203 | layers { 204 | name: "drop6" 205 | type: DROPOUT 206 | bottom: "fc6" 207 | top: "fc6" 208 | dropout_param { 209 | dropout_ratio: 0.5 210 | } 211 | } 212 | layers { 213 | name: "fc7" 214 | type: INNER_PRODUCT 215 | bottom: "fc6" 216 | top: "fc7" 217 | inner_product_param { 218 | num_output: 4096 219 | weight_filler { 220 | type: "gaussian" 221 | std: 0.01 222 | } 223 | bias_filler { 224 | type: "constant" 225 | value: 0 226 | } 227 | } 228 | 229 | blobs_lr: 1 230 | blobs_lr: 1 231 | } 232 | layers { 233 | name: "relu7" 234 | type: RELU 235 | bottom: "fc7" 236 | top: "fc7" 237 | } 238 | layers { 239 | name: "drop7" 240 | type: DROPOUT 241 | bottom: "fc7" 242 | top: "fc7" 243 | dropout_param { 244 | dropout_ratio: 0.5 245 | } 246 | } 247 | 248 | layers { 249 | name: "fc_n1" 250 | type: INNER_PRODUCT 251 | bottom: "fc7" 252 | top: "fc_n1" 253 | inner_product_param { 254 | num_output: 128 255 | weight_filler { 256 | type: "gaussian" 257 | std: 0.01 258 | } 259 | bias_filler { 260 | type: "constant" 261 | value: 0 262 | } 263 | } 264 | blobs_lr: 1 265 | blobs_lr: 1 266 | } 267 | layers { 268 | name: "relu_n1" 269 | type: RELU 270 | bottom: "fc_n1" 271 | top: "fc_n1" 272 | } 273 | layers { 274 | name: "drop_n1" 275 | type: DROPOUT 276 | bottom: "fc_n1" 277 | top: "fc_n1" 278 | dropout_param { 279 | dropout_ratio: 0.5 280 | } 281 | 282 | } 283 | 284 | layers { 285 | name: "fc_n2" 286 | type: INNER_PRODUCT 287 | bottom: "fc_n1" 288 | top: "fc_n2" 289 | inner_product_param { 290 | num_output: 16 291 | weight_filler { 292 | type: "gaussian" 293 | std: 0.01 294 | } 295 | bias_filler { 296 | type: "constant" 297 | value: 0 298 | } 299 | } 300 | blobs_lr: 1 301 | blobs_lr: 1 302 | } 303 | #layers { 304 | # name: "prob" 305 | # type: SOFTMAX_LOSS 306 | # bottom: "fc_n2" 307 | # bottom: "label" 308 | # top: "prob" 309 | #} 310 | # 311 | #layers { 312 | # name: "accuracy" 313 | # type: ACCURACY 314 | # bottom: "fc_n2" 315 | # bottom: "label" 316 | # top: "accuracy" 317 | # include: { phase: TEST } 318 | #} 319 | 320 | 321 | # EUCLIDEAN LOSS LAYER / FOR REGRESSION 322 | layers { 323 | name: "prob" 324 | type: SOFTMAX 325 | bottom: "fc_n2" 326 | top: "fc_n3" 327 | } 328 | 329 | 330 | layers { 331 | name: "output_neuron" 332 | type: INNER_PRODUCT 333 | bottom: "fc_n3" 334 | top: "output_neuron" 335 | inner_product_param { 336 | num_output: 1 337 | } 338 | } 339 | #layers { 340 | # name: "loss" 341 | # type: EUCLIDEAN_LOSS 342 | # bottom: "output_neuron" 343 | # bottom: "label" 344 | #} 345 | 346 | 347 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/udr_euclidean_lmdb.prototxt: -------------------------------------------------------------------------------- 1 | # Pretrained via softmax classifier; now stepping forward to Euclidean 2 | name: "Unary depth regressor, euclidean version" 3 | 4 | # use this style for running mode 5 | #input: "data" 6 | #input_dim: 16 7 | #input_dim: 3 8 | #input_dim: 227 9 | #input_dim: 227 10 | 11 | ### LMDB INPUTS 12 | #layers { 13 | # name: "data" 14 | # type: DATA 15 | # top: "data" 16 | # top: "label" 17 | # transform_param { 18 | # #mirror: true 19 | # #crop_size: 227 20 | # # (Mean file is same for d16 and d128) 21 | # mean_file: "train/NYUv2/NYUv2_train_mean_full_167_resize_d16.binaryproto" 22 | # } 23 | # data_param { 24 | # source: "train/NYUv2/NYUv2_train_full_167_resize_d128_lmdb" 25 | # backend: LMDB 26 | # batch_size: 128 27 | # } 28 | # include: { phase: TRAIN } 29 | #} 30 | # 31 | #layers { 32 | # name: "data" 33 | # type: DATA 34 | # top: "data" 35 | # top: "label" 36 | # transform_param { 37 | # #mirror: true 38 | # #crop_size: 227 39 | # mean_file: "train/NYUv2/NYUv2_test_mean_full_167_resize_d16.binaryproto" 40 | # } 41 | # data_param { 42 | # source: "train/NYUv2/NYUv2_test_full_167_resize_d128_lmdb" 43 | # batch_size: 128 44 | # backend: LMDB 45 | # } 46 | # include: { phase: TEST } 47 | #} 48 | 49 | 50 | layers { 51 | name: "data" 52 | type: IMAGE_DATA 53 | top: "data" 54 | top: "label" 55 | transform_param { 56 | # (Mean file is same for d16 and d128) 57 | mean_file: "train/NYUv2/NYUv2_train_mean_full_167_resize_d16.binaryproto" 58 | } 59 | image_data_param { 60 | new_width: 227 61 | new_height: 227 62 | source: "train/NYUv2/train_full_167_v2/index_16_fullpath.txt" 63 | batch_size: 128 64 | } 65 | include: { phase: TRAIN } 66 | } 67 | 68 | layers { 69 | name: "data" 70 | type: IMAGE_DATA 71 | top: "data" 72 | top: "label" 73 | transform_param { 74 | mean_file: "train/NYUv2/NYUv2_test_mean_full_167_resize_d16.binaryproto" 75 | } 76 | image_data_param { 77 | new_width: 227 78 | new_height: 227 79 | source: "train/NYUv2/test_full_167_v2/index_16_fullpath.txt" 80 | batch_size: 128 81 | } 82 | include: { phase: TEST } 83 | } 84 | 85 | 86 | 87 | ### PRE-TRAINED LAYERS ------------------------------------------ 88 | layers { 89 | name: "conv1" 90 | type: CONVOLUTION 91 | bottom: "data" 92 | top: "conv1" 93 | blobs_lr: 0 # learning rate multiplier for the filters 94 | blobs_lr: 0 # learning rate multiplier for the biases 95 | weight_decay: 1 # weight decay multiplier for the filters 96 | weight_decay: 0 # weight decay multiplier for the biases 97 | convolution_param { 98 | num_output: 96 # learn 96 filters 99 | kernel_size: 11 # each filter is 11x11 100 | stride: 4 # step 4 pixels between each filter application 101 | weight_filler { 102 | type: "gaussian" # initialize the filters from a Gaussian 103 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 104 | } 105 | bias_filler { 106 | type: "constant" # initialize the biases to zero (0) 107 | value: 0 108 | } 109 | } 110 | } 111 | 112 | layers { 113 | name: "relu1" 114 | type: RELU 115 | bottom: "conv1" 116 | top: "conv1" 117 | } 118 | layers { 119 | name: "pool1" 120 | type: POOLING 121 | bottom: "conv1" 122 | top: "pool1" 123 | pooling_param { 124 | pool: MAX 125 | kernel_size: 3 126 | stride: 2 127 | } 128 | } 129 | layers { 130 | name: "norm1" 131 | type: LRN 132 | bottom: "pool1" 133 | top: "norm1" 134 | lrn_param { 135 | local_size: 5 136 | alpha: 0.0001 137 | beta: 0.75 138 | } 139 | } 140 | 141 | layers { 142 | name: "conv2" 143 | type: CONVOLUTION 144 | bottom: "norm1" 145 | top: "conv2" 146 | blobs_lr: 0 # learning rate multiplier for the filters 147 | blobs_lr: 0 # learning rate multiplier for the biases 148 | convolution_param { 149 | num_output: 256 150 | pad: 2 151 | kernel_size: 5 152 | group: 2 153 | weight_filler { 154 | type: "gaussian" # initialize the filters from a Gaussian 155 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 156 | } 157 | bias_filler { 158 | type: "constant" 159 | value: 1.0 160 | } 161 | } 162 | } 163 | layers { 164 | name: "relu2" 165 | type: RELU 166 | bottom: "conv2" 167 | top: "conv2" 168 | } 169 | layers { 170 | name: "pool2" 171 | type: POOLING 172 | bottom: "conv2" 173 | top: "pool2" 174 | pooling_param { 175 | pool: MAX 176 | kernel_size: 3 177 | stride: 2 178 | } 179 | } 180 | layers { 181 | name: "norm2" 182 | type: LRN 183 | bottom: "pool2" 184 | top: "norm2" 185 | lrn_param { 186 | local_size: 5 187 | alpha: 0.0001 188 | beta: 0.75 189 | } 190 | } 191 | 192 | layers { 193 | name: "conv3" 194 | type: CONVOLUTION 195 | bottom: "norm2" 196 | top: "conv3" 197 | blobs_lr: 0 # learning rate multiplier for the filters 198 | blobs_lr: 0 # learning rate multiplier for the biases 199 | convolution_param { 200 | num_output: 384 201 | pad: 1 202 | kernel_size: 3 203 | } 204 | } 205 | layers { 206 | name: "relu3" 207 | type: RELU 208 | bottom: "conv3" 209 | top: "conv3" 210 | } 211 | layers { 212 | name: "conv4" 213 | type: CONVOLUTION 214 | bottom: "conv3" 215 | top: "conv4" 216 | blobs_lr: 0 # learning rate multiplier for the filters 217 | blobs_lr: 0 # learning rate multiplier for the biases 218 | convolution_param { 219 | num_output: 384 220 | pad: 1 221 | kernel_size: 3 222 | group: 2 223 | } 224 | } 225 | layers { 226 | name: "relu4" 227 | type: RELU 228 | bottom: "conv4" 229 | top: "conv4" 230 | } 231 | 232 | layers { 233 | name: "conv5" 234 | type: CONVOLUTION 235 | bottom: "conv4" 236 | top: "conv5" 237 | blobs_lr: 0 # learning rate multiplier for the filters 238 | blobs_lr: 0 # learning rate multiplier for the biases 239 | convolution_param { 240 | num_output: 256 241 | pad: 1 242 | kernel_size: 3 243 | group: 2 244 | } 245 | } 246 | layers { 247 | name: "relu5" 248 | type: RELU 249 | bottom: "conv5" 250 | top: "conv5" 251 | } 252 | 253 | layers { 254 | name: "pool5" 255 | type: POOLING 256 | bottom: "conv5" 257 | top: "pool5" 258 | pooling_param { 259 | pool: MAX 260 | kernel_size: 3 261 | stride: 2 262 | } 263 | } 264 | 265 | 266 | 267 | ### FULLY-CONNECTED LAYERS ------------------------------------------ 268 | layers { 269 | name: "fc6" 270 | type: INNER_PRODUCT 271 | bottom: "pool5" 272 | top: "fc6" 273 | inner_product_param { 274 | num_output: 4096 275 | weight_filler { 276 | type: "gaussian" 277 | std: 0.01 278 | } 279 | bias_filler { 280 | type: "constant" 281 | value: 0 282 | } 283 | } 284 | blobs_lr: 1 285 | blobs_lr: 0.1 286 | } 287 | layers { 288 | name: "relu6" 289 | type: RELU 290 | bottom: "fc6" 291 | top: "fc6" 292 | } 293 | layers { 294 | name: "drop6" 295 | type: DROPOUT 296 | bottom: "fc6" 297 | top: "fc6" 298 | dropout_param { 299 | dropout_ratio: 0.5 300 | } 301 | } 302 | layers { 303 | name: "fc7" 304 | type: INNER_PRODUCT 305 | bottom: "fc6" 306 | top: "fc7" 307 | inner_product_param { 308 | num_output: 4096 309 | weight_filler { 310 | type: "gaussian" 311 | std: 0.01 312 | } 313 | bias_filler { 314 | type: "constant" 315 | value: 0 316 | } 317 | } 318 | 319 | blobs_lr: 1 320 | blobs_lr: 0.1 321 | } 322 | layers { 323 | name: "relu7" 324 | type: RELU 325 | bottom: "fc7" 326 | top: "fc7" 327 | } 328 | layers { 329 | name: "drop7" 330 | type: DROPOUT 331 | bottom: "fc7" 332 | top: "fc7" 333 | dropout_param { 334 | dropout_ratio: 0.5 335 | } 336 | } 337 | 338 | layers { 339 | name: "fc_n1" 340 | type: INNER_PRODUCT 341 | bottom: "fc7" 342 | top: "fc_n1" 343 | inner_product_param { 344 | num_output: 128 345 | weight_filler { 346 | type: "gaussian" 347 | std: 0.01 348 | } 349 | bias_filler { 350 | type: "constant" 351 | value: 0 352 | } 353 | } 354 | blobs_lr: 1 355 | blobs_lr: 0.1 356 | } 357 | layers { 358 | name: "relu_n1" 359 | type: RELU 360 | bottom: "fc_n1" 361 | top: "fc_n1" 362 | } 363 | layers { 364 | name: "drop_n1" 365 | type: DROPOUT 366 | bottom: "fc_n1" 367 | top: "fc_n1" 368 | dropout_param { 369 | dropout_ratio: 0.5 370 | } 371 | 372 | } 373 | 374 | layers { 375 | name: "fc_n2" 376 | type: INNER_PRODUCT 377 | bottom: "fc_n1" 378 | top: "fc_n2" 379 | inner_product_param { 380 | num_output: 16 381 | weight_filler { 382 | type: "gaussian" 383 | std: 0.01 384 | } 385 | bias_filler { 386 | type: "constant" 387 | value: 0 388 | } 389 | } 390 | blobs_lr: 1 391 | blobs_lr: 0.1 392 | } 393 | #layers { 394 | # name: "prob" 395 | # type: SOFTMAX_LOSS 396 | # bottom: "fc_n2" 397 | # bottom: "label" 398 | # top: "prob" 399 | #} 400 | # 401 | #layers { 402 | # name: "accuracy" 403 | # type: ACCURACY 404 | # bottom: "fc_n2" 405 | # bottom: "label" 406 | # top: "accuracy" 407 | # include: { phase: TEST } 408 | #} 409 | 410 | 411 | # Pre-sum Nonlinearity 412 | #layers { 413 | # name: "relu8" 414 | # type: RELU 415 | # bottom: "fc_n2" 416 | # top: "fc_n2" 417 | #} 418 | #layers { 419 | # name: "drop_n2" 420 | # type: DROPOUT 421 | # bottom: "fc_n2" 422 | # top: "fc_n2" 423 | # dropout_param { 424 | # dropout_ratio: 0.5 425 | # } 426 | #} 427 | 428 | layers { 429 | name: "prob" 430 | type: SOFTMAX 431 | bottom: "fc_n2" 432 | top: "fc_n3" 433 | } 434 | 435 | 436 | layers { 437 | name: "output_neuron" 438 | type: INNER_PRODUCT 439 | bottom: "fc_n3" 440 | #bottom: "fc_n2" 441 | 442 | top: "output_neuron" 443 | inner_product_param { 444 | num_output: 1 445 | } 446 | } 447 | layers { 448 | name: "loss" 449 | type: EUCLIDEAN_LOSS 450 | bottom: "output_neuron" 451 | bottom: "label" 452 | } 453 | 454 | 455 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/udr_softmax_deploy_2.prototxt: -------------------------------------------------------------------------------- 1 | # Pretrained via softmax classifier; now stepping forward to Euclidean 2 | name: "Unary depth regressor, softmax version: Deploy" 3 | 4 | # use this style for running mode 5 | input: "data" 6 | input_dim: 1 7 | input_dim: 3 8 | input_dim: 227 9 | input_dim: 227 10 | 11 | 12 | ### PRE-TRAINED LAYERS ------------------------------------------ 13 | layers { 14 | name: "conv1" 15 | type: CONVOLUTION 16 | bottom: "data" 17 | top: "conv1" 18 | blobs_lr: 0 # learning rate multiplier for the filters 19 | blobs_lr: 0 # learning rate multiplier for the biases 20 | weight_decay: 1 # weight decay multiplier for the filters 21 | weight_decay: 0 # weight decay multiplier for the biases 22 | convolution_param { 23 | num_output: 96 # learn 96 filters 24 | kernel_size: 11 # each filter is 11x11 25 | stride: 4 # step 4 pixels between each filter application 26 | weight_filler { 27 | type: "gaussian" # initialize the filters from a Gaussian 28 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 29 | } 30 | bias_filler { 31 | type: "constant" # initialize the biases to zero (0) 32 | value: 0 33 | } 34 | } 35 | } 36 | 37 | layers { 38 | name: "relu1" 39 | type: RELU 40 | bottom: "conv1" 41 | top: "conv1" 42 | } 43 | layers { 44 | name: "pool1" 45 | type: POOLING 46 | bottom: "conv1" 47 | top: "pool1" 48 | pooling_param { 49 | pool: MAX 50 | kernel_size: 3 51 | stride: 2 52 | } 53 | } 54 | layers { 55 | name: "norm1" 56 | type: LRN 57 | bottom: "pool1" 58 | top: "norm1" 59 | lrn_param { 60 | local_size: 5 61 | alpha: 0.0001 62 | beta: 0.75 63 | } 64 | } 65 | 66 | layers { 67 | name: "conv2" 68 | type: CONVOLUTION 69 | bottom: "norm1" 70 | top: "conv2" 71 | blobs_lr: 0 # learning rate multiplier for the filters 72 | blobs_lr: 0 # learning rate multiplier for the biases 73 | convolution_param { 74 | num_output: 256 75 | pad: 2 76 | kernel_size: 5 77 | group: 2 78 | weight_filler { 79 | type: "gaussian" # initialize the filters from a Gaussian 80 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 81 | } 82 | bias_filler { 83 | type: "constant" 84 | value: 1.0 85 | } 86 | } 87 | } 88 | layers { 89 | name: "relu2" 90 | type: RELU 91 | bottom: "conv2" 92 | top: "conv2" 93 | } 94 | layers { 95 | name: "pool2" 96 | type: POOLING 97 | bottom: "conv2" 98 | top: "pool2" 99 | pooling_param { 100 | pool: MAX 101 | kernel_size: 3 102 | stride: 2 103 | } 104 | } 105 | layers { 106 | name: "norm2" 107 | type: LRN 108 | bottom: "pool2" 109 | top: "norm2" 110 | lrn_param { 111 | local_size: 5 112 | alpha: 0.0001 113 | beta: 0.75 114 | } 115 | } 116 | 117 | layers { 118 | name: "conv3" 119 | type: CONVOLUTION 120 | bottom: "norm2" 121 | top: "conv3" 122 | blobs_lr: 0 # learning rate multiplier for the filters 123 | blobs_lr: 0 # learning rate multiplier for the biases 124 | convolution_param { 125 | num_output: 384 126 | pad: 1 127 | kernel_size: 3 128 | } 129 | } 130 | layers { 131 | name: "relu3" 132 | type: RELU 133 | bottom: "conv3" 134 | top: "conv3" 135 | } 136 | layers { 137 | name: "conv4" 138 | type: CONVOLUTION 139 | bottom: "conv3" 140 | top: "conv4" 141 | blobs_lr: 0 # learning rate multiplier for the filters 142 | blobs_lr: 0 # learning rate multiplier for the biases 143 | convolution_param { 144 | num_output: 384 145 | pad: 1 146 | kernel_size: 3 147 | group: 2 148 | } 149 | } 150 | layers { 151 | name: "relu4" 152 | type: RELU 153 | bottom: "conv4" 154 | top: "conv4" 155 | } 156 | 157 | layers { 158 | name: "conv5" 159 | type: CONVOLUTION 160 | bottom: "conv4" 161 | top: "conv5" 162 | blobs_lr: 0 # learning rate multiplier for the filters 163 | blobs_lr: 0 # learning rate multiplier for the biases 164 | convolution_param { 165 | num_output: 256 166 | pad: 1 167 | kernel_size: 3 168 | group: 2 169 | } 170 | } 171 | layers { 172 | name: "relu5" 173 | type: RELU 174 | bottom: "conv5" 175 | top: "conv5" 176 | } 177 | 178 | layers { 179 | name: "pool5" 180 | type: POOLING 181 | bottom: "conv5" 182 | top: "pool5" 183 | pooling_param { 184 | pool: MAX 185 | kernel_size: 3 186 | stride: 2 187 | } 188 | } 189 | 190 | 191 | 192 | ### FULLY-CONNECTED LAYERS ------------------------------------------ 193 | layers { 194 | name: "fc6" 195 | type: INNER_PRODUCT 196 | bottom: "pool5" 197 | top: "fc6" 198 | inner_product_param { 199 | num_output: 4096 200 | weight_filler { 201 | type: "gaussian" 202 | std: 0.01 203 | } 204 | bias_filler { 205 | type: "constant" 206 | value: 0 207 | } 208 | } 209 | blobs_lr: 1 210 | blobs_lr: 0.1 211 | } 212 | layers { 213 | name: "relu6" 214 | type: RELU 215 | bottom: "fc6" 216 | top: "fc6" 217 | } 218 | layers { 219 | name: "drop6" 220 | type: DROPOUT 221 | bottom: "fc6" 222 | top: "fc6" 223 | dropout_param { 224 | dropout_ratio: 0.5 225 | } 226 | } 227 | layers { 228 | name: "fc7" 229 | type: INNER_PRODUCT 230 | bottom: "fc6" 231 | top: "fc7" 232 | inner_product_param { 233 | num_output: 4096 234 | weight_filler { 235 | type: "gaussian" 236 | std: 0.01 237 | } 238 | bias_filler { 239 | type: "constant" 240 | value: 0 241 | } 242 | } 243 | 244 | blobs_lr: 1 245 | blobs_lr: 0.5 246 | } 247 | layers { 248 | name: "relu7" 249 | type: RELU 250 | bottom: "fc7" 251 | top: "fc7" 252 | } 253 | layers { 254 | name: "drop7" 255 | type: DROPOUT 256 | bottom: "fc7" 257 | top: "fc7" 258 | dropout_param { 259 | dropout_ratio: 0.5 260 | } 261 | } 262 | 263 | layers { 264 | name: "fc_n1" 265 | type: INNER_PRODUCT 266 | bottom: "fc7" 267 | top: "fc_n1" 268 | inner_product_param { 269 | num_output: 128 270 | weight_filler { 271 | type: "gaussian" 272 | std: 0.01 273 | } 274 | bias_filler { 275 | type: "constant" 276 | value: 0 277 | } 278 | } 279 | blobs_lr: 1 280 | blobs_lr: 0.5 281 | } 282 | layers { 283 | name: "relu_n1" 284 | type: RELU 285 | bottom: "fc_n1" 286 | top: "fc_n1" 287 | } 288 | layers { 289 | name: "drop_n1" 290 | type: DROPOUT 291 | bottom: "fc_n1" 292 | top: "fc_n1" 293 | dropout_param { 294 | dropout_ratio: 0.5 295 | } 296 | 297 | } 298 | 299 | layers { 300 | name: "fc_n2" 301 | type: INNER_PRODUCT 302 | bottom: "fc_n1" 303 | top: "fc_n2" 304 | inner_product_param { 305 | num_output: 16 306 | weight_filler { 307 | type: "gaussian" 308 | std: 0.01 309 | } 310 | bias_filler { 311 | type: "constant" 312 | value: 0 313 | } 314 | } 315 | blobs_lr: 1 316 | blobs_lr: 0.5 317 | } 318 | layers { 319 | name: "prob" 320 | type: SOFTMAX 321 | bottom: "fc_n2" 322 | top: "prob" 323 | } 324 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/udr_softmax_dir.prototxt: -------------------------------------------------------------------------------- 1 | name: "Unary depth regressor, softmax version: directory input. Center depth values:" 2 | 3 | layers { 4 | name: "data" 5 | type: IMAGE_DATA 6 | top: "data" 7 | top: "label" 8 | transform_param { 9 | # (Mean file is same for d16 and d128) 10 | mean_file: "train/NYUv2/train_full_167_v3/mean.binaryproto" 11 | } 12 | image_data_param { 13 | new_width: 227 14 | new_height: 227 15 | shuffle: 1 16 | source: "train/NYUv2/train_full_167_v3/index_16_norm_randomized.txt" 17 | batch_size: 128 18 | } 19 | include: { phase: TRAIN } 20 | } 21 | 22 | layers { 23 | name: "data" 24 | type: IMAGE_DATA 25 | top: "data" 26 | top: "label" 27 | transform_param { 28 | mean_file: "train/NYUv2/test_full_167_v3/mean.binaryproto" 29 | } 30 | image_data_param { 31 | new_width: 227 32 | new_height: 227 33 | shuffle: 1 34 | source: "train/NYUv2/test_full_167_v3/index_16_norm_randomized.txt" 35 | batch_size: 128 36 | } 37 | include: { phase: TEST } 38 | } 39 | 40 | 41 | 42 | ### PRE-TRAINED LAYERS ------------------------------------------ 43 | layers { 44 | name: "conv1" 45 | type: CONVOLUTION 46 | bottom: "data" 47 | top: "conv1" 48 | blobs_lr: 0 # learning rate multiplier for the filters 49 | blobs_lr: 0 # learning rate multiplier for the biases 50 | weight_decay: 1 # weight decay multiplier for the filters 51 | weight_decay: 0 # weight decay multiplier for the biases 52 | convolution_param { 53 | num_output: 96 # learn 96 filters 54 | kernel_size: 11 # each filter is 11x11 55 | stride: 4 # step 4 pixels between each filter application 56 | weight_filler { 57 | type: "gaussian" # initialize the filters from a Gaussian 58 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 59 | } 60 | bias_filler { 61 | type: "constant" # initialize the biases to zero (0) 62 | value: 0 63 | } 64 | } 65 | } 66 | 67 | layers { 68 | name: "relu1" 69 | type: RELU 70 | bottom: "conv1" 71 | top: "conv1" 72 | } 73 | layers { 74 | name: "pool1" 75 | type: POOLING 76 | bottom: "conv1" 77 | top: "pool1" 78 | pooling_param { 79 | pool: MAX 80 | kernel_size: 3 81 | stride: 2 82 | } 83 | } 84 | layers { 85 | name: "norm1" 86 | type: LRN 87 | bottom: "pool1" 88 | top: "norm1" 89 | lrn_param { 90 | local_size: 5 91 | alpha: 0.0001 92 | beta: 0.75 93 | } 94 | } 95 | 96 | layers { 97 | name: "conv2" 98 | type: CONVOLUTION 99 | bottom: "norm1" 100 | top: "conv2" 101 | blobs_lr: 0 # learning rate multiplier for the filters 102 | blobs_lr: 0 # learning rate multiplier for the biases 103 | convolution_param { 104 | num_output: 256 105 | pad: 2 106 | kernel_size: 5 107 | group: 2 108 | weight_filler { 109 | type: "gaussian" # initialize the filters from a Gaussian 110 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 111 | } 112 | bias_filler { 113 | type: "constant" 114 | value: 1.0 115 | } 116 | } 117 | } 118 | layers { 119 | name: "relu2" 120 | type: RELU 121 | bottom: "conv2" 122 | top: "conv2" 123 | } 124 | layers { 125 | name: "pool2" 126 | type: POOLING 127 | bottom: "conv2" 128 | top: "pool2" 129 | pooling_param { 130 | pool: MAX 131 | kernel_size: 3 132 | stride: 2 133 | } 134 | } 135 | layers { 136 | name: "norm2" 137 | type: LRN 138 | bottom: "pool2" 139 | top: "norm2" 140 | lrn_param { 141 | local_size: 5 142 | alpha: 0.0001 143 | beta: 0.75 144 | } 145 | } 146 | 147 | layers { 148 | name: "conv3" 149 | type: CONVOLUTION 150 | bottom: "norm2" 151 | top: "conv3" 152 | blobs_lr: 0 # learning rate multiplier for the filters 153 | blobs_lr: 0 # learning rate multiplier for the biases 154 | convolution_param { 155 | num_output: 384 156 | pad: 1 157 | kernel_size: 3 158 | } 159 | } 160 | layers { 161 | name: "relu3" 162 | type: RELU 163 | bottom: "conv3" 164 | top: "conv3" 165 | } 166 | layers { 167 | name: "conv4" 168 | type: CONVOLUTION 169 | bottom: "conv3" 170 | top: "conv4" 171 | blobs_lr: 0 # learning rate multiplier for the filters 172 | blobs_lr: 0 # learning rate multiplier for the biases 173 | convolution_param { 174 | num_output: 384 175 | pad: 1 176 | kernel_size: 3 177 | group: 2 178 | } 179 | } 180 | layers { 181 | name: "relu4" 182 | type: RELU 183 | bottom: "conv4" 184 | top: "conv4" 185 | } 186 | 187 | layers { 188 | name: "conv5" 189 | type: CONVOLUTION 190 | bottom: "conv4" 191 | top: "conv5" 192 | blobs_lr: 0 # learning rate multiplier for the filters 193 | blobs_lr: 0 # learning rate multiplier for the biases 194 | convolution_param { 195 | num_output: 256 196 | pad: 1 197 | kernel_size: 3 198 | group: 2 199 | } 200 | } 201 | layers { 202 | name: "relu5" 203 | type: RELU 204 | bottom: "conv5" 205 | top: "conv5" 206 | } 207 | 208 | layers { 209 | name: "pool5" 210 | type: POOLING 211 | bottom: "conv5" 212 | top: "pool5" 213 | pooling_param { 214 | pool: MAX 215 | kernel_size: 3 216 | stride: 2 217 | } 218 | } 219 | 220 | 221 | 222 | ### FULLY-CONNECTED LAYERS ------------------------------------------ 223 | layers { 224 | name: "fc6" 225 | type: INNER_PRODUCT 226 | bottom: "pool5" 227 | top: "fc6" 228 | inner_product_param { 229 | num_output: 4096 230 | weight_filler { 231 | type: "gaussian" 232 | std: 0.01 233 | } 234 | bias_filler { 235 | type: "constant" 236 | value: 0 237 | } 238 | } 239 | blobs_lr: 0 240 | blobs_lr: 0 241 | } 242 | layers { 243 | name: "relu6" 244 | type: RELU 245 | bottom: "fc6" 246 | top: "fc6" 247 | } 248 | layers { 249 | name: "drop6" 250 | type: DROPOUT 251 | bottom: "fc6" 252 | top: "fc6" 253 | dropout_param { 254 | dropout_ratio: 0.5 255 | } 256 | } 257 | layers { 258 | name: "fc7" 259 | type: INNER_PRODUCT 260 | bottom: "fc6" 261 | top: "fc7" 262 | inner_product_param { 263 | num_output: 4096 264 | weight_filler { 265 | type: "gaussian" 266 | std: 0.01 267 | } 268 | bias_filler { 269 | type: "constant" 270 | value: 0 271 | } 272 | } 273 | 274 | blobs_lr: 1 275 | blobs_lr: 1 276 | } 277 | layers { 278 | name: "relu7" 279 | type: RELU 280 | bottom: "fc7" 281 | top: "fc7" 282 | } 283 | layers { 284 | name: "drop7" 285 | type: DROPOUT 286 | bottom: "fc7" 287 | top: "fc7" 288 | dropout_param { 289 | dropout_ratio: 0.5 290 | } 291 | } 292 | 293 | layers { 294 | name: "fc_n1" 295 | type: INNER_PRODUCT 296 | bottom: "fc7" 297 | top: "fc_n1" 298 | inner_product_param { 299 | num_output: 128 300 | weight_filler { 301 | type: "gaussian" 302 | std: 0.01 303 | } 304 | bias_filler { 305 | type: "constant" 306 | value: 0 307 | } 308 | } 309 | blobs_lr: 1 310 | blobs_lr: 1 311 | } 312 | layers { 313 | name: "relu_n1" 314 | type: RELU 315 | bottom: "fc_n1" 316 | top: "fc_n1" 317 | } 318 | layers { 319 | name: "drop_n1" 320 | type: DROPOUT 321 | bottom: "fc_n1" 322 | top: "fc_n1" 323 | dropout_param { 324 | dropout_ratio: 0.5 325 | } 326 | 327 | } 328 | 329 | layers { 330 | name: "fc_n2" 331 | type: INNER_PRODUCT 332 | bottom: "fc_n1" 333 | top: "fc_n2" 334 | inner_product_param { 335 | num_output: 16 336 | weight_filler { 337 | type: "gaussian" 338 | std: 0.01 339 | } 340 | bias_filler { 341 | type: "constant" 342 | value: 0 343 | } 344 | } 345 | blobs_lr: 1 346 | blobs_lr: 1 347 | } 348 | layers { 349 | name: "prob" 350 | type: SOFTMAX_LOSS 351 | bottom: "fc_n2" 352 | bottom: "label" 353 | top: "prob" 354 | } 355 | layers { 356 | name: "accuracy" 357 | type: ACCURACY 358 | bottom: "fc_n2" 359 | bottom: "label" 360 | top: "accuracy" 361 | include: { phase: TEST } 362 | } 363 | 364 | -------------------------------------------------------------------------------- /models/unary_depth_regressor/udr_softmax_lmdb.prototxt: -------------------------------------------------------------------------------- 1 | name: "Unary depth regressor" 2 | 3 | # use this style for running mode 4 | #input: "data" 5 | #input_dim: 16 6 | #input_dim: 3 7 | #input_dim: 227 8 | #input_dim: 227 9 | 10 | layers { 11 | name: "data" 12 | type: DATA 13 | top: "data" 14 | top: "label" 15 | transform_param { 16 | #mirror: true 17 | #crop_size: 227 18 | mean_file: "train/NYUv2/NYUv2_train_mean_full_167_resize_d16.binaryproto" 19 | } 20 | data_param { 21 | source: "train/NYUv2/NYUv2_train_full_167_resize_d16_lmdb" 22 | backend: LMDB 23 | batch_size: 256 24 | } 25 | include: { phase: TRAIN } 26 | } 27 | 28 | layers { 29 | name: "data" 30 | type: DATA 31 | top: "data" 32 | top: "label" 33 | transform_param { 34 | #mirror: true 35 | #crop_size: 227 36 | mean_file: "train/NYUv2/NYUv2_test_mean_full_167_resize_d16.binaryproto" 37 | } 38 | data_param { 39 | source: "train/NYUv2/NYUv2_test_full_167_resize_d16_lmdb" 40 | batch_size: 256 41 | backend: LMDB 42 | } 43 | include: { phase: TEST } 44 | } 45 | 46 | layers { 47 | name: "conv1" 48 | type: CONVOLUTION 49 | bottom: "data" 50 | top: "conv1" 51 | blobs_lr: 0 # learning rate multiplier for the filters 52 | blobs_lr: 0 # learning rate multiplier for the biases 53 | weight_decay: 1 # weight decay multiplier for the filters 54 | weight_decay: 0 # weight decay multiplier for the biases 55 | convolution_param { 56 | num_output: 96 # learn 96 filters 57 | kernel_size: 11 # each filter is 11x11 58 | stride: 4 # step 4 pixels between each filter application 59 | weight_filler { 60 | type: "gaussian" # initialize the filters from a Gaussian 61 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 62 | } 63 | bias_filler { 64 | type: "constant" # initialize the biases to zero (0) 65 | value: 0 66 | } 67 | } 68 | } 69 | 70 | layers { 71 | name: "relu1" 72 | type: RELU 73 | bottom: "conv1" 74 | top: "conv1" 75 | } 76 | layers { 77 | name: "pool1" 78 | type: POOLING 79 | bottom: "conv1" 80 | top: "pool1" 81 | pooling_param { 82 | pool: MAX 83 | kernel_size: 3 84 | stride: 2 85 | } 86 | } 87 | layers { 88 | name: "norm1" 89 | type: LRN 90 | bottom: "pool1" 91 | top: "norm1" 92 | lrn_param { 93 | local_size: 5 94 | alpha: 0.0001 95 | beta: 0.75 96 | } 97 | } 98 | 99 | layers { 100 | name: "conv2" 101 | type: CONVOLUTION 102 | bottom: "norm1" 103 | top: "conv2" 104 | blobs_lr: 0 # learning rate multiplier for the filters 105 | blobs_lr: 0 # learning rate multiplier for the biases 106 | convolution_param { 107 | num_output: 256 108 | pad: 2 109 | kernel_size: 5 110 | group: 2 111 | weight_filler { 112 | type: "gaussian" # initialize the filters from a Gaussian 113 | std: 0.01 # distribution with stdev 0.01 (default mean: 0) 114 | } 115 | bias_filler { 116 | type: "constant" 117 | value: 1.0 118 | } 119 | } 120 | } 121 | layers { 122 | name: "relu2" 123 | type: RELU 124 | bottom: "conv2" 125 | top: "conv2" 126 | } 127 | layers { 128 | name: "pool2" 129 | type: POOLING 130 | bottom: "conv2" 131 | top: "pool2" 132 | pooling_param { 133 | pool: MAX 134 | kernel_size: 3 135 | stride: 2 136 | } 137 | } 138 | layers { 139 | name: "norm2" 140 | type: LRN 141 | bottom: "pool2" 142 | top: "norm2" 143 | lrn_param { 144 | local_size: 5 145 | alpha: 0.0001 146 | beta: 0.75 147 | } 148 | } 149 | 150 | layers { 151 | name: "conv3" 152 | type: CONVOLUTION 153 | bottom: "norm2" 154 | top: "conv3" 155 | blobs_lr: 0 # learning rate multiplier for the filters 156 | blobs_lr: 0 # learning rate multiplier for the biases 157 | convolution_param { 158 | num_output: 384 159 | pad: 1 160 | kernel_size: 3 161 | } 162 | } 163 | layers { 164 | name: "relu3" 165 | type: RELU 166 | bottom: "conv3" 167 | top: "conv3" 168 | } 169 | layers { 170 | name: "conv4" 171 | type: CONVOLUTION 172 | bottom: "conv3" 173 | top: "conv4" 174 | blobs_lr: 0 # learning rate multiplier for the filters 175 | blobs_lr: 0 # learning rate multiplier for the biases 176 | convolution_param { 177 | num_output: 384 178 | pad: 1 179 | kernel_size: 3 180 | group: 2 181 | } 182 | } 183 | layers { 184 | name: "relu4" 185 | type: RELU 186 | bottom: "conv4" 187 | top: "conv4" 188 | } 189 | 190 | layers { 191 | name: "conv5" 192 | type: CONVOLUTION 193 | bottom: "conv4" 194 | top: "conv5" 195 | blobs_lr: 0 # learning rate multiplier for the filters 196 | blobs_lr: 0 # learning rate multiplier for the biases 197 | convolution_param { 198 | num_output: 256 199 | pad: 1 200 | kernel_size: 3 201 | group: 2 202 | } 203 | } 204 | layers { 205 | name: "relu5" 206 | type: RELU 207 | bottom: "conv5" 208 | top: "conv5" 209 | } 210 | 211 | layers { 212 | name: "pool5" 213 | type: POOLING 214 | bottom: "conv5" 215 | top: "pool5" 216 | pooling_param { 217 | pool: MAX 218 | kernel_size: 3 219 | stride: 2 220 | } 221 | } 222 | 223 | layers { 224 | name: "fc6" 225 | type: INNER_PRODUCT 226 | bottom: "pool5" 227 | top: "fc6" 228 | inner_product_param { 229 | num_output: 4096 230 | } 231 | } 232 | layers { 233 | name: "relu6" 234 | type: RELU 235 | bottom: "fc6" 236 | top: "fc6" 237 | } 238 | layers { 239 | name: "drop6" 240 | type: DROPOUT 241 | bottom: "fc6" 242 | top: "fc6" 243 | dropout_param { 244 | dropout_ratio: 0.5 245 | } 246 | } 247 | layers { 248 | name: "fc7" 249 | type: INNER_PRODUCT 250 | bottom: "fc6" 251 | top: "fc7" 252 | inner_product_param { 253 | num_output: 4096 254 | weight_filler { 255 | type: "gaussian" 256 | std: 0.01 257 | } 258 | bias_filler { 259 | type: "constant" 260 | value: 0 261 | } 262 | } 263 | 264 | blobs_lr: 1 265 | blobs_lr: 1 266 | } 267 | layers { 268 | name: "relu7" 269 | type: RELU 270 | bottom: "fc7" 271 | top: "fc7" 272 | } 273 | layers { 274 | name: "drop7" 275 | type: DROPOUT 276 | bottom: "fc7" 277 | top: "fc7" 278 | dropout_param { 279 | dropout_ratio: 0.5 280 | } 281 | } 282 | 283 | layers { 284 | name: "fc_n1" 285 | type: INNER_PRODUCT 286 | bottom: "fc7" 287 | top: "fc_n1" 288 | inner_product_param { 289 | num_output: 128 290 | weight_filler { 291 | type: "gaussian" 292 | std: 0.01 293 | } 294 | bias_filler { 295 | type: "constant" 296 | value: 0 297 | } 298 | } 299 | blobs_lr: 1 300 | blobs_lr: 1 301 | } 302 | layers { 303 | name: "relu_n1" 304 | type: RELU 305 | bottom: "fc_n1" 306 | top: "fc_n1" 307 | } 308 | layers { 309 | name: "drop_n1" 310 | type: DROPOUT 311 | bottom: "fc_n1" 312 | top: "fc_n1" 313 | dropout_param { 314 | dropout_ratio: 0.5 315 | } 316 | 317 | } 318 | 319 | layers { 320 | name: "fc_n2" 321 | type: INNER_PRODUCT 322 | bottom: "fc_n1" 323 | top: "fc_n2" 324 | inner_product_param { 325 | num_output: 16 326 | weight_filler { 327 | type: "gaussian" 328 | std: 0.01 329 | } 330 | bias_filler { 331 | type: "constant" 332 | value: 0 333 | } 334 | } 335 | blobs_lr: 1 336 | blobs_lr: 1 337 | } 338 | layers { 339 | name: "prob" 340 | type: SOFTMAX_LOSS 341 | bottom: "fc_n2" 342 | bottom: "label" 343 | top: "prob" 344 | } 345 | 346 | layers { 347 | name: "accuracy" 348 | type: ACCURACY 349 | bottom: "fc_n2" 350 | bottom: "label" 351 | top: "accuracy" 352 | include: { phase: TEST } 353 | } 354 | 355 | 356 | ## EUCLIDEAN LOSS LAYER / FOR REGRESSION 357 | #layers { 358 | # name: "prob" 359 | # type: SOFTMAX 360 | # bottom: "fc_n2" 361 | # top: "fc_n3" 362 | #} 363 | # 364 | # 365 | #layers { 366 | # name: "output_neuron" 367 | # type: INNER_PRODUCT 368 | # bottom: "fc_n3" 369 | # top: "output_neuron" 370 | # inner_product_param { 371 | # num_output: 1 372 | # } 373 | #} 374 | #layers { 375 | # name: "loss" 376 | # type: EUCLIDEAN_LOSS 377 | # bottom: "output_neuron" 378 | # bottom: "label" 379 | #} 380 | 381 | 382 | -------------------------------------------------------------------------------- /parse_log.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Usage parse_log.sh caffe.log 3 | # It creates the following two text files, each containing a table: 4 | # caffe.log.test (columns: '#Iters Seconds TestAccuracy TestLoss') 5 | # caffe.log.train (columns: '#Iters Seconds TrainingLoss LearningRate') 6 | 7 | 8 | # get the dirname of the script 9 | DIR="$( cd "$(dirname "$0")" ; pwd -P )" 10 | 11 | if [ "$#" -lt 1 ] 12 | then 13 | echo "Usage parse_log.sh /path/to/your.log" 14 | exit 15 | fi 16 | LOG=`basename $1` 17 | grep -B 1 'Test ' $1 > aux.txt 18 | grep 'Iteration ' aux.txt | sed 's/.*Iteration \([[:digit:]]*\).*/\1/g' > aux0.txt 19 | grep 'Test net output #0' aux.txt | awk '{print $11}' > aux1.txt 20 | grep 'Test net output #1' aux.txt | awk '{print $11}' > aux2.txt 21 | 22 | # Extracting elapsed seconds 23 | # For extraction of time since this line contains the start time 24 | grep '] Solving ' $1 > aux3.txt 25 | grep 'Testing net' $1 >> aux3.txt 26 | $DIR/extract_seconds.py aux3.txt aux4.txt 27 | 28 | # Generating 29 | echo '#Iters Seconds TestAccuracy TestLoss'> $LOG.test 30 | paste aux0.txt aux4.txt aux1.txt aux2.txt | column -t >> $LOG.test 31 | rm aux.txt aux0.txt aux1.txt aux2.txt aux3.txt aux4.txt 32 | 33 | # For extraction of time since this line contains the start time 34 | grep '] Solving ' $1 > aux.txt 35 | grep ', loss = ' $1 >> aux.txt 36 | grep 'Iteration ' aux.txt | sed 's/.*Iteration \([[:digit:]]*\).*/\1/g' > aux0.txt 37 | grep ', loss = ' $1 | awk '{print $9}' > aux1.txt 38 | grep ', lr = ' $1 | awk '{print $9}' > aux2.txt 39 | 40 | # Extracting elapsed seconds 41 | $DIR/extract_seconds.py aux.txt aux3.txt 42 | 43 | # Generating 44 | echo '#Iters Seconds TrainingLoss LearningRate'> $LOG.train 45 | paste aux0.txt aux3.txt aux1.txt aux2.txt | column -t >> $LOG.train 46 | rm aux.txt aux0.txt aux1.txt aux2.txt aux3.txt 47 | -------------------------------------------------------------------------------- /plot_training_info.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "", 4 | "signature": "sha256:dc0a640d10d7279f617a68c56a6f2180cbfd162bad9e134c7a3ee3965ec2dfe6" 5 | }, 6 | "nbformat": 3, 7 | "nbformat_minor": 0, 8 | "worksheets": [ 9 | { 10 | "cells": [ 11 | { 12 | "cell_type": "code", 13 | "collapsed": false, 14 | "input": [ 15 | "# Plot training info\n", 16 | "# Hella Importnt\n", 17 | "import numpy as np\n", 18 | "import scipy as sp\n", 19 | "import csv\n", 20 | "import matplotlib.pyplot as plt\n", 21 | "import sys\n", 22 | "import google\n", 23 | "from IPython.display import display, Image \n", 24 | "%matplotlib inline\n", 25 | "%load_ext autoreload\n", 26 | "%autoreload 1\n", 27 | "\n", 28 | "# Generate loss plots\n", 29 | "# --------------- Latex Plot Beautification --------------------------\n", 30 | "fig_width_pt = 246.0 # Get this from LaTeX using \\showthe\\columnwidth\n", 31 | "inches_per_pt = 1.0/72.27 # Convert pt to inch\n", 32 | "golden_mean = (np.sqrt(5)-1.0)/2.0 # Aesthetic ratio\n", 33 | "fig_width = fig_width_pt*inches_per_pt # width in inches\n", 34 | "fig_height = fig_width*golden_mean # height in inches\n", 35 | "fig_size = [fig_width+1,fig_height+1]\n", 36 | "params = {'backend': 'ps',\n", 37 | " 'axes.labelsize': 14,\n", 38 | " 'text.fontsize': 14,\n", 39 | " 'legend.fontsize': 10,\n", 40 | " 'xtick.labelsize': 10,\n", 41 | " 'ytick.labelsize': 10,\n", 42 | " 'text.usetex': False,\n", 43 | " 'figure.figsize': fig_size}\n", 44 | "plt.rcParams.update(params)\n", 45 | "# --------------- Latex Plot Beautification --------------------------\n", 46 | "\n" 47 | ], 48 | "language": "python", 49 | "metadata": {}, 50 | "outputs": [ 51 | { 52 | "output_type": "stream", 53 | "stream": "stdout", 54 | "text": [ 55 | "The autoreload extension is already loaded. To reload it, use:\n", 56 | " %reload_ext autoreload\n" 57 | ] 58 | } 59 | ], 60 | "prompt_number": 18 61 | }, 62 | { 63 | "cell_type": "code", 64 | "collapsed": false, 65 | "input": [ 66 | "# Before using:\n", 67 | "# -bash $CAFFE_HOME/tools/extra/parse_log.sh /tmp/caffe.INFO\n", 68 | "# (creates two tables, caffe.INFO.test, caffe.INFO.train)\n", 69 | "\n", 70 | "train = {}\n", 71 | "tmp = np.loadtxt('caffe.INFO.softmax_centerdepth.train')\n", 72 | "train['iters'], train['seconds'], train['loss'], train['learn_rate'] = tmp[:,0], tmp[:,1], tmp[:,2], tmp[:,3]\n", 73 | "# Iters Seconds TrainingLoss LearningRate\n", 74 | "\n", 75 | "plt.subplot(211)\n", 76 | "plt.semilogy(train['iters'],train['loss'],'b',lw=2)\n", 77 | "plt.ylabel('loss')\n", 78 | "plt.title('Train Set')\n", 79 | "#plt.ylim(0,30)\n", 80 | "#plt.xlim(0,2000)\n", 81 | "\n", 82 | "# plt.subplot(212)\n", 83 | "# plt.plot(train['iters'],train['learn_rate'],'b')\n", 84 | "# plt.xlabel('iters')\n", 85 | "# plt.ylabel('learn rate')\n", 86 | "# plt.show()\n", 87 | "\n", 88 | "test = {}\n", 89 | "tmp = np.loadtxt('caffe.INFO.softmax_centerdepth.test')\n", 90 | "test['iters'], test['seconds'], test['accuracy'], test['loss'] = tmp[:,0], tmp[:,1], tmp[:,2], tmp[:,3]\n", 91 | "# Iters Seconds TrainingLoss LearningRate\n", 92 | "plt.subplot(212)\n", 93 | "plt.plot(test['iters'],100*test['accuracy'],'bo-', lw=2)\n", 94 | "#plt.title('Validation Accuracy')\n", 95 | "plt.xlabel('iterations')\n", 96 | "plt.ylabel('Val. Accuracy')\n", 97 | "#plt.show()\n", 98 | "plt.savefig('Softmax_train.pdf')" 99 | ], 100 | "language": "python", 101 | "metadata": {}, 102 | "outputs": [ 103 | { 104 | "metadata": {}, 105 | "output_type": "display_data", 106 | "png": "iVBORw0KGgoAAAANSUhEUgAAATkAAADrCAYAAAASYOFhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 107 | "text": [ 108 | "" 109 | ] 110 | } 111 | ], 112 | "prompt_number": 21 113 | }, 114 | { 115 | "cell_type": "code", 116 | "collapsed": false, 117 | "input": [ 118 | "# Plot histograms of depths in a dataset:\n", 119 | "\n", 120 | "in_file = 'train/NYUv2/train_full_167_v2/index_16_norm.txt'\n", 121 | "\n", 122 | "\n", 123 | "import csv\n", 124 | "\n", 125 | "f = open(in_file,'r')\n", 126 | "depths = []\n", 127 | "csvf = csv.reader(f)\n", 128 | "\n", 129 | "for row in csvf:\n", 130 | " tmp = row[0].split(' ',1)\n", 131 | " depths.append(tmp[1])\n", 132 | "print np.unique(depths)\n", 133 | "plt.plot(np.bincount(depths)/(0.01*len(depths)))\n", 134 | "plt.ylabel('Occurance Percent')\n", 135 | "plt.xlabel('Bin Number')\n", 136 | "plt.xlim([1,len(np.unique(depths))])" 137 | ], 138 | "language": "python", 139 | "metadata": {}, 140 | "outputs": [ 141 | { 142 | "output_type": "stream", 143 | "stream": "stdout", 144 | "text": [ 145 | "['1' '10' '11' '12' '13' '14' '15' '16' '2' '3' '4' '5' '6' '7' '8' '9']\n" 146 | ] 147 | }, 148 | { 149 | "metadata": {}, 150 | "output_type": "pyout", 151 | "prompt_number": 4, 152 | "text": [ 153 | "(1, 16)" 154 | ] 155 | }, 156 | { 157 | "metadata": {}, 158 | "output_type": "display_data", 159 | "png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEPCAYAAABLIROyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3XeYVOXZx/HvSseGSFNQQEApEkARe1yVZmLEFn0TRYWo\nSVBANEYpKpZo0CRqTIyoiCiiaDQKKtIHVCxIlyLNgIgChiIYysLO+8c9kx2WLWdm58xzzszvc11z\nMTPMnHNfsHvu87T7ARERERERERERERERERERERERERERkf08B2wAFpXwd7cBhUDtjEYkIiL/c5CP\nxx4JdC/h/WOALsAaH88tIiKONeHAFsBrwI+AL1ELQETEGT9bACXpAawDFmb4vCIiUkzlDJ6rJjAI\n6/6Jy8vg+UVEJEEmE0AzrEtoQex1I2AO0AnYmPjBdu3aRRcsWICIiCRlFdDc64cz2QW0CKgPNI09\n1gEnUeziD7BgwQKi0agvj3vuuce3YyvecMYctngVs+It7YHdaHvmZwJ4GZgFHA98BfQq9vdRH88t\nIiLl8LML6Bfl/P1xPp5bRETKkelZQM7l5+e7DiEpYYsX0hdzNApffAGPPw4XXAD335+Wwx4gl/+N\nMylsMYct3lQEdRZONNafJTlm+3aYPh3ee88ee/ZA9+5w6qkwcCB8/TVUq+Y6SpFgysvLgySu65mc\nBSRygGgUPv8cJkywC/7s2Xax794dxo2DNm0gL/bj/NJL8O67cMklbmMWyRZqAUjGbdkCU6YU3eVX\nq2ZdPN27w7nnwiGHlPy9ESPg7bfhX//KbLwiYZFsC0AJQHxXWAhz59rFfsIEWLQIzj7bLvjdu0Pz\n5kV3+WXZtg2OPRZWr4Yjj/Q/bpGwUQKQQNi0CSZOtIv+pElQp07RBf/ss6FGjdSO+4tf2Pf79Elv\nvCLZQAlAnHr2WRg+HFasgPPOswt+t27QuHF6jj9hAtx7L3z8cXqOJ5JNlADEmddfh1tvhVGj4Iwz\noGrV9J9j715o1AhmzoTjj0//8UXCTAlAnPj8cxvAfe89OPlkf891661w8MH+rQsQCatkE0DOLQST\n9Nu8GS6+GB591P+LP8A118CLL9rgsoikTglAKmTfPhuY7dEDrr46M+ds1w4OPRQ++CAz5xPJVkoA\nUiGDBlkSGDYsc+fMy7NWwAsvZO6cItlIYwCSspdfhsGDbfVupuflr18PJ55opSFSnVIqkm00BiAZ\nMW8e9Otnq3JdLMo6+mjo2BHeeivz5xbJFkoAkrRNm6wez9//bv3xrsQHg0UkNeoCkqQUFNjCrlNP\nhYcechvLDz9Aw4awbBk0aOA2FpEgUBeQ+Or226142wMPuI7E1gL06GFjESKSPCUA8WzUKHjnHRgz\nBipVch2NUTeQSOrUBSSezJ4NP/kJRCJWoz8o9u2DJk1sn4C2bV1HI+KWuoAk7TZsgMsug6efDtbF\nH6wlctVVagWIpEIJQMq0Zw9cfjn06hXcnbh69rTdwvbtcx1JZowYYWMxIhWlLiApU58+sG4dvPkm\nHBTg24WOHW1WUpcuriPxX4cONvNp6VLr/hKJUxeQpM0zz9gG7aNHB/viD9YKyIXSEEuW2DqMW2+F\nP/zBdTQSdn63AJ4DfgpsBOJDdI8AFwJ7gFVAL2Bbse+pBeDYrFlW4fP99+GEE1xHU76NG21/gHXr\nSt9TOBsMHmzdcgMHQosW8Nln0LSp66gkKILWAhgJdC/23iSgDdAOWA4M9DkGSdL69fDzn8PIkeG4\n+APUq2dbRb7xhutI/BON2hTcq66C2rWte+7BB11HJWHmdwJ4H9hS7L3JQLyS+ydAI59jkCTs3g2X\nXmoXl5/+1HU0ycn2bqBZs6BmzaLyGwMGWML78ku3cUl4ue7Z7Q286zgGiYlG7cLfqJGVeQ6bn/0M\n5s61bqBs9NJLdvefF2vgx1sBGguQVFV2eO7B2DjAmJL+cujQof97np+fT35+fkaCymX/+Ad8+il8\n9FHRRSZMatSwKasvvQR33OE6mvQqKIDXXrMFeYkGDLCxj0GD4Ljj3MQm7kQiESKRSMrfz8SveRNg\nPEWDwADXATcA5wO7SviOBoEzbOZM6/efNQuaNXMdTerefx9+8xvboziMSaw0b78Nf/xjybug3X23\njds8+2zm45JgCdogcEm6A7cDPSj54i8Z9tVXcOWV1n8e5os/wJlnws6d1hWUTeLdPyW55RZbp7F6\ndWZjkvDz+x7pZeAcoA6wAbgHm/VTFdgc+8xHQJ9i31MLIEN27rTZM1demT2rS++5B7Ztg8cecx1J\nemzfDsccAytXQp06JX/m7rttd7QRIzIbmwRLsi2AoDaSlQAyIBq1app799r0wmzpMlmxAs46ywaD\nq1RxHU3FvfgivPoqjB9f+me2bLF1AZ9+qrGAXBaGLiAJiMcft77yESOy5+IPdiFs1gwmTnQdSXqU\n1f0Td8QRcNNNmhEkyQnqr71aAD6bOtUuKh9/nJ31ZJ56yspYjB3rOpKK2bABWra07p2aNcv+rFoB\noi4gKdeuXXbRHzMGzjvPdTT+2LzZSiSsWQO1armOJnV//auVe/C6wO2ee6zrS2MBuUldQFKu+fNt\nL91svfiDLZLq3NnmzoeZl+6fRAMGwFtvwapV/sUk2UMJIAfNnm3lk7Nd2LeLXLHCWjDnn+/9O7Vq\nwc03ayxAvFECyEGzZ8Mpp7iOwn8XXGA188M6P37MGJueWznJ9fq33ALjxqkVIOVTAshBuZIAqla1\nC+jo0a4jSV40mnz3T5xaAeKVBoFzzPffw9FHw9atyd9ZhtGnn9pFdPnycE11nT0bfvnL1OPeuhWa\nN7dZXs2bpz8+CSYNAkuZ5syxcsK5cPEHa+lUqmQXwjApXvkzWbVqQd++agVI2ZQAckyudP/E5eWF\nb5+AvXtt/UIq3T+J+ve31cMrV6YnLsk+SgA5JtcSAMDVV9t00N27XUfizbRpVvunRYuKHUetACmP\nEkCOycUE0LgxtG0L77zjOhJvUh38LUn//lZKWq0AKYkSQA7ZtKlocDDXhKUb6L//tSmcV16ZnuPF\nWwEPPJCe40l2UQLIIfEFYAfl4P/65ZdbbaDvvnMdSdnGj4dOnaBBg/Qds18/a/2oFSDF5eClIHfl\nYvdP3GGH2Sb3QS8Ol87unzi1AqQ0SgA5JJcTAAS/G+g//7GtOS+5JP3H7t/fWgErVqT/2BJeSgA5\nIhpVAujSBdauhS++cB1JyV57Dbp3h0MPTf+xDz/cuoLUCpBESgA54quvbE58o0auI3GncmVbXRvU\nAnF+dP8k6tcP3n1XrQApogSQI+J3/2Eqh+CHnj0tARQWuo5kf2vWwLJl0K2bf+dQK0CKUwLIEbne\n/RPXrp1dCGfOdB3J/saMsZlKVav6ex61AiSREkCOUAIweXnB2yegIpU/kxVvBdx/v//nkuALaoeA\nqoGmUWGh7ZC1ciXUqeM6GvfWr4c2bbzts5sJCxZAjx62b0Em1mhs22aLAT/8EI4/3v/zSeaoGqgc\nYMUKOOIIXfzjjj7aFlu99ZbrSMxLL9ngdKYW6B1+uE0L1ViA+Pkj9xywAViU8F5tYDKwHJgEhHi7\n7vBQ98+BgtINVFgIL7+cme6fRH37woQJtt+A5C4/E8BIoHux9+7EEsDxwNTYa/GZEsCBLr4YZs2C\nb791G8fMmXDkkdYllUnxVoDGAnKbnwngfWBLsfcuAkbFno8CLvbx/BKjBHCggw+2JDBmjNs4MjX4\nW5J+/eC994K7ME78l+kxgPpYtxCxP+tn+Pw5p6AAFi6Ek092HUnwuO4G2r0b3ngDfvELN+c/7DDb\nQF5jAbnL5caA0dijREOHDv3f8/z8fPLz8/2PKAstXgzHHutPeYGwy8+36qALF8KPfpT587/7rp3X\n5ersvn2hWTNrBZxwgrs4JDWRSIRIJJLy9/2eBtoEGA+0jb1eBuQD3wJHAdOBliV8T9NA0+SZZ+CD\nD2DUqPI/m4sGDrQtGB95JPPnvvxyq/1z/fWZP3eiP/wBli6F0aPdxiEVF/RpoOOAa2PPrwXezPD5\nc476/8t2zTWWHFevzux5t22DyZMtCbjWty9MmmSlKCS3eEkAJfWSeuk5fRmYBZwAfAX0Av4IdMGm\ngZ4Xey0+UgIoW6tWcN991h2UySmRr78O559vtfpd01hA7vLSVJgHdEh4XRlYCLT2JSKjLqA02LnT\nphhu3gzVq7uOJtieew7uusvuylv7+ZMdc/750KcPXHaZ/+fy4vvvbXXwzJnQsqROWQmFdHYBDQK2\nY/332xMeG7GuHAm4+fPtDlcX//L17g3DhtmFeeFCf8/19dcwb57tUBYU8VaA1gXklrISwIPAocCf\nYn/GH7XRAq5QUPdPcq6+Gh5/HLp2hblz/TvPK6/Yrl9BS8x9+1oLSOsCcoeXMYA7gYbAGcCPEx4S\ncEoAybviCnjqKbjgAvjkE3/O4XLxV1kOPdQWhz34oOtIJFO89BUNA64ElgD7Et7/mS8RGY0BpEHL\nlvDqq27muIfdO+9Ar162UOuss9J33KVLoXNn25qyUqX0HTddtm2zdQEff2xjAhIuyY4BePngcmwc\nYHeKMaVCCaCCtm2Dhg1h61bbClGSN2mS3am/+iqce256jjlkCOzaBX/6U3qO54ehQ20L0REjXEci\nyfJjHcAqwOd9iiTd5syB9u118a+Irl1to/YrroCJEyt+vGjUag8FsfsnUf/+8Oab8OWXriMRv3lJ\nADuB+cDTwBOxx1/9DEoqTv3/6ZGfbxfDnj3h7bcrdqyPPrKB3/bt0xKab444An77W3joIdeRiN+8\nJIBxwP3Ah8BnwJzYQwJMCSB9zjwTxo+HX/0K/vWv1I8TH/zNC+o+fAkGDLDFamvWuI5E/OT1R7Em\ncCxWyycTNAZQQY0bw5Qp0KKF60iyx9y58JOf2FTRK69M7rsFBTYm88kn0LSpP/Gl28CBNpb05JOu\nIxGv/BgDuAhbDfxe7HUHtBAs0DZuLFrZKelz0kk2T37AAHjhheS+O2mSJeOwXPwBbr3V1iysW+c6\nEvGLlwQwFDiVos1d5gHH+RWQVNzs2dCxYzi6GsKmbVtrWQ0cmNwsmaDO/S9L3brW7fXww64jEb94\nSQAFwNZi7xX6EIukyWefqf/fT61bQyQC997rrXtkxw6r/X/FFb6Hlna/+52Vif7mG9eRiB+8JIDF\nwFVYEbgW2CygWX4GJRWjAWD/tWgBM2bYPgKPPlr2Z9980xaT1amTmdjSqX59uPZaN/sliP+8dBIc\nDAwGusZeT8RmBe3yKyg0CJyyaBQaNLB1AC53msoVa9fCeefZpi53llIh64ILbN8BV1s/VtT69XDi\nibaKub42cQ00P1YCu6AEkKK1a+HUU+2XVmMAmfH111ZF9Je/tJLSif/uGzfaVovr1tlG9GHVty/U\nqKHxgKDzYxbQFCBx24raWCtAAije/aOLf+Y0bGhjAq++aqUeEu9dxo6FCy8M98Uf4I474NlnYdMm\n15FIOnlJAHXYfxB4M6CGYECp/9+NBg1g+nQrIve73xUlgTDO/ilJo0a29qG88Q4JFy8JYB/QOOF1\nEzQLKLCUANypWxemTbNdtfr1gxUrrJ5O586uI0uPO++E4cNthznJDl46CrpjdYBmxD7/Y+BGihaG\n+UFjACkoLITatWHlynDOOMkW27ZB9+42dfKii+CvWVQ564Yb4KijbB9lCZ50DwIfBPwcmAacBkSB\nTwC/ewKVAFLwxRd24VEVR/e2b7eL5eDBtngsW6xeDZ062U1GEDa0l/35MQtoDnByqgGlSAkgBaNH\nw7hxNhgp4pdevaykxd13u45EivNjFtBk4HfAMdgMoPhDAkb9/5IJgwbBE09YvSkJNy8J4P+Am4CZ\nFJWCVjnoAFICkExo0cK6Gp94wnUkUlGuZosPBK7GZhMtAnqx/5aT6gJKUkGBbeTxzTe2ubeIn5Yt\ngx//GFat0s9bkPjRBXQwcBfwTOx1C+DCpCMr0gS4ATgJ22u4EtbKkApYvBiOPVa/jJIZLVva6mft\nFRBuXhLASGAPcEbs9XrgDxU45/dYhdGaWIG5msDXFTieoO4fybwhQ+Avf4EffnAdiaTKSwJoBgzD\nkgBARf+7NwN/BtZiyWQrVm5CKkAJQDKtTRs45xx46inXkUiqKnv4zG6gRsLrZuzfX5+sZsAtWFfQ\nNuA1rNz0S4kfGjp06P+e5+fnk5+fX4FTZr/Zs23zDpFMGjIEunWzTeRr1nQdTe6JRCJEIpGUv+9l\nsKArVg66NTYl9EzgOmB6iue8EugCXB973RNbZHZTwmc0CJyEnTvhyCNtiX716q6jkVxz6aXWEujf\n33Uk4scg8FzgMmymzhhsUViqF3+wjeVPw1oVeUBnYEkFjpfz5s+HVq108Rc37rrLykTv8nOHEPFF\nWQngZ1jJh0XAfGxP4LeB7yp4zgXAC8BnwMLYe09X8Jg5Tf3/4lKHDnDyycntkSzBUFZTYRFWB2gZ\ntin8w8A5mQgKdQElpWdPyM/XGIC4M3u2dQWtXAnVqrmOJnelswtoL3bxBysAd1jqYYmf1AIQ1045\nxYrePf+860gkGWVlinXAXxI+MyDhdTT23C9qAXi0bZvtSLV1K1T2MqdLxCcffWT7Hi9fDlWruo4m\nN6WzBfAscChwSOyR+FrrTQNizhxo314Xf3Hv9NPh+OPhxRddRyJeBXXnWLUAPBo2DL79Vlv1STB8\n8AFcc43tTVGliutoco8f00AlwNT/L0Fy1lnQpAmMGeM6EvFCLYCQa9wYpkyxEr0iQRCJwI03wpIl\n6prMNLUAcsjGjbYpR/PmriMRKXLOOdCgAYwd6zoSKY+XBNAAGEHRJvCtAc04D4DZs6FjR8gLajtO\nclJenm0Xef/9sG+f62ikLF4SwPPAJODo2OsV2JRQcUz9/xJU558PtWvDa6+5jkTK4iUB1AHGAvFc\nXoAtEhPHlAAkqBJbAYWFrqOR0nhJADuAIxNen4aVcRaHolElAAm2bt3g4IPhjTdcRyKl8ZIAbgPG\nA8cBs4AXgX5+BiXlW7sWKlWyVcAiQaRWQPB5SQBzsCJwZwK/xgaBF/gZlJQvfvevAWAJsp/+1KaC\njhvnOhIpiZcEcDNW/uFzrELoIUAfP4OS8qn7R8Ig3gq47z7rtpRg8ZIAbsD2AojbAtzoTzjilRKA\nhMVFF8Hu3VYmQoLFSwI4qNjnKgGq8uFQYaEVgevY0XUkIuXLy4MePWDiRNeRSHFeEsBE4BXgfGz7\nxlcoWhQmDixfbnsA16njOhIRb7p2hUmTXEchxXmp1HEH1uXz29jryVhpaHFE3T8SNqefDsuWwebN\ntkBMgsFLC2Af8A/g8thjOEWLwsQBJQAJm2rV4OyzYepU15FIIi8J4Czsrn8F8GXssdrPoKRsSgAS\nRuoGCh4vs8i/AG4B5rL/nf93vkRkVA66FAUFUKuWbQJzqPZlkxBZuhS6d4d//1vrV/ySbDloL2MA\nW4EJqQYk6bV4sW24oYu/hE3LljaDbcUK2zpS3PPSBTQdeAQ4HTgp4SEOqPtHwiovD7p0UTdQkHhp\nAZwGRIHis87PrcB5a2EzidrEjt0b+LgCx8sZSgASZl272naRN9/sOhIBd1tCjgJmAM9hSehg9q8w\nqjGAUnToAMOHQ6dOriMRSd5330GzZvanNo1Pv2THALx+8EKsCFz1hPfu8x7Wfg4H5mHVRUujBFCC\nnTtt8dfmzTatTiSMOnaERx+1aaGSXn7sCTwcuAIrAZ0Xe944leBimgKbgJHYzKJngJoVOF7OmD8f\nWrXSxV/CTeMAweFlDOAMoC2wELgX+DMVKwVRGRtEvhmYDTwG3AncnfihoUOH/u95fn4++fn5FThl\ndlD/v2SDrl3hzjttnwCpmEgkQiQSSfn7XpoKnwKdsEHay4D/YKWhm6d4zgbAR1hLAGyh2Z1YN1Oc\nuoBK0LMnnHsu9O7tOhKR1O3eDXXr2noAlYVILz+6gMYDR2BTQecA/wZeTiG2uG+Br4D4TODOwOIK\nHC9nqAUg2SBeFmLaNNeRSHmZ4iBs/v+HsdfVY4+tFTxvO2waaFVgFdALzQIq07Zt0KgRbNliOyyJ\nhNljj8GSJfD0064jyS7pXglcCPwdaB97vSv2qKgFgO5lkzBnDrRvr4u/ZIeuXS0JRKMqC+GSly6g\nKVgVUP03OTR7tjaAkezRqhXs3QsrV7qOJLd5SQC/AV4F9gDbY4/v/QxKDqT+f8kmeXmqDhoEXhLA\nIbHPVQEOjT0O8zMoOZASgGQbrQdwz0u3zo9LeX9mOgMpRoPACTZuhBNOsBXA6i+VbLFpEzRvrrIQ\n6eRHOejfYwXbwGYAdcKmg56XbHCSmnj/vy7+kk3q1rUE8MkncNZZrqPJTV4SwIXFXh8DPO5DLFIK\ndf9ItoqPAygBuOFlDKC4dUCrdAcipVMCkGylcQC3vHQqPJHw/CBsTcCXwNW+RGQ0BhATjUL9+jB3\nri0EE8km8bIQa9bAEUe4jib8/BgDmEPRGMBeYAxFK4PFZ2vXQqVK0LCh60hE0q9aNev+mTYNLrvM\ndTS5x0sC+Cewk6IN4Sth5Zv/61dQUiTe/aMBYMlW8XEAJYDM87oSuEbC65qx9yQD1P8v2a5LF5g4\n0bo7JbO8JIDqwI6E19vRBi4ZowQg2a51aygoUFkIF7wkgB+AkxNed8S6hMRnhYVWBE41gCSbxctC\nTJ7sOpLc4yUB3ILVAvog9hgL9PUzKDHLl8ORR9o+wCLZTHWB3PA6tFgVOCH2/AusMJyfNA0UGDYM\nFi2C0aNdRyLir40b4fjjrTyEykKkzo8dwW4GDgYWxR4HA31SCU68W7ECHnkEErZGFsla9erBccdZ\nWQjJHC8J4AZgS8LrLcCN/oQjYH3/vXvDkCFWK0UkF2gcIPO8JICDin2uElYaWnzyt7/ZlLi+GmmR\nHKJxgMzz0lf0J+BYYHjs878G1gK3+RhXzo4BrFoFp54Ks2ZZn6hIrti92yY8rF2rshCp8mMM4A5g\nOvBbbHewKViJaEmzwkL41a9g0CBd/CX3xMtCTJ/uOpLc4aUURBWKpoCuRGsAfPOPf8CePdC/v+tI\nRNyIdwNdeqnrSHJDWU2FKsAfgN5Ylw9YV9BIYBBQ4GNcOdcFtHo1dOoEH35ou3+J5KLFi+HCC+33\nQfWvkpfOLqBHgNpAU+Ck2OM4oBY2LiBpEu/6ufNOXfwlt7Vuba3gVatcR5IbykoAF2LTPbcnvPc9\nNg7w0zScuxIwDxifhmOF2vDhsHMnDBjgOhIRt/LyrDicpoNmRlkJoDD2KG5fKe8nqz+whKK9BnLS\nv/8Nd90FI0da3X+RXKfpoJlTVgJYClxbwvs9gWUVPG8j4CfAsyTRX5VtolG4/nq4/XZopU02RQDo\n3NlmAhX4OcooQNmzgG4C3sAGgefE3jsZKwV9SQXP+yhwO3BYBY8Tas88A99/D7f5uaJCJGTq1YOm\nTeHTT+HMM11Hk93KSgDrgFOB84A2WFfNO8DUCp7zQmAj1v+fX9qHhiYUwcnPzyc/v9SPhtKaNTB4\nMEQiUNnLZFyRHBIvC6EEULZIJEIkEkn5+y66Xx7EupH2YpvNHAa8DlyT8JmsngYajUK3bnDuuTBw\noOtoRIJn6lQbG5s1y3Uk4ZLsNFDX/e/nAL8Dflbs/axOAM8+C089BR9/rLt/kZLs2mVdQWvXQq1a\nrqMJDz9KQfgte6/0JVi71u76R47UxV+kNNWrwxlnwLRpriPJbq4TwAzgIscxZEw0CjfeaKUe2rZ1\nHY1IsKk8tP9cJ4CcMnKk7Xx0xx2uIxEJPq0H8J/rMYDSZN0YwLp1cNJJMGUK/OhHrqMRCb5oFBo2\nhPffh2bNXEcTDmEcA8h60Sj8+tdw8826+It4FS8LoVaAf5QAMuCFF2D9ek35FEmWxgH8pS4gn339\nNXToYHcx7du7jkYkXDZsgJYtYdMmzZrzQl1AARLv+vntb3XxF0lF/frQpImVhZD0UwLw0ejRNu9/\n8GDXkYiEl8YB/KME4JNvvrEib88/D1Wruo5GJLw0DuAfjQH4IBqFiy+2GT/33+86GpFw27UL6taF\nr75SWYjyaAwgAF5+2fY0HTLEdSQi4Ve9ulUFnT7ddSTZRwkgzb791rZ2HDkSqlVzHY1IdtA4gD+U\nANIoGrUZP7/6FXTs6DoakeyhcQB/aGZtGo0dC8uXwyuvuI5EJLuceCL88AOsWqWyEOmkFkCabNhg\nVT7V9SOSfvGyEGoFpJcSQBpEo9CnD/TqBZ06uY5GJDupOmj6aRpoGowdC0OHwrx5NmNBRNLv22+h\nVSuVhSiLpoFm2OTJVuXzhRd08RfxU4MG0LgxzJ7tOpLsoQRQAe+9B1ddBW+8Aaec4joakeyn6aDp\npQSQonfegWuugTffhLPPdh2NSG7QdND00hhACsaNg+uvh/Hj4dRTXUcjkjt27oR69WyHvcMPdx1N\n8GgMwGf/+hfccIO1AHTxF8msGjXgjDNUFiJdlACS8NprttJ3wgT1+Yu4onGA9FEC8OiVV6BfP5g4\n0TZ3FxE3NA6QPq4SwDHAdGAx8DnQz1EcnowebQXeJk2Cdu1cRyOS29q2he3breKuVIyrBFAADADa\nAKcBNwGtHMVSplGj4I47YOpU+8ETEbfy8tQKSBdXCeBbYH7s+Q5gKXC0o1hKNWKEbec4dSq0bu06\nGhGJ0zhAegRhGmgTYAbWGtgRe8/5NNCnn4YHHrCLf4sWTkMRkWK++QbatIGNG1UWIlGy00Bd/9Md\nAvwT6E/RxR+AoUOH/u95fn4++fn5GQvq73+Hhx+2qWYqPSsSPEcdBcccA599Bqed5joadyKRCJFI\nJOXvu2wBVAHeBiYAjxX7O2ctgMcfh8ceg2nToGlTJyGIiAe33w6HHgp33+06kuAIy0KwPGAEsIQD\nL/7O/OUv8Ne/QiSii79I0GkcoOJctQDOAmYCC4H4rf5A4L3Y84y3AB5+2Pr9p0+3pqWIBFu8LMTX\nX8Nhh7mOJhjCMgbwAQFahPbgg/D88zBjBjRs6DoaEfGiRg04/XTrrr34YtfRhFNgLsKu3HcfvPii\nLv4iYdSwj4N3AAAJVElEQVSzJ/TuDTfdBJ9/7jqa8MnZBBCN2uDR2LHW53/UUa4jEpFk9ewJixZB\n3brQrRucc479Tu/Z4zqycAjCOoCS+DoGEI3aAq+334YpU6wfUUTCraAA3noLnnwSli61ku033phb\nY3phmQXkTDRqpR3efdf6DnXxF8kOVarA5Zfb7/W0abBtG7RvD5dcYmUjCgtdRxg8OdUCiEbhttus\nv3/yZKhdO+2nEJEA2bEDxoyxxZ07d1o59+uugyOOcBNPNGqrmOvV82cFc7ItgJxJAAUFVtHzk09s\n7rCrHwARybxoFD76yLqH3nkHLr0U+vSBk0/275wFBbBsGcybZ4/58+1RqRLs3QtnnmljFuecY3Gk\nIyEoAZTg009tF6+jjrK6/rVqpe3QIhIyGzfCc8/BU09B/fqWCK64wqaVpmrHDli4cP+L/ZIlcOyx\n0KGDdUXF/6xXDzZtgpkzbQLKjBmwZo1Nac3Pt4TQsaN1aSVLCSDB9u0wZIjNCvjzn+GXv7RSsiIi\n+/bZ7n5PPgmzZ1vX0G9+U379rw0b7AIfv9DPmwdffWXF6eIX+g4drHz8IYd4i+W77+D99y0ZzJgB\nK1daQoi3EE45BapVK/84SgAx48fb3ODOneGRR+DII9MUmYhknVWrYPhwGDnS7r779IELLrA788S7\n+nnzbCwh8a6+Qwc44YTU7thLs2VLUUKIRGD5cujUyZJBfr49r179wO/lfAL45hvbunH+fPsPPe+8\nNEcmIllr507b+/vJJ2HOHOs2Lt6F07hx5nsStm6FDz4oaiEsWWKJKt5ldNpp1oWVswmgsBCeeca6\nfH79a5vnX5E+PRHJbTt2eO/CybTvv4cPPyxqIXz+ue1V/v77OZgAliyxBR/79lkSOPFEHyMTEQmY\nHTtg1izo1i2HEsCuXfDQQ9Zcu/deu/OvVCkD0YmIBFBYqoFW2MyZdtffurX196uQm4hIckKXALZs\ngd//3qZvPfGELfMWEZHkhaYWUDRq8/nbtLH5sIsX6+IvIlIRoWgBrFlj83LXroXXX7cFEiIiUjGB\nbgHs3QuPPmp1Ms480+bl6uIvIpIegW0BzJtn9XsOO8yKOLVo4ToiEZHsEthpoPXqRRk2DK69VvV7\nRES8yJqVwBs2RLVZi4hIErImAfi5JaSISDYKy5aQ3YFlwArgDkcxiIjkNBcJoBLwNywJtAZ+AbTK\n1MkjkUimTpUWYYsXwhdz2OIFxZwJYYs3FS4SQCdgJfBvoAB4BeiRqZOH7T81bPFC+GIOW7ygmDMh\nbPGmwkUCaAh8lfB6Xew9ERHJIBcJQKO7IiIB4GIW0GnAUGwMAGAgUAgMS/jMfKBdZsMSEQm9VUBz\n10GUpTIWZBOgKnaxz9ggsIiIuHUB8AU2GDzQcSwiIiIiIpJtjgGmA4uBz4F+bsPxrBIwDxjvOhCP\nagH/BJYCS7DxnqAbiP1cLALGANXchlOi54ANWIxxtYHJwHJgEvZvHxQlxfsI9nOxAHgDONxBXGUp\nKea427BxytoZjahspcXbF/t3/pz9x1VzWgOgfez5IVj3UxjGHW4FXgLGuQ7Eo1FA79jzygTvl7y4\nJsBqii76Y4FrnUVTurOBDuz/y/4w8PvY8zuAP2Y6qDKUFG8XimYd/pFgxQslxwx28/ge8CXBSgAl\nxXsudlNQJfa6bqaDCos3gfNdB1GORsAU7D81DC2Aw7GLaZjUxm4GjsAS1nigs9OISteE/X/ZlwH1\nY88bxF4HSRNKvpsGuAQYnblQPGvCgTG/BvyI4CUAODDeV4HzkjlAoDeE8UkTLHN+4jiO8jwK3I41\nPcOgKbAJGAnMBZ4BajqNqHybgT8Da4H1wFYs6YZBfawLgNif9cv4bND0Bt51HYQHPbCFqgtdB+JR\nC+DHwMdABOhY3hdyLQEcgvVR9wd2OI6lLBcCG7H+/6BWbC2uMnAS8GTszx+AO51GVL5mwC3YTcHR\n2M/HVS4DSlGU8CywHAzswcZbgqwmMAi4J+G9oP8uVsZas6dhN4+vlveFXEoAVYDXsabnm45jKc8Z\nwEVYs/NlrFn3gtOIyrcu9pgde/1PLBEEWUdgFvAfYC82OHmG04i824B1/QAchd0wBN11wE8IR5Jt\nht0YLMB+DxsBc4Ag71KyDvsZBvs9LASOLOsLuZIA8oAR2MyUxxzH4sUgbPCpKfB/wDTgGqcRle9b\nrMbT8bHXnbHZNUG2DLtbqoH9jHTGfkbCYBxFA9bXEvybmu7YXWkPYJfjWLxYhHWrNY091mE3NEFO\ntG9SNAZwPLbQ9j/uwgmOs7BsOB/rVplHUSmKoDuH8MwCaofdeQR1ql9Jfk/RNNBRFM2gCJKXsTGK\nPViS7YUNSE4hmNNAi8fbG9v7Yw1Fv39POouuZPGYd1P0b5xoNcEaBC4p3irAi9jP8hwg31VwIiIi\nIiIiIiIiIiIiIiIiIiIiIiIiImXYh80rn4/NfT499v7RWCGvZEQoWskMtlJ4egXji7sOeCJNxxJJ\ni1xZCSzZ679Ycb/2WG3/h2Lvrwd+nsLx6uLPIsGK1urR76qknX6oJJscjlX4hP1L5V6HrUyegK2c\nLW2jjCjwJ6xgWXHXsf8d/NtY5UWwwoIPY5twTMbKS8zA9r7+WcJ34hsTLQfuTnj/aqw67TzgKYp+\nL3fE4plPODbXkZBRApCwq4FdOJdiJagfKOVz7YArgLbAlUDDUj73EVbCIJ+y79oT/64mMBU4EdgO\n3IfVZLkk9hys1lAn4FKsvvzPgZOxjYmuwIrQdcBKllyVcNyPsdbNrDJiEUlJZdcBiFTQTuzCCXaX\n/AJ2IS5uKnZxBiv41gT4upRjPgAMwXba8mIPMDH2fBFW7Gwf1iJokvC5ScCW2PM3sBpV+7BE8Fns\n/RpYYT1if/e6xxhEkqYEINnkY6BO7FHc7oTn+7D9lksSxbppHmD/bpe97N9irp7wvCDheSGWEOLP\nS/sdy6OoFTEKqwBb3C7CU+dfQkhdQJJNWmIXdi8lcMvb3OMBrAUQvwB/iXXF5GF9+Z1SiK8LtmFH\nDaws8gdYy+RyivZvrQ0cm8KxRZKmFoCEXXwMAOzifA1FF+3EP4vfSZd3Zz2B/Wu/f4glgSXYeMOc\nMo4VLeF5FPgU69JphJXtnRv7uyFY99BBWGuiD7ZNpe7+RURERERERERERERERERERERERERERERE\nREREctn/A7ATWdRJAp72AAAAAElFTkSuQmCC\n", 160 | "text": [ 161 | "" 162 | ] 163 | } 164 | ], 165 | "prompt_number": 4 166 | }, 167 | { 168 | "cell_type": "code", 169 | "collapsed": false, 170 | "input": [ 171 | "# Generate loss plots\n", 172 | "# --------------- Latex Plot Beautification --------------------------\n", 173 | "fig_width_pt = 246.0 # Get this from LaTeX using \\showthe\\columnwidth\n", 174 | "inches_per_pt = 1.0/72.27 # Convert pt to inch\n", 175 | "golden_mean = (sqrt(5)-1.0)/2.0 # Aesthetic ratio\n", 176 | "fig_width = fig_width_pt*inches_per_pt # width in inches\n", 177 | "fig_height = fig_width*golden_mean # height in inches\n", 178 | "fig_size = [fig_width+1,fig_height+1]\n", 179 | "params = {'backend': 'ps',\n", 180 | " 'axes.labelsize': 10,\n", 181 | " 'text.fontsize': 10,\n", 182 | " 'legend.fontsize': 10,\n", 183 | " 'xtick.labelsize': 8,\n", 184 | " 'ytick.labelsize': 8,\n", 185 | " 'text.usetex': False,\n", 186 | " 'figure.figsize': fig_size}\n", 187 | "plt.rcParams.update(params)\n", 188 | "# --------------- Latex Plot Beautification --------------------------\n", 189 | "\n", 190 | "\n", 191 | "\n", 192 | "train = {}\n", 193 | "tmp = np.loadtxt('caffe.INFO.euclidean_v3_16_norm_realmean_20k_assem.train')\n", 194 | "train['iters'], train['seconds'], train['loss'], train['learn_rate'] = tmp[:,0], tmp[:,1], tmp[:,2], tmp[:,3]\n", 195 | "# Iters Seconds TrainingLoss LearningRate\n", 196 | "\n", 197 | "train2 = {}\n", 198 | "tmp = np.loadtxt('caffe.INFO.euclidean_v3_16_norm_superpixel_avg_20k.train')\n", 199 | "train2['iters'], train2['seconds'], train2['loss'], train2['learn_rate'] = tmp[:,0], tmp[:,1], tmp[:,2], tmp[:,3]\n", 200 | "\n", 201 | "\n", 202 | "#plt.subplot(211)\n", 203 | "plt.semilogy(train['iters'],train['loss'],'b',label='Center Depth')\n", 204 | "plt.semilogy(train2['iters'],train2['loss'],'r',label='Superpixel Avg')\n", 205 | "\n", 206 | "plt.ylabel('loss')\n", 207 | "plt.xlabel('Iters')\n", 208 | "\n", 209 | "plt.title('Train Set')\n", 210 | "plt.xlim(0,20000)\n", 211 | "plt.ylim(0,14)\n", 212 | "plt.legend()\n", 213 | "\n", 214 | "plt.savefig('training_loss.eps')\n" 215 | ], 216 | "language": "python", 217 | "metadata": {}, 218 | "outputs": [ 219 | { 220 | "metadata": {}, 221 | "output_type": "display_data", 222 | "png": "iVBORw0KGgoAAAANSUhEUgAAATIAAADmCAYAAABWHglIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 223 | "text": [ 224 | "" 225 | ] 226 | } 227 | ], 228 | "prompt_number": 72 229 | }, 230 | { 231 | "cell_type": "code", 232 | "collapsed": false, 233 | "input": [ 234 | " import pylab\n", 235 | " from pylab import arange,pi,sin,cos,sqrt\n", 236 | " fig_width_pt = 246.0 # Get this from LaTeX using \\showthe\\columnwidth\n", 237 | " inches_per_pt = 1.0/72.27 # Convert pt to inch\n", 238 | " golden_mean = (sqrt(5)-1.0)/2.0 # Aesthetic ratio\n", 239 | " fig_width = fig_width_pt*inches_per_pt # width in inches\n", 240 | " fig_height = fig_width*golden_mean # height in inches\n", 241 | " fig_size = [fig_width,fig_height]\n", 242 | " params = {'backend': 'ps',\n", 243 | " 'axes.labelsize': 10,\n", 244 | " 'text.fontsize': 10,\n", 245 | " 'legend.fontsize': 10,\n", 246 | " 'xtick.labelsize': 8,\n", 247 | " 'ytick.labelsize': 8,\n", 248 | " 'text.usetex': False,\n", 249 | " 'figure.figsize': fig_size}\n", 250 | " pylab.rcParams.update(params)\n", 251 | " # Generate data\n", 252 | " x = pylab.arange(-2*pi,2*pi,0.01)\n", 253 | " y1 = sin(x)\n", 254 | " y2 = cos(x)\n", 255 | " # Plot data\n", 256 | " # Plot data\n", 257 | " pylab.figure(1)\n", 258 | " pylab.clf()\n", 259 | " pylab.axes([0.125,0.2,0.95-0.125,0.95-0.2])\n", 260 | " pylab.plot(x,y1,'g:',label='sin(x)')\n", 261 | " pylab.plot(x,y2,'-b',label='cos(x)')\n", 262 | " pylab.xlabel('x (radians)')\n", 263 | " pylab.ylabel('y')\n", 264 | " pylab.legend()\n", 265 | " pylab.savefig('fig2.eps')\n", 266 | " \n", 267 | " \n", 268 | " " 269 | ], 270 | "language": "python", 271 | "metadata": {}, 272 | "outputs": [ 273 | { 274 | "metadata": {}, 275 | "output_type": "display_data", 276 | "png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAACgCAYAAADD0LroAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", 277 | "text": [ 278 | "" 279 | ] 280 | } 281 | ], 282 | "prompt_number": 69 283 | } 284 | ], 285 | "metadata": {} 286 | } 287 | ] 288 | } -------------------------------------------------------------------------------- /train.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Pre-train a regressor 3 | echo "Pretraining..." 4 | 5 | # starting point 6 | 7 | #INITIAL_WEIGHTS="models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel" 8 | #SOLVER_PROTO="models/finetune_flickr_style/solver.prototxt" 9 | 10 | INITIAL_WEIGHTS="models/placesCNN/places205CNN_iter_300000.caffemodel" 11 | #INITIAL_WEIGHTS="models/unary_depth_regressor/snapshots/udr_softmax_lmdb_snapshot_iter_7000.caffemodel" # resume from here 12 | #SOLVER_PROTO="models/unary_depth_regressor/solver_udr_softmax_lmdb.prototxt" 13 | #SOLVER_PROTO="models/unary_depth_regressor/solver_udr_euclidean_lmdb.prototxt" 14 | 15 | # Softmax 16 | #SOLVER_PROTO="models/unary_depth_regressor/solver_euclidean_dir.prototxt" 17 | #SOLVER_PROTO="models/unary_depth_regressor/solver_euclidean_no_softmax.prototxt" 18 | #SOLVER_PROTO="models/udr_scratch/solver_softmax_32bins.prototxt" 19 | SOLVER_PROTO="models/unary_depth_regressor/solver_softmax_dir.prototxt" 20 | # Euclidean 21 | #SOLVER_PROTO="models/unary_depth_regressor/solver_euclidean_dir.prototxt" 22 | #SNAPSHOT_PATH="models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_dir_v3_16_norm_realmean_iter_10000.solverstate" 23 | #INITIAL_WEIGHTS='models/unary_depth_regressor/snapshots_euclidean/udr_euclidean_d16_superpixel_avg_hardcoded_output_layer_iter_20000.caffemodel' 24 | 25 | # Use this to start: 26 | caffe train -solver $SOLVER_PROTO -weights $INITIAL_WEIGHTS -gpu 0 27 | 28 | # Use this to resume 29 | #caffe train -solver $SOLVER_PROTO -snapshot $SNAPSHOT_PATH -gpu 0 30 | 31 | # Use this to run from scratch (probably terrible idea) 32 | #caffe train -solver $SOLVER_PROTO 33 | --------------------------------------------------------------------------------