def parse(self): if not self.initialized: self.initialize() self.opt = self.parser.parse_args() self.opt.isTrain = self.isTrain # train or test str_ids = self.opt.gpu_ids.split(',') self.opt.gpu_ids = [] for str_id in str_ids: id = int(str_id) if id >= 0: self.opt.gpu_ids.append(id) # set gpu ids if len(self.opt.gpu_ids) > 0: torch.cuda.set_device(self.opt.gpu_ids[0]) args = vars(self.opt) print('------------ Options -------------') for k, v in sorted(args.items()): print('%s: %s' % (str(k), str(v))) print('-------------- End ----------------') # save to the disk expr_dir = os.path.join(self.opt.checkpoints_dir, self.opt.name) util.mkdirs(expr_dir) file_name = os.path.join(expr_dir, 'opt.txt') with open(file_name, 'wt') as opt_file: opt_file.write('------------ Options -------------\n') for k, v in sorted(args.items()): opt_file.write('%s: %s\n' % (str(k), str(v))) opt_file.write('-------------- End ----------------\n') return self.opt
def parse(self): if not self.initialized: self.initialize() self.opt = self.parser.parse_args() self.opt.isTrain = self.isTrain # train or test str_ids = self.opt.gpu_ids.split(',') self.opt.gpu_ids = [] for str_id in str_ids: id = int(str_id) if id >= 0: self.opt.gpu_ids.append(id) args = dict((name, getattr(self.opt, name)) for name in dir(self.opt) if not name.startswith('_')) print('------------ Options -------------') for k, v in sorted(args.items()): print('%s: %s' % (str(k), str(v))) print('-------------- End ----------------') # save to the disk expr_dir = os.path.join(self.opt.checkpoints_dir, self.opt.name) util.mkdirs(expr_dir) file_name = os.path.join(expr_dir, 'opt.txt') with open(file_name, 'wt') as opt_file: opt_file.write('------------ Options -------------\n') for k, v in sorted(args.items()): opt_file.write('%s: %s\n' % (str(k), str(v))) opt_file.write('-------------- End ----------------\n') return self.opt
def print_options(self, opt): message = '' message += '----------------- Options ---------------\n' for k, v in sorted(vars(opt).items()): comment = '' default = self.parser.get_default(k) if v != default: comment = '\t[default: %s]' % str(default) message += '{:>25}: {:<30}{}\n'.format(str(k), str(v), comment) message += '----------------- End -------------------' print(message) # save to the disk expr_dir = os.path.join(opt.checkpoints_dir, opt.name) util.mkdirs(expr_dir) file_name = os.path.join(expr_dir, 'opt.txt') with open(file_name, 'wt') as opt_file: opt_file.write(message) opt_file.write('\n')
def parse(self): if not self.initialized: self.initialize() self.opt = self.parser.parse_args() self.opt.isTrain = self.isTrain # train or test args = vars(self.opt) print('------------ Options -------------') for k, v in sorted(args.items()): print('%s: %s' % (str(k), str(v))) print('-------------- End ----------------') # save to the disk expr_dir = os.path.join(self.opt.checkpoints_dir, self.opt.name) util.mkdirs(expr_dir) file_name = os.path.join(expr_dir, 'opt.txt') with open(file_name, 'wt') as opt_file: opt_file.write('------------ Options -------------\n') for k, v in sorted(args.items()): opt_file.write('%s: %s\n' % (str(k), str(v))) opt_file.write('-------------- End ----------------\n') return self.opt
from models.models import create_model import os import util.util as util from torch.autograd import Variable import torch.nn as nn opt = TrainOptions().parse() opt.nThreads = 1 opt.batchSize = 1 opt.serial_batches = True opt.no_flip = True opt.instance_feat = True name = 'features' save_path = os.path.join(opt.checkpoints_dir, opt.name) ############ Initialize ######### data_loader = CreateDataLoader(opt) dataset = data_loader.load_data() dataset_size = len(data_loader) model = create_model(opt) util.mkdirs(os.path.join(opt.dataroot, opt.phase + '_feat')) ######## Save precomputed feature maps for 1024p training ####### for i, data in enumerate(dataset): print('%d / %d images' % (i+1, dataset_size)) feat_map = model.module.netE.forward(Variable(data['image'].cuda(), volatile=True), data['inst'].cuda()) feat_map = nn.Upsample(scale_factor=2, mode='nearest')(feat_map) image_numpy = util.tensor2im(feat_map.data[0]) save_path = data['path'][0].replace('/train_label/', '/train_feat/') util.save_image(image_numpy, save_path)
def option_file_path(self, opt, makedir=False): expr_dir = os.path.join(opt.checkpoints_dir, opt.name) if makedir: util.mkdirs(expr_dir) file_name = os.path.join(expr_dir, 'opt') return file_name
import sys from util import util import numpy as np import argparse parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--in_path', type=str, default='/data/big/dataset/ILSVRC2012') parser.add_argument('--out_path', type=str, default='./dataset/ilsvrc2012/') opt = parser.parse_args() orig_path = opt.in_path print('Copying ILSVRC from...[%s]'%orig_path) # Copy over part of training set (for initializer) trn_small_path = os.path.join(opt.out_path,'train_small') util.mkdirs(opt.out_path) util.mkdirs(trn_small_path) train_subdirs = os.listdir(os.path.join(opt.in_path,'train')) for train_subdir in train_subdirs[:10]: os.symlink(os.path.join(opt.in_path,'train',train_subdir),os.path.join(trn_small_path,train_subdir)) print('Making small training set in...[%s]'%trn_small_path) # Copy over whole training set trn_path = os.path.join(opt.out_path,'train') util.mkdirs(opt.out_path) os.symlink(os.path.join(opt.in_path,'train'),trn_path) print('Making training set in...[%s]'%trn_path) # Copy over subset of ILSVRC12 val set for colorization val set val_path = os.path.join(opt.out_path,'val/imgs') util.mkdirs(val_path)
import util.util as util from torch.autograd import Variable import torch.nn as nn opt = TrainOptions().parse() opt.nThreads = 1 opt.batchSize = 1 opt.serial_batches = True opt.no_flip = True opt.instance_feat = True name = 'features' save_path = os.path.join(opt.checkpoints_dir, opt.name) ############ Initialize ######### data_loader = CreateDataLoader(opt) dataset = data_loader.load_data() dataset_size = len(data_loader) model = create_model(opt) util.mkdirs(os.path.join(opt.dataroot, opt.phase + '_feat')) # Save precomputed feature maps for 1024p training # for i, data in enumerate(dataset): print('%d / %d images' % (i + 1, dataset_size)) feat_map = model.module.netE.forward( Variable(data['image'].cuda(), volatile=True), data['inst'].cuda()) feat_map = nn.Upsample(scale_factor=2, mode='nearest')(feat_map) image_numpy = util.tensor2im(feat_map.data[0]) save_path = data['path'][0].replace('/train_label/', '/train_feat/') util.save_image(image_numpy, save_path)
cv2.imwrite((output_path + "/images/image%d.tif" % index), src_roi) cv2.imwrite((output_path + "/labels/label%d.tif" % index), label_roi) index += 1 def change_label(label_dir): image_paths = os.listdir(label_dir) for path_item in tqdm(image_paths): label = m.open(label_dir + "/" + path_item).convert("L") # change 255 to 1 im_point = label.point(lambda x: x // 255) im_point.save(label_dir + "/" + path_item, 'tif') if __name__ == "__main__": # create the paths of created datasets util.mkdirs(['./mass_inria/trainA/images', './mass_inria/trainA/labels', './mass_inria/trainB/images', './mass_inria/trainB/labels']) mass_output_path = "./mass_inria/trainA" createSetsA(mass_images_path, mass_labels_path, mass_image_size, mass_output_path) inria_output_path_train = "./mass_inria/trainB" createSetsB(inria_images_path_train, inria_labels_path_train, inria_image_size, inria_output_path_train) trainA_label_dir = "./mass_inria/trainA/labels" change_label(trainA_label_dir) trainB_label_dir = "./mass_inria/trainB/labels" change_label(trainB_label_dir)
import torchvision.utils as vutils from util import util opt = TestOptions().parse() opt.nThreads = 1 opt.batchSize = 1 opt.serial_batches = True opt.no_flip = True data_loader = CreateDataLoader(opt) dataset = data_loader.load_data() model = create_model(opt) opt.is_psnr = True summary_dir = os.path.join(opt.results_dir, 'result') util.mkdirs([summary_dir]) for i, data in enumerate(dataset): if i >= opt.how_many: break model.set_input(data) model.test() print('\nimage: ', i, '/', len(dataset)) visuals = model.get_current_visuals() print('%04d: process image... ' % (i)) for key, val in visuals.items(): vutils.save_image(val, '{}/{}_{}.png'.format(summary_dir, i, key), nrow=1,
start_row = row * image_size end_row = start_row + image_size for colom in range(8): start_colom = colom * image_size end_colom = start_colom + image_size src_roi = image[start_colom: end_colom, start_row: end_row, :] label_roi = label[start_colom: end_colom, start_row: end_row, :] # 切割图像然后保存 cv2.imwrite((output_path + "/images/image%d.tif" % index), src_roi) cv2.imwrite((output_path + "/labels/label%d.tif" % index), label_roi) index += 1 def change_B_label(label_dir): image_paths = os.listdir(label_dir) for path_item in tqdm(image_paths): label = m.open(label_dir + "/" + path_item).convert("L") # change 255 to 1 im_point = label.point(lambda x: x // 255) im_point.save(label_dir + "/" + path_item, 'tif') if __name__ == "__main__": util.mkdirs(['./mass_inria/valB/images', './mass_inria/valB/labels']) inria_output_path_val = "./mass_inria/valB" createSets(inria_images_path_val, inria_labels_path_val, inria_image_size_val, inria_output_path_val) valB_label_dir = "./mass_inria/valB/labels" change_B_label(valB_label_dir)
elif host in [ 'danbury', 'denton', 'elkin', 'elkpark', 'dublin', 'dobson', 'eureka', 'erwin', 'enfield', 'elmcity' ]: opt.checkpoints_dir = '/data/zhenghan/checkpoints' else: raise ValueError( "cannot decide checkpoints_dir, server '%s' not recognized." % host) args = vars(opt) print('------------ Options -------------') for k, v in sorted(args.items()): print('%s: %s' % (str(k), str(v))) print('-------------- End ----------------') expr_dir = os.path.join(opt.checkpoints_dir, opt.name) util.mkdirs(expr_dir) opt.file_name = os.path.join(expr_dir, 'log.txt') with open(opt.file_name, 'wt') as log_file: log_file.write('------------ Options -------------\n') for k, v in sorted(args.items()): log_file.write('%s: %s\n' % (str(k), str(v))) log_file.write('-------------- End ----------------\n') Model = getModel(opt) model = Model() ''' model.initialize(opt) print("model [%s] was created" % (model.name())) ''' MRFDataset = getDataset(opt)
def batch_generation_from_update(batch_size, save_path, fname_list, features_mat, checkpoints_dir, classname, black=True): ''' Generate decoded segmentation map from input features Args: batch_size (int), batch size for the VAE to take in save_path (str), save generated masks to path fname_list (list of str), save generated masks with fname features_mat (numpy array): input features to be decoded, in the order of fname_list checkpoints_dir (str), load VAE weights from path classname (str), label taxonomy defined by dataset with classname black (boolean), black is True for regular generation; black is False for debugging, thus the generated mask is not in the format for cGAN input ''' # Create and load model weights in vae_opt = initialize_option(classname) vae_opt.batchSize = batch_size vae_opt.checkpoints_dir = checkpoints_dir vae_util.mkdirs(save_path) if vae_opt.share_decoder and vae_opt.share_encoder: if vae_opt.separate_clothing_unrelated: from models.separate_clothing_encoder_models import create_model as vae_create_model else: print('Only supports separating clothing and clothing-irrelevant') raise NotImplementedError else: print('Only supports sharing encoder and decoder among all parts') raise NotImplementedError model = vae_create_model(vae_opt) # Forward input into the model dataset_size = len(fname_list) num_batch = int(dataset_size / batch_size) elem_in_last_batch = dataset_size % batch_size for i in range(num_batch): generated = model.generate_from_random( torch.Tensor(features_mat[i * batch_size:(i + 1) * batch_size, :]).cuda()) for j in range(batch_size): if black: vae_util.save_image( vae_util.tensor2label_black(generated.data[j], vae_opt.output_nc, normalize=True), os.path.join(save_path, '%s.png' % (fname_list[i * batch_size + j]))) else: vae_util.save_image( vae_util.tensor2label(generated.data[j], vae_opt.output_nc, normalize=True), os.path.join(save_path, '%s.png' % (fname_list[i * batch_size + j]))) # Remaining instance in the last batch needs to be generated here if elem_in_last_batch > 0: generated = model.generate_from_random( torch.Tensor(features_mat[-elem_in_last_batch:, :]).cuda()) for j in range(elem_in_last_batch): if black: vae_util.save_image( vae_util.tensor2label_black(generated.data[j], vae_opt.output_nc, normalize=True), os.path.join( save_path, '%s.png' % (fname_list[-elem_in_last_batch + j]))) else: vae_util.save_image( vae_util.tensor2label(generated.data[j], vae_opt.output_nc, normalize=True), os.path.join( save_path, '%s.png' % (fname_list[-elem_in_last_batch + j])))
if h == 0: h = base if w == 0: w = base if (h == oh) and (w == ow): return img return img.resize((w, h), method) model, num_params_G, num_params_D = create_model(opt) model.eval() rlt_dir = os.path.join(opt.results_dir, 'test') util.mkdirs([rlt_dir]) transform_list = [] transform_list += [transforms.ToTensor()] mskimg_transform = transforms.Compose(transform_list) transform_list = [] transform_list += [transforms.ToTensor()] msk_transform = transforms.Compose(transform_list) transform_list = [] transform_list += [transforms.ToTensor()] seg_transform = transforms.Compose(transform_list) start_time = time.time() for i, data in enumerate(dataset): with torch.no_grad(): msk_img_path = data['path_mskimg'][0]
from util.visualizer import Visualizer from util.visualizer import save_segment_result from util.metrics import RunningScore from util import util import time import os import numpy as np if __name__ == '__main__': # 加载设置 opt = TrainOptions().parse() # 设置显示验证结果存储的设置 web_dir = os.path.join(opt.checkpoints_dir, opt.name, 'val') image_dir = os.path.join(web_dir, 'images') util.mkdirs([web_dir, image_dir]) # 加载数据集 dataset_train = create_dataset(opt) dataset_train_size = len(dataset_train) print('The number of training images = %d' % dataset_train_size) # 改变phase参数然后获取验证集 opt.phase = "val" dataset_val = create_dataset(opt) dataset_val_size = len(dataset_val) print('The number of valling images = %d' % dataset_val_size) # 创建模型 model = create_model(opt)
from util import util import numpy as np import argparse parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--in_path', type=str, default='/data/big/dataset/') parser.add_argument('--out_path', type=str, default='../datasets/Place/') opt = parser.parse_args() orig_path = '/home/pzh/Place/places365_small/train' print('Copying ILSVRC from...[%s]' % orig_path) # Copy over part of training set (for initializer) trn_small_path = os.path.join(opt.out_path, 'train_small') util.mkdirs(opt.out_path) util.mkdirs(trn_small_path) train_subdirs = os.listdir(os.path.join(opt.in_path, 'train')) for train_subdir in train_subdirs[:5]: os.symlink(os.path.join(opt.in_path, 'train', train_subdir), os.path.join(trn_small_path, train_subdir)) print('Making small training set in...[%s]' % trn_small_path) # Copy over whole training set trn_path = os.path.join(opt.out_path, 'train') util.mkdirs(opt.out_path) os.symlink(os.path.join(opt.in_path, 'train'), trn_path) print('Making training set in...[%s]' % trn_path) ''' # Copy over subset of ILSVRC12 val set for colorization val set val_path = os.path.join(opt.out_path, 'val/imgs')
def parse(self): if not self.initialized: self.initialize() self.opt = self.parser.parse_args() self.opt.isTrain = self.isTrain # train or test ''' str_ids = self.opt.gpu_ids.split(',') self.opt.gpu_ids = [] for str_id in str_ids: id = int(str_id) if id >= 0: self.opt.gpu_ids.append(id) # set gpu ids if len(self.opt.gpu_ids) > 0: torch.cuda.set_device(self.opt.gpu_ids[0]) ''' if not self.opt.onMAC: host = subprocess.check_output('hostname').decode('utf-8')[:-1] if host == 'stilson' or host == 'andrew' or host == 'wiggin': self.opt.checkpoints_dir = '/raid/zhenghan/checkpoints' elif host == 'badin' or host == 'bogue' or host == 'burgaw': self.opt.checkpoints_dir = '/shenlab/local/zhenghan/checkpoints' else: raise ValueError( "cannot decide checkpoints_dir, server '%s' not recognized." % host) # if data is loaded on GPU, nThreads should be 0 and gpu_ids must not be [] if self.opt.data_GPU: self.opt.nThreads = 0 # assert len(self.opt.gpu_ids) > 0, "set data_GPU as true but gpu_ids is []" if self.opt.goal_type == 'T1&T2': assert self.opt.output_nc == 2 if self.opt.which_model_netG == 'simple_conv_small_PCA': self.opt.PCA = True args = vars(self.opt) print('------------ Options -------------') for k, v in sorted(args.items()): print('%s: %s' % (str(k), str(v))) print('-------------- End ----------------') # save to the disk if self.isTrain: expr_dir = os.path.join(self.opt.checkpoints_dir, self.opt.name) else: expr_dir = os.path.join(self.opt.results_dir, self.opt.name) util.mkdirs(expr_dir) file_name = os.path.join(expr_dir, 'opt_' + self.opt.phase + '.txt') with open(file_name, 'wt') as opt_file: opt_file.write('------------ Options -------------\n') for k, v in sorted(args.items()): opt_file.write('%s: %s\n' % (str(k), str(v))) opt_file.write('-------------- End ----------------\n') return self.opt