def main(args): model_prefix = '{}_{}'.format(args.model_type, args.train_id) checkpoint_path = args.CHK_DIR + model_prefix + '/' result_path = args.RESULT_DIR + model_prefix + '/' cp_file = checkpoint_path + "best_model.pth.tar" if not os.path.exists(checkpoint_path): sys.exit('No checkpoint_path found {}'.format(checkpoint_path)) print('Loading model: {}'.format(model_prefix)) # set up vocab txt setup(args, clear=False) print(args.__dict__) # indicate src and tgt language src, tgt = 'en', 'zh' maps = {'en':args.TRAIN_VOCAB_EN, 'zh':args.TRAIN_VOCAB_ZH} vocab_src = read_vocab(maps[src]) tok_src = Tokenizer(language=src, vocab=vocab_src, encoding_length=args.MAX_INPUT_LENGTH) vocab_tgt = read_vocab(maps[tgt]) tok_tgt = Tokenizer(language=tgt, vocab=vocab_tgt, encoding_length=args.MAX_INPUT_LENGTH) print ('Vocab size src/tgt:{}/{}'.format( len(vocab_src), len(vocab_tgt)) ) # Setup the training, validation, and testing dataloaders train_loader, val_loader, test_loader = create_split_loaders(args.DATA_DIR,(tok_src, tok_tgt), args.batch_size, args.MAX_VID_LENGTH, (src, tgt), num_workers=4, pin_memory=True) print ('train/val/test size: {}/{}/{}'.format( len(train_loader), len(val_loader), len(test_loader) )) ## init model if args.model_type == 's2s': encoder = Encoder(vocab_size=len(vocab_src), embed_size=args.wordembed_dim, hidden_size=args.enc_hid_size).cuda() decoder = Decoder(embed_size=args.wordembed_dim, hidden_size=args.dec_hid_size, vocab_size=len(vocab_tgt)).cuda() ### load best model and eval print ('************ Start eval... ************') eval(test_loader, encoder, decoder, cp_file, tok_tgt, result_path)
def print_network(): opt = setup() generator = Generator(16, opt.upSampling) if opt.generatorWeights != '': generator.load_state_dict(torch.load(opt.generatorWeights)) discriminator = Discriminator() if opt.discriminatorWeights != '': discriminator.load_state_dict(torch.load(opt.discriminatorWeights)) feature_extractor = FeatureExtractor( torchvision.models.vgg19(pretrained=True)) printer('generator') summary(generator.cuda(), (3, 32, 32)) printer('discriminator') summary(discriminator.cuda(), (3, 32, 32)) printer('feature_extractor') summary(feature_extractor.cuda(), (3, 32, 32))
def __init__(self, dataset_info: DatasetInfo, unique_label: int, ds: DatasetWrapper, spectral_norm_warming_no_images: int = 50): """ Constructs PIONEER. This call is memory-intensive. :param dataset_info: DatasetInfo. :param unique_label: label of the data class for which WGAN is created. :param ds: DatasetWrapper. :param spectral_norm_warming_no_images: number of images for spectral norm warming. See GAN.warm_spectral_norms. """ super().__init__(128, 511, unique_label, ds) # Model names should end with the number of training iterations. Currently, # these numbers are hard-coded and correspond to very concrete models. if dataset_info == DatasetInfo.CelebA128Gender: pioneer_d = "celeba" save_dir = f"pioneer/CelebA-128-{self.subclass}" test_path = f"data/celeba/img_align_celeba_{self.subclass}" if self.subclass == "male": start_iteration = 22452000 elif self.subclass == "female": start_iteration = 20580000 else: raise RuntimeError() elif dataset_info == DatasetInfo.LSUN128: pioneer_d = "lsun" save_dir = f"pioneer/LSUN-128-{self.subclass}" test_path = f"data/LSUN/data/LSUN/{self.subclass}_train_lmdb" if self.subclass == "bedroom": start_iteration = 15268000 elif self.subclass == "church_outdoor": start_iteration = 20212000 else: raise RuntimeError() else: raise RuntimeError() model_filename = Path( save_dir) / "checkpoint" / f"{start_iteration}_state" if not os.path.isfile(model_filename): raise RuntimeError( f"PIONEER model file {model_filename} does not exist!") max_phase = int(np.round(np.log2(self.resolution))) - 2 # prepare command line arguments # in particular, disable random seed resetting with --manual_seed=-1 LogUtil.info("*** Loading PIONEER...") sys.argv = ( f"train.py -d {pioneer_d} --start_iteration {start_iteration} --save_dir {save_dir} " f"--test_path {test_path} --sample_N=256 --reconstructions_N=0 --interpolate_N=0 " f"--max_phase={max_phase} --testonly --no_TB --manual_seed=-1" ).split(" ") LogUtil.info(f"PIONEER's command line arguments: {sys.argv}") sys.path.append("./pioneer/src") # PIONEER imports import config self.config = reload(config) import evaluate self.evaluate = reload(evaluate) import model self.model = reload(model) import data self.data = reload(data) import utils self.utils = reload(utils) import train self.train = reload(train) # initialize PIONEER train.setup() self.session = train.Session() self.session.create() for model in (self.session.generator, self.session.encoder): model.eval() # disable computation of gradients that are not required Util.set_param_requires_grad(model, False) # "warm" spectral norms in the encoder LogUtil.info( f"*** Spectral norm warming with {spectral_norm_warming_no_images} images..." ) with torch.no_grad(): dataset = self.get_sampler() for i in range(spectral_norm_warming_no_images): self.encode_plain(next(dataset)[0])[0] LogUtil.info("*** Done!")
def upsampling(path, picture_name, upsampling): opt = setup() # image = Image.open(os.getcwd() + r'\images\\' + path) image = Image.open(path) opt.imageSize = (image.size[1], image.size[0]) log = '>>> process image : {} size : ({}, {}) sr_reconstruct size : ({}, {})'.format( picture_name, image.size[0], image.size[1], image.size[0] * upsampling, image.size[1] * upsampling) try: os.makedirs(os.getcwd() + r'\output\result') except OSError: pass if torch.cuda.is_available() and not opt.cuda: print( '[WARNING] : You have a CUDA device, so you should probably run with --cuda' ) transform = transforms.Compose([ transforms.RandomCrop(opt.imageSize), transforms.Pad(padding=0), transforms.ToTensor() ]) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # Equivalent to un-normalizing ImageNet (for correct visualization) unnormalize = transforms.Normalize(mean=[-2.118, -2.036, -1.804], std=[4.367, 4.464, 4.444]) scale = transforms.Compose([ transforms.ToPILImage(), transforms.Resize(opt.imageSize), transforms.Pad(padding=0), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) if opt.dataset == 'folder': # folder dataset dataset = datasets.ImageFolder(root=opt.dataroot, transform=transform) elif opt.dataset == 'cifar10': dataset = datasets.CIFAR10(root=opt.dataroot, download=True, train=False, transform=transform) elif opt.dataset == 'cifar100': dataset = datasets.CIFAR100(root=opt.dataroot, download=True, train=False, transform=transform) assert dataset dataloader = transforms.Compose([transforms.ToTensor()]) image = dataloader(image) # loading paras from networks generator = Generator(16, opt.upSampling) if opt.generatorWeights != '': generator.load_state_dict(torch.load(opt.generatorWeights)) discriminator = Discriminator() if opt.discriminatorWeights != '': discriminator.load_state_dict(torch.load(opt.discriminatorWeights)) # For the content loss feature_extractor = FeatureExtractor( torchvision.models.vgg19(pretrained=True)) content_criterion = nn.MSELoss() adversarial_criterion = nn.BCELoss() target_real = Variable(torch.ones(opt.batchSize, 1)) target_fake = Variable(torch.zeros(opt.batchSize, 1)) # if gpu is to be used if opt.cuda: generator.cuda() discriminator.cuda() feature_extractor.cuda() content_criterion.cuda() adversarial_criterion.cuda() target_real = target_real.cuda() target_fake = target_fake.cuda() low_res = torch.FloatTensor(opt.batchSize, 3, opt.imageSize[0], opt.imageSize[1]) # Set evaluation mode (not training) generator.eval() discriminator.eval() # Generate data high_res_real = image # Downsample images to low resolution low_res = scale(high_res_real) low_res = torch.tensor([np.array(low_res)]) high_res_real = normalize(high_res_real) high_res_real = torch.tensor([np.array(high_res_real)]) # Generate real and fake inputs if opt.cuda: high_res_real = Variable(high_res_real.cuda()) high_res_fake = generator(Variable(low_res).cuda()) else: high_res_real = Variable(high_res_real) high_res_fake = generator(Variable(low_res)) save_image(unnormalize(high_res_fake[0]), './output/result/' + picture_name) return log
type=str) parser.add_argument('-th', '--threshold', dest='threshold', default=0.5, type=float) args = parser.parse_args() save_dir = args.load_model.split('/') save_dir = '/'.join(save_dir[:-1]) save_dir += '/eval_fig' if not os.path.exists(save_dir): os.mkdir(save_dir) args.demo = False args.pre_train = True _, _, _, valloader = setup(args) use_cuda = torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") model = pix2vox().to(device) if use_cuda: state_dict = torch.load(args.load_model) else: state_dict = torch.load(args.load_model, map_location='cpu') model.load_state_dict(state_dict) model.eval() # Set in evaluation mode result = [] bar = tqdm(total=len(valloader), desc='Processing', ncols=90) yolo_criterion = build_yolo() lanemap_criterion = torch.nn.BCEWithLogitsLoss() for idx, (sample, target, road_image, extra) in enumerate(valloader): sample = torch.stack(sample)
import speaker from utils import read_vocab, write_vocab, build_vocab, Tokenizer, padding_idx, timeSince, read_img_features from env import R2RBatch from agent import Seq2SeqAgent from param import args from collections import OrderedDict from eval import Evaluation from train import setup from collections import defaultdict import numpy as np from matplotlib import pyplot as plt setup() args.angle_feat_size = 128 TRAIN_VOCAB = 'tasks/R2R/data/train_vocab.txt' TRAINVAL_VOCAB = 'tasks/R2R/data/trainval_vocab.txt' IMAGENET_FEATURES = 'img_features/ResNet-152-imagenet.tsv' PLACE365_FEATURES = 'img_features/ResNet-152-places365.tsv' features = IMAGENET_FEATURES vocab = read_vocab(TRAIN_VOCAB) tok = Tokenizer(vocab=vocab, encoding_length=80) feat_dict = read_img_features(features) train_env = R2RBatch(feat_dict, batch_size=64, splits=['train'], tokenizer=tok) log_dir = "snap/speaker/state_dict/best_val_seen_bleu" val_env_names = ['val_unseen', 'val_seen'] featurized_scans = set([key.split("_")[0] for key in list(feat_dict.keys())]) val_envs = OrderedDict(((split, (R2RBatch(feat_dict, batch_size=args.batchSize,
df.to_csv(join(model_dir, 'hyper_df.csv')) for k, v in grid_results_dict.items(): print(k) print(v) with open(join(model_dir, 'grid_search_results.pickle'), 'wb') as f: pickle.dump(grid_results_dict, f) del model, trainer, train_loader, loader, validators, best_model, best_results torch.cuda.empty_cache() gc.collect() time.sleep(3) return grid_results_dict, pd_results if __name__ == '__main__': Args, Logger, Model_dir = parse_args() Train_dataset, Datasets, Word_embs, Ent_embs, File_stores = setup(Args, Logger) result_dict, pd_dict = grid_search(word_embs=Word_embs, ent_embs=Ent_embs, model_dir=Model_dir, train_dataset=Train_dataset, datasets=Datasets, logger=Logger, args=Args, file_stores=File_stores) df = pd.DataFrame(pd_dict) df.to_csv(join(Model_dir, 'hyper_df.csv'))
def main(): setup() while True: run_real_benchmarks()
'--pre-train', dest='pre_train', type=str2bool, default='no') parser.add_argument('-dm', '--demo', dest='demo', type=str2bool, default='no') parser.add_argument('-det', '--detection', dest='det', type=str2bool, default='yes') parser.add_argument('-seg', '--segmentation', dest='seg', type=str2bool, default='yes') parser.add_argument('-ssl', '--ssl', dest='ssl', type=str2bool, default='no') parser.add_argument('-a', '--alpha', dest='alpha', type=float, default=2) parser.add_argument('-g', '--gamma', dest='gamma', type=float, default=1) args = parser.parse_args() if __name__ == '__main__': model, optimizer, trainloader, valloader = setup(args) if args.model_config == './config/yolov3_large.cfg': train_yolov3(model, optimizer, trainloader, valloader, args) elif args.model_config == './config/yolov3.cfg': train_yolov3_pass_6(model, optimizer, trainloader, valloader, args) elif args.model_config == 'pix2vox': train_pix2vox_yolo(model, optimizer, trainloader, valloader, args) elif args.model_config == 'center_net': train_center_net(model, optimizer, trainloader, valloader, args)
def main(): setup() while True: run_synthetic_benchmarks()
def down_and_up_sampling(image, save_name, upsampling): opt = setup() # create output folder try: os.makedirs('output/high_res_fake') os.makedirs('output/high_res_real') os.makedirs('output/low_res') except OSError: pass if torch.cuda.is_available() and not opt.cuda: print('[WARNING]: You have a CUDA device, so you should probably run with --cuda') transform = transforms.Compose([transforms.RandomCrop(( image.size[0], image.size[1])), transforms.Pad(padding = 0), transforms.ToTensor()]) normalize = transforms.Normalize(mean = [0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225]) # [down sampling] down-sampling part scale = transforms.Compose([transforms.ToPILImage(), transforms.Resize((int(image.size[1] / opt.upSampling), int(image.size[0] / opt.upSampling))), transforms.Pad(padding=0), transforms.ToTensor(), transforms.Normalize( mean = [0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])]) # Equivalent to un-normalizing ImageNet (for correct visualization) unnormalize = transforms.Normalize( mean = [-2.118, -2.036, -1.804], std = [4.367, 4.464, 4.444]) if opt.dataset == 'folder': # folder dataset dataset = datasets.ImageFolder(root = opt.dataroot, transform = transform) elif opt.dataset == 'cifar10': dataset = datasets.CIFAR10(root = opt.dataroot, download = True, train = False, transform = transform) elif opt.dataset == 'cifar100': dataset = datasets.CIFAR100(root = opt.dataroot, download = True, train = False, transform = transform) assert dataset dataloader = torch.utils.data.DataLoader(dataset, batch_size = opt.batchSize, shuffle = False, num_workers = int(opt.workers)) my_loader = transforms.Compose([transforms.ToTensor()]) image = my_loader(image) # [paras] loading paras from .pth files generator = Generator(16, opt.upSampling) if opt.generatorWeights != '': generator.load_state_dict(torch.load(opt.generatorWeights)) discriminator = Discriminator() if opt.discriminatorWeights != '': discriminator.load_state_dict(torch.load(opt.discriminatorWeights)) # For the content loss feature_extractor = FeatureExtractor(torchvision.models.vgg19(pretrained = True)) content_criterion = nn.MSELoss() adversarial_criterion = nn.BCELoss() target_real = Variable(torch.ones(opt.batchSize, 1)) target_fake = Variable(torch.zeros(opt.batchSize, 1)) # if gpu is to be used if opt.cuda: generator.cuda() discriminator.cuda() feature_extractor.cuda() content_criterion.cuda() adversarial_criterion.cuda() target_real = target_real.cuda() target_fake = target_fake.cuda() low_res = torch.FloatTensor(opt.batchSize, 3, opt.imageSize[0], opt.imageSize[1]) # print('Test started...') mean_generator_content_loss = 0.0 mean_generator_adversarial_loss = 0.0 mean_generator_total_loss = 0.0 mean_discriminator_loss = 0.0 # Set evaluation mode (not training) generator.eval() discriminator.eval() data = image for i in range(1): # Generate data high_res_real = data low_res = scale(high_res_real) low_res = torch.tensor([np.array(low_res)]) high_res_real = normalize(high_res_real) high_res_real = torch.tensor([np.array(high_res_real)]) # Generate real and fake inputs if opt.cuda: high_res_real = Variable(high_res_real.cuda()) high_res_fake = generator(Variable(low_res).cuda()) else: high_res_real = Variable(high_res_real) high_res_fake = generator(Variable(low_res)) # >>> create hr images save_image(unnormalize(high_res_real[0]), 'output/high_res_real/' + save_name) save_image(unnormalize(high_res_fake[0]), 'output/high_res_fake/' + save_name) save_image(unnormalize(low_res[0]), 'output/low_res/' + save_name)