next

cyclegan/scripts/conda_deps.sh

@@ -0,0 +1,4 @@
+set -ex
+conda install numpy pyyaml mkl mkl-include setuptools cmake cffi typing
+conda install pytorch torchvision -c pytorch # add cuda90 if CUDA 9
+conda install visdom dominate -c conda-forge # install visdom and dominate

cyclegan/scripts/download_cyclegan_model.sh

@@ -0,0 +1,11 @@
+FILE=$1
+
+echo "Note: available models are apple2orange, orange2apple, summer2winter_yosemite, winter2summer_yosemite, horse2zebra, zebra2horse, monet2photo, style_monet, style_cezanne, style_ukiyoe, style_vangogh, sat2map, map2sat, cityscapes_photo2label, cityscapes_label2photo, facades_photo2label, facades_label2photo, iphone2dslr_flower"
+
+echo "Specified [$FILE]"
+
+mkdir -p ./checkpoints/${FILE}_pretrained
+MODEL_FILE=./checkpoints/${FILE}_pretrained/latest_net_G.pth
+URL=http://efrosgans.eecs.berkeley.edu/cyclegan/pretrained_models/$FILE.pth
+
+wget -N $URL -O $MODEL_FILE

cyclegan/scripts/download_pix2pix_model.sh

@@ -0,0 +1,10 @@
+FILE=$1
+
+echo "Note: available models are edges2shoes, sat2map, map2sat, facades_label2photo, and day2night"
+echo "Specified [$FILE]"
+
+mkdir -p ./checkpoints/${FILE}_pretrained
+MODEL_FILE=./checkpoints/${FILE}_pretrained/latest_net_G.pth
+URL=http://efrosgans.eecs.berkeley.edu/pix2pix/models-pytorch/$FILE.pth
+
+wget -N $URL -O $MODEL_FILE

cyclegan/scripts/edges/PostprocessHED.m

@@ -0,0 +1,77 @@
+%%% Prerequisites
+% You need to get the cpp file edgesNmsMex.cpp from https://raw.githubusercontent.com/pdollar/edges/master/private/edgesNmsMex.cpp
+% and compile it in Matlab: mex edgesNmsMex.cpp
+% You also need to download and install Piotr's Computer Vision Matlab Toolbox:  https://pdollar.github.io/toolbox/
+
+%%% parameters
+% hed_mat_dir: the hed mat file directory (the output of 'batch_hed.py')
+% edge_dir: the output HED edges directory
+% image_width: resize the edge map to [image_width, image_width]
+% threshold: threshold for image binarization (default 25.0/255.0)
+% small_edge: remove small edges (default 5)
+
+function [] = PostprocessHED(hed_mat_dir, edge_dir, image_width, threshold, small_edge)
+
+if ~exist(edge_dir, 'dir')
+    mkdir(edge_dir);
+end
+fileList = dir(fullfile(hed_mat_dir, '*.mat'));
+nFiles = numel(fileList);
+fprintf('find %d mat files\n', nFiles);
+
+for n = 1 : nFiles
+    if mod(n, 1000) == 0
+        fprintf('process %d/%d images\n', n, nFiles);
+    end
+    fileName = fileList(n).name;
+    filePath = fullfile(hed_mat_dir, fileName);
+    jpgName = strrep(fileName, '.mat', '.jpg');
+    edge_path = fullfile(edge_dir, jpgName);
+
+    if ~exist(edge_path, 'file')
+        E = GetEdge(filePath);
+        E = imresize(E,[image_width,image_width]);
+        E_simple = SimpleEdge(E, threshold, small_edge);
+        E_simple = uint8(E_simple*255);
+        imwrite(E_simple, edge_path, 'Quality',100);
+    end
+end
+end
+
+
+
+
+function [E] = GetEdge(filePath)
+load(filePath);
+E = 1-edge_predict;
+end
+
+function [E4] = SimpleEdge(E, threshold, small_edge)
+if nargin <= 1
+    threshold = 25.0/255.0;
+end
+
+if nargin <= 2
+    small_edge = 5;
+end
+
+if ndims(E) == 3
+    E = E(:,:,1);
+end
+
+E1 = 1 - E;
+E2 = EdgeNMS(E1);
+E3 = double(E2>=max(eps,threshold));
+E3 = bwmorph(E3,'thin',inf);
+E4 = bwareaopen(E3, small_edge);
+E4=1-E4;
+end
+
+function [E_nms] = EdgeNMS( E )
+E=single(E);
+[Ox,Oy] = gradient2(convTri(E,4));
+[Oxx,~] = gradient2(Ox);
+[Oxy,Oyy] = gradient2(Oy);
+O = mod(atan(Oyy.*sign(-Oxy)./(Oxx+1e-5)),pi);
+E_nms = edgesNmsMex(E,O,1,5,1.01,1);
+end

cyclegan/scripts/edges/batch_hed.py

@@ -0,0 +1,81 @@
+# HED batch processing script; modified from https://github.com/s9xie/hed/blob/master/examples/hed/HED-tutorial.ipynb
+# Step 1: download the hed repo: https://github.com/s9xie/hed
+# Step 2: download the models and protoxt, and put them under {caffe_root}/examples/hed/
+# Step 3: put this script under {caffe_root}/examples/hed/
+# Step 4: run the following script:
+#       python batch_hed.py --images_dir=/data/to/path/photos/ --hed_mat_dir=/data/to/path/hed_mat_files/
+# The code sometimes crashes after computation is done. Error looks like "Check failed: ... driver shutting down". You can just kill the job.
+# For large images, it will produce gpu memory issue. Therefore, you better resize the images before running this script.
+# Step 5: run the MATLAB post-processing script "PostprocessHED.m"
+
+
+import caffe
+import numpy as np
+from PIL import Image
+import os
+import argparse
+import sys
+import scipy.io as sio
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='batch proccesing: photos->edges')
+    parser.add_argument('--caffe_root', dest='caffe_root', help='caffe root', default='../../', type=str)
+    parser.add_argument('--caffemodel', dest='caffemodel', help='caffemodel', default='./hed_pretrained_bsds.caffemodel', type=str)
+    parser.add_argument('--prototxt', dest='prototxt', help='caffe prototxt file', default='./deploy.prototxt', type=str)
+    parser.add_argument('--images_dir', dest='images_dir', help='directory to store input photos', type=str)
+    parser.add_argument('--hed_mat_dir', dest='hed_mat_dir', help='directory to store output hed edges in mat file', type=str)
+    parser.add_argument('--border', dest='border', help='padding border', type=int, default=128)
+    parser.add_argument('--gpu_id', dest='gpu_id', help='gpu id', type=int, default=1)
+    args = parser.parse_args()
+    return args
+
+
+args = parse_args()
+for arg in vars(args):
+    print('[%s] =' % arg, getattr(args, arg))
+# Make sure that caffe is on the python path:
+caffe_root = args.caffe_root   # this file is expected to be in {caffe_root}/examples/hed/
+sys.path.insert(0, caffe_root + 'python')
+
+
+if not os.path.exists(args.hed_mat_dir):
+    print('create output directory %s' % args.hed_mat_dir)
+    os.makedirs(args.hed_mat_dir)
+
+imgList = os.listdir(args.images_dir)
+nImgs = len(imgList)
+print('#images = %d' % nImgs)
+
+caffe.set_mode_gpu()
+caffe.set_device(args.gpu_id)
+# load net
+net = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST)
+# pad border
+border = args.border
+
+for i in range(nImgs):
+    if i % 500 == 0:
+        print('processing image %d/%d' % (i, nImgs))
+    im = Image.open(os.path.join(args.images_dir, imgList[i]))
+
+    in_ = np.array(im, dtype=np.float32)
+    in_ = np.pad(in_, ((border, border), (border, border), (0, 0)), 'reflect')
+
+    in_ = in_[:, :, 0:3]
+    in_ = in_[:, :, ::-1]
+    in_ -= np.array((104.00698793, 116.66876762, 122.67891434))
+    in_ = in_.transpose((2, 0, 1))
+    # remove the following two lines if testing with cpu
+
+    # shape for input (data blob is N x C x H x W), set data
+    net.blobs['data'].reshape(1, *in_.shape)
+    net.blobs['data'].data[...] = in_
+    # run net and take argmax for prediction
+    net.forward()
+    fuse = net.blobs['sigmoid-fuse'].data[0][0, :, :]
+    # get rid of the border
+    fuse = fuse[border:-border, border:-border]
+    # save hed file to the disk
+    name, ext = os.path.splitext(imgList[i])
+    sio.savemat(os.path.join(args.hed_mat_dir, name + '.mat'), {'edge_predict': fuse})

cyclegan/scripts/eval_cityscapes/caffemodel/deploy.prototxt

@@ -0,0 +1,769 @@
+layer {
+  name: "data"
+  type: "Input"
+  top: "data"
+  input_param {
+    shape {
+      dim: 1
+      dim: 3
+      dim: 500
+      dim: 500
+    }
+  }
+}
+layer {
+  name: "conv1_1"
+  type: "Convolution"
+  bottom: "data"
+  top: "conv1_1"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 100
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu1_1"
+  type: "ReLU"
+  bottom: "conv1_1"
+  top: "conv1_1"
+}
+layer {
+  name: "conv1_2"
+  type: "Convolution"
+  bottom: "conv1_1"
+  top: "conv1_2"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 64
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu1_2"
+  type: "ReLU"
+  bottom: "conv1_2"
+  top: "conv1_2"
+}
+layer {
+  name: "pool1"
+  type: "Pooling"
+  bottom: "conv1_2"
+  top: "pool1"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv2_1"
+  type: "Convolution"
+  bottom: "pool1"
+  top: "conv2_1"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu2_1"
+  type: "ReLU"
+  bottom: "conv2_1"
+  top: "conv2_1"
+}
+layer {
+  name: "conv2_2"
+  type: "Convolution"
+  bottom: "conv2_1"
+  top: "conv2_2"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu2_2"
+  type: "ReLU"
+  bottom: "conv2_2"
+  top: "conv2_2"
+}
+layer {
+  name: "pool2"
+  type: "Pooling"
+  bottom: "conv2_2"
+  top: "pool2"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv3_1"
+  type: "Convolution"
+  bottom: "pool2"
+  top: "conv3_1"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu3_1"
+  type: "ReLU"
+  bottom: "conv3_1"
+  top: "conv3_1"
+}
+layer {
+  name: "conv3_2"
+  type: "Convolution"
+  bottom: "conv3_1"
+  top: "conv3_2"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu3_2"
+  type: "ReLU"
+  bottom: "conv3_2"
+  top: "conv3_2"
+}
+layer {
+  name: "conv3_3"
+  type: "Convolution"
+  bottom: "conv3_2"
+  top: "conv3_3"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu3_3"
+  type: "ReLU"
+  bottom: "conv3_3"
+  top: "conv3_3"
+}
+layer {
+  name: "pool3"
+  type: "Pooling"
+  bottom: "conv3_3"
+  top: "pool3"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv4_1"
+  type: "Convolution"
+  bottom: "pool3"
+  top: "conv4_1"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu4_1"
+  type: "ReLU"
+  bottom: "conv4_1"
+  top: "conv4_1"
+}
+layer {
+  name: "conv4_2"
+  type: "Convolution"
+  bottom: "conv4_1"
+  top: "conv4_2"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu4_2"
+  type: "ReLU"
+  bottom: "conv4_2"
+  top: "conv4_2"
+}
+layer {
+  name: "conv4_3"
+  type: "Convolution"
+  bottom: "conv4_2"
+  top: "conv4_3"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu4_3"
+  type: "ReLU"
+  bottom: "conv4_3"
+  top: "conv4_3"
+}
+layer {
+  name: "pool4"
+  type: "Pooling"
+  bottom: "conv4_3"
+  top: "pool4"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv5_1"
+  type: "Convolution"
+  bottom: "pool4"
+  top: "conv5_1"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu5_1"
+  type: "ReLU"
+  bottom: "conv5_1"
+  top: "conv5_1"
+}
+layer {
+  name: "conv5_2"
+  type: "Convolution"
+  bottom: "conv5_1"
+  top: "conv5_2"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu5_2"
+  type: "ReLU"
+  bottom: "conv5_2"
+  top: "conv5_2"
+}
+layer {
+  name: "conv5_3"
+  type: "Convolution"
+  bottom: "conv5_2"
+  top: "conv5_3"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu5_3"
+  type: "ReLU"
+  bottom: "conv5_3"
+  top: "conv5_3"
+}
+layer {
+  name: "pool5"
+  type: "Pooling"
+  bottom: "conv5_3"
+  top: "pool5"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "fc6_cs"
+  type: "Convolution"
+  bottom: "pool5"
+  top: "fc6_cs"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 4096
+    pad: 0
+    kernel_size: 7
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu6_cs"
+  type: "ReLU"
+  bottom: "fc6_cs"
+  top: "fc6_cs"
+}
+layer {
+  name: "fc7_cs"
+  type: "Convolution"
+  bottom: "fc6_cs"
+  top: "fc7_cs"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 4096
+    pad: 0
+    kernel_size: 1
+    stride: 1
+    weight_filler {
+      type: "gaussian"
+      std: 0.01
+    }
+    bias_filler {
+      type: "constant"
+      value: 0
+    }
+  }
+}
+layer {
+  name: "relu7_cs"
+  type: "ReLU"
+  bottom: "fc7_cs"
+  top: "fc7_cs"
+}
+layer {
+  name: "score_fr"
+  type: "Convolution"
+  bottom: "fc7_cs"
+  top: "score_fr"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 20
+    pad: 0
+    kernel_size: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+    }
+  }
+}
+layer {
+  name: "upscore2"
+  type: "Deconvolution"
+  bottom: "score_fr"
+  top: "upscore2"
+  param {
+    lr_mult: 1
+  }
+  convolution_param {
+    num_output: 20
+    bias_term: false
+    kernel_size: 4
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+    }
+  }
+}
+layer {
+  name: "score_pool4"
+  type: "Convolution"
+  bottom: "pool4"
+  top: "score_pool4"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 20
+    pad: 0
+    kernel_size: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+    }
+  }
+}
+layer {
+  name: "score_pool4c"
+  type: "Crop"
+  bottom: "score_pool4"
+  bottom: "upscore2"
+  top: "score_pool4c"
+  crop_param {
+    axis: 2
+    offset: 5
+  }
+}
+layer {
+  name: "fuse_pool4"
+  type: "Eltwise"
+  bottom: "upscore2"
+  bottom: "score_pool4c"
+  top: "fuse_pool4"
+  eltwise_param {
+    operation: SUM
+  }
+}
+layer {
+  name: "upscore_pool4"
+  type: "Deconvolution"
+  bottom: "fuse_pool4"
+  top: "upscore_pool4"
+  param {
+    lr_mult: 1
+  }
+  convolution_param {
+    num_output: 20
+    bias_term: false
+    kernel_size: 4
+    stride: 2
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+    }
+  }
+}
+layer {
+  name: "score_pool3"
+  type: "Convolution"
+  bottom: "pool3"
+  top: "score_pool3"
+  param {
+    lr_mult: 1
+    decay_mult: 1
+  }
+  param {
+    lr_mult: 2
+    decay_mult: 0
+  }
+  convolution_param {
+    num_output: 20
+    pad: 0
+    kernel_size: 1
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+    }
+  }
+}
+layer {
+  name: "score_pool3c"
+  type: "Crop"
+  bottom: "score_pool3"
+  bottom: "upscore_pool4"
+  top: "score_pool3c"
+  crop_param {
+    axis: 2
+    offset: 9
+  }
+}
+layer {
+  name: "fuse_pool3"
+  type: "Eltwise"
+  bottom: "upscore_pool4"
+  bottom: "score_pool3c"
+  top: "fuse_pool3"
+  eltwise_param {
+    operation: SUM
+  }
+}
+layer {
+  name: "upscore8"
+  type: "Deconvolution"
+  bottom: "fuse_pool3"
+  top: "upscore8"
+  param {
+    lr_mult: 1
+  }
+  convolution_param {
+    num_output: 20
+    bias_term: false
+    kernel_size: 16
+    stride: 8
+    weight_filler {
+      type: "xavier"
+    }
+    bias_filler {
+      type: "constant"
+    }
+  }
+}
+layer {
+  name: "score"
+  type: "Crop"
+  bottom: "upscore8"
+  bottom: "data"
+  top: "score"
+  crop_param {
+    axis: 2
+    offset: 31
+  }
+}

cyclegan/scripts/eval_cityscapes/cityscapes.py

@@ -0,0 +1,141 @@
+# The following code is modified from https://github.com/shelhamer/clockwork-fcn
+import sys
+import os
+import glob
+import numpy as np
+from PIL import Image
+
+
+class cityscapes:
+    def __init__(self, data_path):
+        # data_path something like /data2/cityscapes
+        self.dir = data_path
+        self.classes = ['road', 'sidewalk', 'building', 'wall', 'fence',
+                        'pole', 'traffic light', 'traffic sign', 'vegetation', 'terrain',
+                        'sky', 'person', 'rider', 'car', 'truck',
+                        'bus', 'train', 'motorcycle', 'bicycle']
+        self.mean = np.array((72.78044, 83.21195, 73.45286), dtype=np.float32)
+        # import cityscapes label helper and set up label mappings
+        sys.path.insert(0, '{}/scripts/helpers/'.format(self.dir))
+        labels = __import__('labels')
+        self.id2trainId = {label.id: label.trainId for label in labels.labels}  # dictionary mapping from raw IDs to train IDs
+        self.trainId2color = {label.trainId: label.color for label in labels.labels}  # dictionary mapping train IDs to colors as 3-tuples
+
+    def get_dset(self, split):
+        '''
+        List images as (city, id) for the specified split
+
+        TODO(shelhamer) generate splits from cityscapes itself, instead of
+        relying on these separately made text files.
+        '''
+        if split == 'train':
+            dataset = open('{}/ImageSets/segFine/train.txt'.format(self.dir)).read().splitlines()
+        else:
+            dataset = open('{}/ImageSets/segFine/val.txt'.format(self.dir)).read().splitlines()
+        return [(item.split('/')[0], item.split('/')[1]) for item in dataset]
+
+    def load_image(self, split, city, idx):
+        im = Image.open('{}/leftImg8bit_sequence/{}/{}/{}_leftImg8bit.png'.format(self.dir, split, city, idx))
+        return im
+
+    def assign_trainIds(self, label):
+        """
+        Map the given label IDs to the train IDs appropriate for training
+        Use the label mapping provided in labels.py from the cityscapes scripts
+        """
+        label = np.array(label, dtype=np.float32)
+        if sys.version_info[0] < 3:
+            for k, v in self.id2trainId.iteritems():
+                label[label == k] = v
+        else:
+            for k, v in self.id2trainId.items():
+                label[label == k] = v
+        return label
+
+    def load_label(self, split, city, idx):
+        """
+        Load label image as 1 x height x width integer array of label indices.
+        The leading singleton dimension is required by the loss.
+        """
+        label = Image.open('{}/gtFine/{}/{}/{}_gtFine_labelIds.png'.format(self.dir, split, city, idx))
+        label = self.assign_trainIds(label)  # get proper labels for eval
+        label = np.array(label, dtype=np.uint8)
+        label = label[np.newaxis, ...]
+        return label
+
+    def preprocess(self, im):
+        """
+        Preprocess loaded image (by load_image) for Caffe:
+        - cast to float
+        - switch channels RGB -> BGR
+        - subtract mean
+        - transpose to channel x height x width order
+        """
+        in_ = np.array(im, dtype=np.float32)
+        in_ = in_[:, :, ::-1]
+        in_ -= self.mean
+        in_ = in_.transpose((2, 0, 1))
+        return in_
+
+    def palette(self, label):
+        '''
+        Map trainIds to colors as specified in labels.py
+        '''
+        if label.ndim == 3:
+            label = label[0]
+        color = np.empty((label.shape[0], label.shape[1], 3))
+        if sys.version_info[0] < 3:
+            for k, v in self.trainId2color.iteritems():
+                color[label == k, :] = v
+        else:
+            for k, v in self.trainId2color.items():
+                color[label == k, :] = v
+        return color
+
+    def make_boundaries(label, thickness=None):
+        """
+        Input is an image label, output is a numpy array mask encoding the boundaries of the objects
+        Extract pixels at the true boundary by dilation - erosion of label.
+        Don't just pick the void label as it is not exclusive to the boundaries.
+        """
+        assert(thickness is not None)
+        import skimage.morphology as skm
+        void = 255
+        mask = np.logical_and(label > 0, label != void)[0]
+        selem = skm.disk(thickness)
+        boundaries = np.logical_xor(skm.dilation(mask, selem),
+                                    skm.erosion(mask, selem))
+        return boundaries
+
+    def list_label_frames(self, split):
+        """
+        Select labeled frames from a split for evaluation
+        collected as (city, shot, idx) tuples
+        """
+        def file2idx(f):
+            """Helper to convert file path into frame ID"""
+            city, shot, frame = (os.path.basename(f).split('_')[:3])
+            return "_".join([city, shot, frame])
+        frames = []
+        cities = [os.path.basename(f) for f in glob.glob('{}/gtFine/{}/*'.format(self.dir, split))]
+        for c in cities:
+            files = sorted(glob.glob('{}/gtFine/{}/{}/*labelIds.png'.format(self.dir, split, c)))
+            frames.extend([file2idx(f) for f in files])
+        return frames
+
+    def collect_frame_sequence(self, split, idx, length):
+        """
+        Collect sequence of frames preceding (and including) a labeled frame
+        as a list of Images.
+
+        Note: 19 preceding frames are provided for each labeled frame.
+        """
+        SEQ_LEN = length
+        city, shot, frame = idx.split('_')
+        frame = int(frame)
+        frame_seq = []
+        for i in range(frame - SEQ_LEN, frame + 1):
+            frame_path = '{0}/leftImg8bit_sequence/val/{1}/{1}_{2}_{3:0>6d}_leftImg8bit.png'.format(
+                self.dir, city, shot, i)
+            frame_seq.append(Image.open(frame_path))
+        return frame_seq

cyclegan/scripts/eval_cityscapes/download_fcn8s.sh

@@ -0,0 +1,3 @@
+URL=http://people.eecs.berkeley.edu/~tinghuiz/projects/pix2pix/fcn-8s-cityscapes/fcn-8s-cityscapes.caffemodel
+OUTPUT_FILE=./scripts/eval_cityscapes/caffemodel/fcn-8s-cityscapes.caffemodel
+wget -N $URL -O $OUTPUT_FILE

cyclegan/scripts/eval_cityscapes/evaluate.py

@@ -0,0 +1,68 @@
+import os
+import caffe
+import argparse
+import numpy as np
+import scipy.misc
+from PIL import Image
+from util import segrun, fast_hist, get_scores
+from cityscapes import cityscapes
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--cityscapes_dir", type=str, required=True, help="Path to the original cityscapes dataset")
+parser.add_argument("--result_dir", type=str, required=True, help="Path to the generated images to be evaluated")
+parser.add_argument("--output_dir", type=str, required=True, help="Where to save the evaluation results")
+parser.add_argument("--caffemodel_dir", type=str, default='./scripts/eval_cityscapes/caffemodel/', help="Where the FCN-8s caffemodel stored")
+parser.add_argument("--gpu_id", type=int, default=0, help="Which gpu id to use")
+parser.add_argument("--split", type=str, default='val', help="Data split to be evaluated")
+parser.add_argument("--save_output_images", type=int, default=0, help="Whether to save the FCN output images")
+args = parser.parse_args()
+
+
+def main():
+    if not os.path.isdir(args.output_dir):
+        os.makedirs(args.output_dir)
+    if args.save_output_images > 0:
+        output_image_dir = args.output_dir + 'image_outputs/'
+        if not os.path.isdir(output_image_dir):
+            os.makedirs(output_image_dir)
+    CS = cityscapes(args.cityscapes_dir)
+    n_cl = len(CS.classes)
+    label_frames = CS.list_label_frames(args.split)
+    caffe.set_device(args.gpu_id)
+    caffe.set_mode_gpu()
+    net = caffe.Net(args.caffemodel_dir + '/deploy.prototxt',
+                    args.caffemodel_dir + 'fcn-8s-cityscapes.caffemodel',
+                    caffe.TEST)
+
+    hist_perframe = np.zeros((n_cl, n_cl))
+    for i, idx in enumerate(label_frames):
+        if i % 10 == 0:
+            print('Evaluating: %d/%d' % (i, len(label_frames)))
+        city = idx.split('_')[0]
+        # idx is city_shot_frame
+        label = CS.load_label(args.split, city, idx)
+        im_file = args.result_dir + '/' + idx + '_leftImg8bit.png'
+        im = np.array(Image.open(im_file))
+        im = scipy.misc.imresize(im, (label.shape[1], label.shape[2]))
+        out = segrun(net, CS.preprocess(im))
+        hist_perframe += fast_hist(label.flatten(), out.flatten(), n_cl)
+        if args.save_output_images > 0:
+            label_im = CS.palette(label)
+            pred_im = CS.palette(out)
+            scipy.misc.imsave(output_image_dir + '/' + str(i) + '_pred.jpg', pred_im)
+            scipy.misc.imsave(output_image_dir + '/' + str(i) + '_gt.jpg', label_im)
+            scipy.misc.imsave(output_image_dir + '/' + str(i) + '_input.jpg', im)
+
+    mean_pixel_acc, mean_class_acc, mean_class_iou, per_class_acc, per_class_iou = get_scores(hist_perframe)
+    with open(args.output_dir + '/evaluation_results.txt', 'w') as f:
+        f.write('Mean pixel accuracy: %f\n' % mean_pixel_acc)
+        f.write('Mean class accuracy: %f\n' % mean_class_acc)
+        f.write('Mean class IoU: %f\n' % mean_class_iou)
+        f.write('************ Per class numbers below ************\n')
+        for i, cl in enumerate(CS.classes):
+            while len(cl) < 15:
+                cl = cl + ' '
+            f.write('%s: acc = %f, iou = %f\n' % (cl, per_class_acc[i], per_class_iou[i]))
+
+
+main()

cyclegan/scripts/eval_cityscapes/util.py

@@ -0,0 +1,42 @@
+# The following code is modified from https://github.com/shelhamer/clockwork-fcn
+import numpy as np
+
+
+def get_out_scoremap(net):
+    return net.blobs['score'].data[0].argmax(axis=0).astype(np.uint8)
+
+
+def feed_net(net, in_):
+    """
+    Load prepared input into net.
+    """
+    net.blobs['data'].reshape(1, *in_.shape)
+    net.blobs['data'].data[...] = in_
+
+
+def segrun(net, in_):
+    feed_net(net, in_)
+    net.forward()
+    return get_out_scoremap(net)
+
+
+def fast_hist(a, b, n):
+    k = np.where((a >= 0) & (a < n))[0]
+    bc = np.bincount(n * a[k].astype(int) + b[k], minlength=n**2)
+    if len(bc) != n**2:
+        # ignore this example if dimension mismatch
+        return 0
+    return bc.reshape(n, n)
+
+
+def get_scores(hist):
+    # Mean pixel accuracy
+    acc = np.diag(hist).sum() / (hist.sum() + 1e-12)
+
+    # Per class accuracy
+    cl_acc = np.diag(hist) / (hist.sum(1) + 1e-12)
+
+    # Per class IoU
+    iu = np.diag(hist) / (hist.sum(1) + hist.sum(0) - np.diag(hist) + 1e-12)
+
+    return acc, np.nanmean(cl_acc), np.nanmean(iu), cl_acc, iu

cyclegan/scripts/install_deps.sh

@@ -0,0 +1,3 @@
+set -ex
+pip install visdom
+pip install dominate

cyclegan/scripts/test_before_push.py

@@ -0,0 +1,51 @@
+# Simple script to make sure basic usage
+# such as training, testing, saving and loading
+# runs without errors.
+import os
+
+
+def run(command):
+    print(command)
+    exit_status = os.system(command)
+    if exit_status > 0:
+        exit(1)
+
+
+if __name__ == '__main__':
+    # download mini datasets
+    if not os.path.exists('./datasets/mini'):
+        run('bash ./datasets/download_cyclegan_dataset.sh mini')
+
+    if not os.path.exists('./datasets/mini_pix2pix'):
+        run('bash ./datasets/download_cyclegan_dataset.sh mini_pix2pix')
+
+    # pretrained cyclegan model
+    if not os.path.exists('./checkpoints/horse2zebra_pretrained/latest_net_G.pth'):
+        run('bash ./scripts/download_cyclegan_model.sh horse2zebra')
+    run('python test.py --model test --dataroot ./datasets/mini --name horse2zebra_pretrained --no_dropout --num_test 1 --no_dropout')
+
+    # pretrained pix2pix model
+    if not os.path.exists('./checkpoints/facades_label2photo_pretrained/latest_net_G.pth'):
+        run('bash ./scripts/download_pix2pix_model.sh facades_label2photo')
+    if not os.path.exists('./datasets/facades'):
+        run('bash ./datasets/download_pix2pix_dataset.sh facades')
+    run('python test.py --dataroot ./datasets/facades/ --direction BtoA --model pix2pix --name facades_label2photo_pretrained --num_test 1')
+
+    # cyclegan train/test
+    run('python train.py --model cycle_gan --name temp_cyclegan --dataroot ./datasets/mini --n_epochs 1 --n_epochs_decay 0 --save_latest_freq 10  --print_freq 1 --display_id -1')
+    run('python test.py --model test --name temp_cyclegan --dataroot ./datasets/mini --num_test 1 --model_suffix "_A" --no_dropout')
+
+    # pix2pix train/test
+    run('python train.py --model pix2pix --name temp_pix2pix --dataroot ./datasets/mini_pix2pix --n_epochs 1 --n_epochs_decay 5 --save_latest_freq 10 --display_id -1')
+    run('python test.py --model pix2pix --name temp_pix2pix --dataroot ./datasets/mini_pix2pix --num_test 1')
+
+    # template train/test
+    run('python train.py --model template --name temp2 --dataroot ./datasets/mini_pix2pix --n_epochs 1 --n_epochs_decay 0 --save_latest_freq 10 --display_id -1')
+    run('python test.py --model template --name temp2 --dataroot ./datasets/mini_pix2pix --num_test 1')
+
+    # colorization train/test (optional)
+    if not os.path.exists('./datasets/mini_colorization'):
+        run('bash ./datasets/download_cyclegan_dataset.sh mini_colorization')
+
+    run('python train.py --model colorization --name temp_color --dataroot ./datasets/mini_colorization --n_epochs 1 --n_epochs_decay 0 --save_latest_freq 5 --display_id -1')
+    run('python test.py --model colorization --name temp_color --dataroot ./datasets/mini_colorization --num_test 1')

cyclegan/scripts/test_colorization.sh

@@ -0,0 +1,2 @@
+set -ex
+python test.py --dataroot ./datasets/colorization --name color_pix2pix --model colorization

cyclegan/scripts/test_cyclegan.sh

@@ -0,0 +1,2 @@
+set -ex
+python test.py --dataroot ./datasets/maps --name maps_cyclegan --model cycle_gan --phase test --no_dropout

cyclegan/scripts/test_pix2pix.sh

@@ -0,0 +1,2 @@
+set -ex
+python test.py --dataroot ./datasets/facades --name facades_pix2pix --model pix2pix --netG unet_256 --direction BtoA --dataset_mode aligned --norm batch

cyclegan/scripts/test_single.sh

@@ -0,0 +1,2 @@
+set -ex
+python test.py --dataroot ./datasets/facades/testB/ --name facades_pix2pix --model test --netG unet_256 --direction BtoA --dataset_mode single --norm batch

cyclegan/scripts/train_colorization.sh

@@ -0,0 +1,2 @@
+set -ex
+python train.py --dataroot ./datasets/colorization --name color_pix2pix --model colorization

cyclegan/scripts/train_cyclegan.sh

@@ -0,0 +1,2 @@
+set -ex
+python train.py --dataroot ./datasets/maps --name maps_cyclegan --model cycle_gan --pool_size 50 --no_dropout

cyclegan/scripts/train_pix2pix.sh

@@ -0,0 +1,2 @@
+set -ex
+python train.py --dataroot ./datasets/facades --name facades_pix2pix --model pix2pix --netG unet_256 --direction BtoA --lambda_L1 100 --dataset_mode aligned --norm batch --pool_size 0