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)
def main():
setup()
while True:
run_synthetic_benchmarks()
