update scripts

Author: junyanz

README.md

@@ -59,13 +59,13 @@ conda create --name von --file pkg_specs.txt
 source activate von
 ```
 
-- Compile the rendering kernel by the following:
+- Compile our rendering kernel by running the following:
 ```bash
 ./install.sh
 ```
 
 
-- (Optional) Install [blender](https://www.blender.org/) for visualizing generated 3D shapes. After installation, please add blender to your PATH environment variable.
+- (Optional) Install [blender](https://www.blender.org/) for visualizing generated 3D shapes. After installation, please add blender to the PATH environment variable.
 
 ### Generate 3D shapes, 2.5D sketches, and images
 - Download our pretrained models:

clean.sh

@@ -1,3 +1,4 @@
+# remove the old built files
 cd render_module
 echo "clean calc_prob directory"
 bash ./calc_prob/clean.sh

data/base_dataset.py

@@ -25,7 +25,7 @@ def __len__(self):
 
 def get_transform(opt, has_mask=False, no_flip=None, no_normalize=False):
     transform_list = []
-    if opt.color_jitter and not has_mask:
+    if hasattr(opt, 'color_jitter') and opt.color_jitter and not has_mask:
         transform_list.append(transforms.ColorJitter(hue=0.1))
     if opt.resize_or_crop == 'resize_and_crop':
         osize = [opt.load_size, opt.load_size]

data/images_dataset.py

@@ -49,6 +49,7 @@ def initialize(self, opt):
     @staticmethod
     def modify_commandline_options(parser, is_train=True):
         parser.add_argument('--random_shift', action='store_true', help='add random shift to real images and rendered ones')
+        parser.add_argument('--color_jitter', action='store_true', help='jitter the hue of loaded images')
         # type of  pose pool to sample from:
         parser.add_argument('--pose_type', type=str, default='hack', choices=['hack'], help='select which pool of poses to sample from')
         parser.add_argument('--pose_align', action='store_true', help='choose to shuffle pose or not. not shuffling == paired pose')

models/base_model.py

@@ -216,20 +216,16 @@ def get_current_losses(self):
                 if hasattr(var, 'requires_grad'):
                     if var.requires_grad:
                         var = var.item()
-                losses_ret[name] = var  # getattr(self, 'loss_' + name)
+                losses_ret[name] = var
         return losses_ret
 
     def check_nan_inf(self):
         losses = self.get_current_losses()
         for k, v in losses.items():
             if np.isnan(v):
                 print('%s is nan!' % k)
-                import pdb
-                pdb.set_trace()
             elif np.isinf(v):
                 print('s is inf!' % k)
-                import pdb
-                pdb.set_trace()
             else:
                 continue
 
@@ -276,7 +272,6 @@ def get_depth(self, voxel, rot_mat, use_df=False, flipped=False):
         max_depth = depth.data.max()
         # normalize the depth to [-1, 1]
         depth2 = 1 - (depth - min_depth) / (max_depth - min_depth) * 2
-        # sil2 = silhouette * 2 - 1
         return silhouette, depth2
 
     def move_to_cuda(self, gpu_idx=0):
@@ -340,7 +335,6 @@ def safe_render(self, netG, batch_size, nz, flipped=None):
         success = False
         MAX_RETRY = 10
         cnt = 0
-        # print('safe render')
         while not success and cnt < MAX_RETRY:
             try:
                 z_shape = self.get_z_random(batch_size, nz).view(batch_size, nz, 1, 1, 1).to(self.device)

models/basics.py

@@ -4,11 +4,10 @@
 import functools
 from torch.optim import lr_scheduler
 
+
 ###############################################################################
 # Functions
 ###############################################################################
-
-
 def init_weights(net, init_type='normal', init_param=0.02):
     def init_func(m):
         classname = m.__class__.__name__

models/networks.py

@@ -3,11 +3,10 @@
 import math
 from .basics import get_norm_layer, get_non_linearity, init_net
 
+
 ###############################################################################
 # Functions
 ###############################################################################
-
-
 def _cal_kl(mu, logvar, lambda_kl):
     if lambda_kl > 0.0:
         logvar = torch.clamp(logvar, max=10.0)  # to prevent nan
@@ -742,7 +741,6 @@ def __init__(self, n_downsample, input_dim, dim, style_dim, norm, activ, vae=Fal
 
         self.model = nn.Sequential(*self.model)
         self.output_dim = dim
-        # import pdb; pdb.set_trace()
 
     def forward(self, x):
         if self.vae:

models/networks_3d.py

@@ -36,8 +36,9 @@ def deconvBlock(input_nc, output_nc, bias, norm_layer=None, nl='relu'):
     return nn.Sequential(*layers)
 
 
-def toRGB(input_nc, rgb_nc, bias, zero_mean=False, sig=True):
-    layers = [nn.ConvTranspose3d(input_nc, rgb_nc, 4, 2, 1, bias=bias)]
+# the last layer of a generator
+def toRGB(input_nc, output_nc, bias, zero_mean=False, sig=True):
+    layers = [nn.ConvTranspose3d(input_nc, output_nc, 4, 2, 1, bias=bias)]
     if sig:
         layers += [nn.Sigmoid()]
     return nn.Sequential(*layers)
@@ -114,6 +115,7 @@ def forward(self, input):
         return output.view(-1, 1).squeeze(1)
 
 
+# the first layer of a discriminator
 def fromRGB(input_nc, output_nc, bias):
     layers = []
     layers += [nn.Conv3d(input_nc, output_nc, 4, 2, 1, bias=bias)]

models/test_model.py

@@ -65,7 +65,6 @@ def set_posepool(self, posepool):
         if not self.random_view:
             self.elevation = (posepool[:, 0] // 3) * 3
             self.azimuth = (posepool[:, 1] // 5) * 5
-            # import pdb; pdb.set_trace()
             views = np.zeros((self.n_views, 2))
             hist, bins = np.histogram(self.azimuth, bins=range(-90, 91, 5))
             sort_ids = hist.argsort()[::-1][: self.n_views]

options/base_options.py

@@ -21,59 +21,55 @@ def initialize(self, parser):
         parser.add_argument('--output_nc', type=int, default=3, help='# of output image channels')
         parser.add_argument('--nz_texture', type=int, default=8, help='#latent vector')
         parser.add_argument('--nz_shape', type=int, default=200, help='#latent vector')
-
-        parser.add_argument('--nef', type=int, default=64, help='# of encoder filters in first conv layer')
-        parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in first conv layer')
-        parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in first conv layer')
-        parser.add_argument('--ngf_3d', type=int, default=64, help='# of gen filters in first conv layer')
-        parser.add_argument('--ndf_3d', type=int, default=64, help='# of discrim filters in first conv layer')
-
         parser.add_argument('--gpu_ids', type=str, default='0', help='gpu ids: e.g. 0  0,1,2, 0,2, -1 for CPU mode')
         parser.add_argument('--name', type=str, default='experiment_name', help='name of the experiment. It decides where to store samples and models')
-        parser.add_argument('--resize_or_crop', type=str, default='crop_real_im', help='crop_real_im | resize_and_crop | crop | scale_width | scale_width_and_crop')
-
-        parser.add_argument('--dataset_mode', type=str, default='base', help='base')
         parser.add_argument('--model', type=str, default='stage', help='chooses which model to use. bicycle,, ...')
+        parser.add_argument('--epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model')
+        parser.add_argument('--phase', type=str, default='val', help='train, val, test, etc')
         parser.add_argument('--num_threads', default=6, type=int, help='# sthreads for loading data')
         parser.add_argument('--checkpoints_dir', type=str, default='../../results_texture/', help='models are saved here')
-
-        parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly')
+        # display
         parser.add_argument('--display_winsize', type=int, default=128, help='display window size')
-        parser.add_argument('--use_dropout', action='store_true', help='use dropout for the generator')
+        # dataset
+        parser.add_argument('--dataset_mode', type=str, default='base', help='base')
+        parser.add_argument('--resize_or_crop', type=str, default='crop_real_im', help='crop_real_im | resize_and_crop | crop | scale_width | scale_width_and_crop')
+        parser.add_argument('--serial_batches', action='store_true', help='if true, takes images in order to make batches, otherwise takes them randomly')
         parser.add_argument('--max_dataset_size', type=int, default=float("inf"), help='Maximum number of samples allowed per dataset. If the dataset directory contains more than max_dataset_size, only a subset is loaded.')
-
         # models
         parser.add_argument('--num_Ds', type=int, default=2, help='the number of discrminators')
-        parser.add_argument('--gan_mode', type=str, default='lsgan', help='dcgan | lsgan | wgangp | hinge')  # for 2D texture network; not for 3D; use gan_mode_3D for 3D shape
         parser.add_argument('--netD', type=str, default='multi', help='selects model to use for netD')
         parser.add_argument('--netG', type=str, default='resnet_cat', help='selects model to use for netG')
+        parser.add_argument('--use_dropout', action='store_true', help='use dropout for the generator')
         parser.add_argument('--netE', type=str, default='adaIN', help='selects model to use for netE')
+        parser.add_argument('--where_add', type=str, default='all', help='where to add z in the network G: input | all | middle')
         parser.add_argument('--netG_3D', type=str, default='G0', help='selects model to use for netG_3D')
         parser.add_argument('--netD_3D', type=str, default='D0', help='selects model to use for netD_3D')
         parser.add_argument('--norm', type=str, default='inst', help='instance normalization or batch normalization')
         parser.add_argument('--nl', type=str, default='relu', help='non-linearity activation: relu | lrelu | elu')
         parser.add_argument('--G_norm_3D', type=str, default='batch3d', help='normalization layer for G: inst3d | batch3d | none')
         parser.add_argument('--D_norm_3D', type=str, default='none', help='normalization layer for D: inst3d | batch3d | none')
-
+        # number of channels in our networks
+        parser.add_argument('--nef', type=int, default=64, help='# of encoder filters in first conv layer')
+        parser.add_argument('--ngf', type=int, default=64, help='# of gen filters in first conv layer')
+        parser.add_argument('--ndf', type=int, default=64, help='# of discrim filters in first conv layer')
+        parser.add_argument('--ngf_3d', type=int, default=64, help='# of gen filters in first conv layer')
+        parser.add_argument('--ndf_3d', type=int, default=64, help='# of discrim filters in first conv layer')
         # extra parameters
-        parser.add_argument('--where_add', type=str, default='all', help='input|all|middle; where to add z in the network G')
+        parser.add_argument('--gan_mode', type=str, default='lsgan', help='dcgan | lsgan | wgangp | hinge')  # for 2D texture network; not for 3D; use gan_mode_3D for 3D shape
         parser.add_argument('--init_type', type=str, default='kaiming', help='network initialization [normal|xavier|kaiming|orth]')
         parser.add_argument('--init_param', type=float, default=0.02, help='gain')
-        parser.add_argument('--no_largest', action='store_true', help='skip findind largest connected component during rendering')
-        parser.add_argument('--color_jitter', action='store_true', help='jitter the hue of loaded images')
-
-        # 3dgan paramters:
+        # 3D paramters:
         parser.add_argument('--voxel_res', type=int, default=128, help='voxel res')
         parser.add_argument('--class_3d', type=str, default='car', choices=['car', 'chair', 'mug', 'lamp'], help='3d model class')
-        parser.add_argument('--suffix', default='', type=str, help='suffix')
-        parser.add_argument('--verbose', action='store_true', help='if specified, print more debugging information')
         parser.add_argument('--model3D_dir', type=str, default=None, help='directory to store pretrained 3D model')
         parser.add_argument('--model2D_dir', type=str, default=None, help='directory to store pretrained 2D model')
-        parser.add_argument('--print_grad', action='store_true', help='if print grad for 2D and 3D gan loss')
-        parser.add_argument('--epoch', type=str, default='latest', help='which epoch to load? set to latest to use latest cached model')
-        parser.add_argument('--phase', type=str, default='val', help='train, val, test, etc')
         parser.add_argument('--use_df', action='store_true', help='use distance function (DF) representation')
         parser.add_argument('--df_th', type=float, default=0.90, help='threshold for rendering df')
+        # misc
+        parser.add_argument('--no_largest', action='store_true', help='skip findind largest connected component during rendering')
+        parser.add_argument('--suffix', default='', type=str, help='suffix')
+        parser.add_argument('--verbose', action='store_true', help='if specified, print more debugging information')
+        parser.add_argument('--print_grad', action='store_true', help='if print grad for 2D and 3D gan loss')
         parser.add_argument('--seed', type=int, default=0, help='seed')
 
         # special tasks

options/test_options.py

@@ -7,9 +7,6 @@ def initialize(self, parser):
         parser.add_argument('--results_dir', type=str, default='../results/', help='saves results here.')
         parser.add_argument('--n_shapes', type=int, default=10, help='#shapes')
         parser.add_argument('--n_views', type=int, default=10, help='#views')
-        parser.add_argument('--aspect_ratio', type=float, default=1.0, help='aspect ratio for the results')
-        parser.add_argument('--th', default=0.01, type=float, help='thresholding for isosurface')
-        # new parameters
         parser.add_argument('--reset_shape', action='store_true', help='sample a different shape')
         parser.add_argument('--reset_texture', action='store_true', help='sample a different texture')
         parser.add_argument('--real_shape', action='store_true', help='use real voxels')
@@ -21,6 +18,8 @@ def initialize(self, parser):
         parser.add_argument('--show_rec', action='store_true', help='show reconstruction image')
         parser.add_argument('--interp_shape', action='store_true', help='interpolate in shape space')
         parser.add_argument('--interp_texture', action='store_true', help='interpolate in texture space')
+        parser.add_argument('--aspect_ratio', type=float, default=1.0, help='aspect ratio for the results')
+        parser.add_argument('--ios_th', default=0.01, type=float, help='thresholding for isosurface')
 
         self.isTrain = False
         return parser

options/train_options.py

@@ -4,21 +4,22 @@
 class TrainOptions(BaseOptions):
     def initialize(self, parser):
         BaseOptions.initialize(self, parser)
+        # display and print
         parser.add_argument('--display_freq', type=int, default=400, help='frequency of showing training results on screen')
         parser.add_argument('--display_id', type=int, default=1, help='window id of the web display')
         parser.add_argument('--display_port', type=int, default=2005, help='visdom display port')
-
         parser.add_argument('--update_html_freq', type=int, default=4000, help='frequency of saving training results to html')
         parser.add_argument('--print_freq', type=int, default=400, help='frequency of showing training results on console')
+        parser.add_argument('--no_html', action='store_true', help='do not save intermediate training results to [opt.checkpoints_dir]/[opt.name]/web/')
+        # saving and training models
         parser.add_argument('--save_latest_freq', type=int, default=10000, help='frequency of saving the latest results')
         parser.add_argument('--save_epoch_freq', type=int, default=10, help='frequency of saving checkpoints at the end of epochs')
         parser.add_argument('--continue_train', action='store_true', help='continue training: load the latest model')
         parser.add_argument('--niter', type=int, default=100, help='# of iter at starting learning rate')
         parser.add_argument('--niter_decay', type=int, default=100, help='# of iter to linearly decay learning rate to zero')
         parser.add_argument('--epoch_count', type=int, default=1, help='the starting epoch count, we save the model by <epoch_count>, <epoch_count>+<save_latest_freq>, ...')
-        parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam')
-        parser.add_argument('--no_html', action='store_true', help='do not save intermediate training results to [opt.checkpoints_dir]/[opt.name]/web/')
         # learning rate
+        parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam')
         parser.add_argument('--lr', type=float, default=0.0002, help='initial learning rate for adam')
         parser.add_argument('--lr_policy', type=str, default='lambda', help='learning rate policy: lambda|step|plateau')
         parser.add_argument('--pool_size', type=int, default=50, help='the size of image buffer that stores previously generated images')

render_module/calc_prob/calc_prob/functions/calc_prob.py

@@ -28,10 +28,6 @@ def backward(ctx, grad_in):
         calc_prob_lib.calc_prob_backward(prob_in, stop_prob_weighted, grad_out)
         if torch.isnan(grad_out).any():
             print('nan gradient found')
-            import pdb
-            pdb.set_trace()
         elif torch.isinf(grad_out).any():
             print('inf gradient found')
-            import pdb
-            pdb.set_trace()
         return grad_out

scripts/figures.sh

@@ -1,8 +1,8 @@
 # misc
 set -ex
 GPU_IDS=${1}   # 0
-CLASS=${2}    # car, chair
-DATASET=${3}  # df, voxel
+CLASS=${2}    # car | chair
+DATASET=${3}  # df | voxel
 SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
 ROOT_DIR=${SCRIPTPATH}/..
 # models

scripts/test_shape.sh

@@ -2,8 +2,8 @@ set -ex
 SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
 PROJ_ROOT="$SCRIPTPATH/../"
 GPU_IDS=${1}
-DATASET_MODE=${2} # voxel or df
-MODEL_NAME=${3} # model name
+DATASET_MODE=${2} # df | voxel
+MODEL_NAME=${3} # model's full name, not only the class name
 
 
 

scripts/test_texture.sh

@@ -1,8 +1,8 @@
 # misc
 set -ex
 GPU_IDS=${1}
-CLASS=${2}
-DATASET=${3}
+CLASS=${2}    # car | chair
+DATASET=${3}  # df | voxel
 
 # models
 SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"

scripts/train_full.sh

@@ -1,8 +1,8 @@
 set -ex
 
 GPU_IDS=${1}
-CLASS=${2}
-DATASET=${3}
+CLASS=${2}    # car | chair
+DATASET=${3}  # df | voxel
 DISPLAY_ID=${4}
 DATE=`date +%Y-%m-%d`
 
@@ -22,7 +22,6 @@ python train.py --gpu_ids ${GPU_IDS} \
   --checkpoints_dir ${CHECKPOINTS_DIR} \
   --model2D_dir ${MODEL2D_DIR} \
   --model3D_dir ${MODEL3D_DIR} \
-  --random_shift \
-  --color_jitter \
+  --random_shift --color_jitter \
   --lambda_GAN_3D 0.05 \
   --suffix {model}_{class_3d}_${DATASET}

scripts/train_shape.sh

@@ -1,8 +1,8 @@
 set -ex
 
 GPU_IDS=${1}
-CLASS=${2}  # car or chair
-DATASET=${3} # df or voxel
+CLASS=${2}  # car | chair
+DATASET=${3} # df | voxel
 DATE=`date +%Y-%m-%d`
 SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
 ROOT_DIR=${SCRIPTPATH}/..

scripts/train_stage2.sh

@@ -1,8 +1,8 @@
 set -ex
 
 GPU_IDS=${1}
-CLASS=${2}
-DATASET=${3}
+CLASS=${2}    # car | chair
+DATASET=${3}  # voxel | df
 DISPLAY_ID=${4}
 DATE=`date +%Y-%m-%d`
 SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"

scripts/train_stage2_real.sh

@@ -1,8 +1,8 @@
 set -ex
 
 GPU_IDS=${1}
-CLASS=${2}
-DATASET=${3}
+CLASS=${2}  # car | chair
+DATASET=${3} # df | voxel
 DISPLAY_ID=${4}
 DATE=`date +%Y-%m-%d`