def load_model(self):
if len(glob.glob(os.path.join(args.save_dir, args.corpus) + '-selector-*.pth')) == 0:
return
if args.load_iter is None:
f_list = glob.glob(os.path.join(args.save_dir, args.corpus) + '-selector-*.pth')
iter_list = [int(i.split('-')[-1].split('.')[0]) for i in f_list]
start_iter = sorted(iter_list)[-1]
else:
start_iter = args.load_iter
name = args.corpus + '-selector-{}.pth'.format(start_iter)
model_file_path = os.path.join(args.save_dir, name)
print("loading model", model_file_path)
if opt.device == torch.device('cuda'):
state = torch.load(model_file_path)
else:
state = torch.load(model_file_path, map_location=opt.device)
self._epoch = state['epoch']
self._iter = state['iter']
self.running_avg_loss = state['current_loss']
self.min_loss = state['min_loss']
self.model.sentence_selector.load_state_dict(state['selector_state_dict'])
if not args.is_coverage:
self.optimizer.load_state_dict(state['optimizer'])
if opt.device == torch.device('cuda'):
for state in list(self.optimizer.state.values()):
for k, v in list(state.items()):
if torch.is_tensor(v):
state[k] = v.cuda()
def load(self, filename, legacy=False, ignore_d=False):
"""
ignore_d: if `True`, then don't load in the
discriminator.
"""
if not self.use_cuda:
map_location = lambda storage, loc: storage
else:
map_location = None
if legacy:
g, d = torch.load(filename,
map_location=map_location)
self.g.load_state_dict(g)
if not ignore_d:
self.d.load_state_dict(d)
else:
dd = torch.load(filename,
map_location=map_location)
self.g.load_state_dict(dd['g'])
if not ignore_d:
self.d.load_state_dict(dd['d'])
for key in self.optim:
if ignore_d and key == 'd':
continue
self.optim[key].load_state_dict(dd['optim_'+key])
self.last_epoch = dd['epoch']
def generate(**kwargs):
"""
随机生成动漫头像，并根据netd的分数选择较好的
"""
for k_, v_ in kwargs.items():
setattr(opt, k_, v_)
device=t.device('cuda') if opt.gpu else t.device('cpu')
netg, netd = NetG(opt).eval(), NetD(opt).eval()
noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std)
noises = noises.to(device)
map_location = lambda storage, loc: storage
netd.load_state_dict(t.load(opt.netd_path, map_location=map_location))
netg.load_state_dict(t.load(opt.netg_path, map_location=map_location))
netd.to(device)
netg.to(device)
# 生成图片，并计算图片在判别器的分数
fake_img = netg(noises)
scores = netd(fake_img).detach()
# 挑选最好的某几张
indexs = scores.topk(opt.gen_num)[1]
result = []
for ii in indexs:
result.append(fake_img.data[ii])
# 保存图片
tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def _load(checkpoint_path):
if use_cuda:
checkpoint = torch.load(checkpoint_path)
else:
checkpoint = torch.load(checkpoint_path,
map_location=lambda storage, loc: storage)
return checkpoint
def load_checkpoint(checkpoint):
if torch.cuda.is_available():
checkpoint = torch.load(checkpoint)
else:
checkpoint = torch.load(checkpoint, map_location=lambda storage, loc: storage)
return checkpoint
def __init__(self,
root, mnist_root="data",
train=True,
transform=None, target_transform=None,
download=False):
"""Init MNIST-M dataset."""
super(MNISTM, self).__init__()
self.root = os.path.expanduser(root)
self.mnist_root = os.path.expanduser(mnist_root)
self.transform = transform
self.target_transform = target_transform
self.train = train # training set or test set
if download:
self.download()
if not self._check_exists():
raise RuntimeError('Dataset not found.' +
' You can use download=True to download it')
if self.train:
self.train_data, self.train_labels = \
torch.load(os.path.join(self.root,
self.processed_folder,
self.training_file))
else:
self.test_data, self.test_labels = \
torch.load(os.path.join(self.root,
self.processed_folder,
self.test_file))
def get_pretrained_net(name):
"""Loads pretrained network"""
if name == 'alexnet_caffe':
if not os.path.exists('alexnet-torch_py3.pth'):
print('Downloading AlexNet')
os.system('wget -O alexnet-torch_py3.pth --no-check-certificate -nc https://box.skoltech.ru/index.php/s/77xSWvrDN0CiQtK/download')
return torch.load('alexnet-torch_py3.pth')
elif name == 'vgg19_caffe':
if not os.path.exists('vgg19-caffe-py3.pth'):
print('Downloading VGG-19')
os.system('wget -O vgg19-caffe-py3.pth --no-check-certificate -nc https://box.skoltech.ru/index.php/s/HPcOFQTjXxbmp4X/download')
vgg = get_vgg19_caffe()
return vgg
elif name == 'vgg16_caffe':
if not os.path.exists('vgg16-caffe-py3.pth'):
print('Downloading VGG-16')
os.system('wget -O vgg16-caffe-py3.pth --no-check-certificate -nc https://box.skoltech.ru/index.php/s/TUZ62HnPKWdxyLr/download')
vgg = get_vgg16_caffe()
return vgg
elif name == 'vgg19_pytorch_modified':
# os.system('wget -O data/feature_inversion/vgg19-caffe.pth --no-check-certificate -nc https://www.dropbox.com/s/xlbdo688dy4keyk/vgg19-caffe.pth?dl=1')
model = VGGModified(vgg19(pretrained=False), 0.2)
model.load_state_dict(torch.load('vgg_pytorch_modified.pkl')['state_dict'])
return model
else:
assert False
def run(args, run_args, rank=0, world_size=1):
set_seed(args, rank=rank)
logger = initialize_logger(args, rank)
field, train_sets, val_sets, save_dict = run_args
logger.start = time.time()
logger.info(f'Preparing iterators')
train_iters = [(name, to_iter(args, world_size, tok, x, token_testing=args.token_testing))
for name, x, tok in zip(args.train_tasks, train_sets, args.train_batch_tokens)]
val_iters = [(name, to_iter(args, world_size, tok, x, train=False, token_testing=args.token_testing, sort=False if 'sql' in name else None))
for name, x, tok in zip(args.val_tasks, val_sets, args.val_batch_size)]
logger.info(f'Initializing Writer')
writer = SummaryWriter(log_dir=args.log_dir)
model = init_model(args, field, logger, world_size)
opt = init_opt(args, model)
start_iteration = 1
if save_dict is not None:
logger.info(f'Loading model from {os.path.join(args.save, args.load)}')
save_dict = torch.load(os.path.join(args.save, args.load))
model.load_state_dict(save_dict['model_state_dict'])
if args.resume:
logger.info(f'Resuming Training from {os.path.splitext(args.load)[0]}_rank_{rank}_optim.pth')
opt.load_state_dict(torch.load(os.path.join(args.save, f'{os.path.splitext(args.load)[0]}_rank_{rank}_optim.pth')))
start_iteration = int(os.path.splitext(os.path.basename(args.load))[0].split('_')[1])
logger.info(f'Begin Training')
train(args, model, opt, train_iters, args.train_iterations, field, val_iters=val_iters,
rank=rank, world_size=world_size,
log_every=args.log_every, val_every=args.val_every, rounds=len(train_iters)>1,
writer=writer if rank==0 else None, save_every=args.save_every, start_iteration=start_iteration)
def get_vanilla_vgg_features(cut_idx=-1):
if not os.path.exists('vgg_features.pth'):
os.system(
'wget --no-check-certificate -N https://s3-us-west-2.amazonaws.com/jcjohns-models/vgg19-d01eb7cb.pth')
vgg_weights = torch.load('vgg19-d01eb7cb.pth')
# fix compatibility issues
map = {'classifier.6.weight':u'classifier.7.weight', 'classifier.6.bias':u'classifier.7.bias'}
vgg_weights = OrderedDict([(map[k] if k in map else k,v) for k,v in vgg_weights.iteritems()])
model = models.vgg19()
model.classifier = nn.Sequential(View(), *model.classifier._modules.values())
model.load_state_dict(vgg_weights)
torch.save(model.features, 'vgg_features.pth')
torch.save(model.classifier, 'vgg_classifier.pth')
vgg = torch.load('vgg_features.pth')
if cut_idx > 36:
vgg_classifier = torch.load('vgg_classifier.pth')
vgg = nn.Sequential(*(vgg._modules.values() + vgg_classifier._modules.values()))
vgg.eval()
return vgg
def restore_model(self, resume_iters):
"""Restore the trained generator and discriminator."""
print('Loading the trained models from step {}...'.format(resume_iters))
G_path = os.path.join(self.model_save_dir, '{}-G.ckpt'.format(resume_iters))
D_path = os.path.join(self.model_save_dir, '{}-D.ckpt'.format(resume_iters))
self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))
self.D.load_state_dict(torch.load(D_path, map_location=lambda storage, loc: storage))
def load_network_stageI(self):
from model import STAGE1_G, STAGE1_D
netG = STAGE1_G()
netG.apply(weights_init)
print(netG)
netD = STAGE1_D()
netD.apply(weights_init)
print(netD)
if cfg.NET_G != '':
state_dict = \
torch.load(cfg.NET_G,
map_location=lambda storage, loc: storage)
netG.load_state_dict(state_dict)
print('Load from: ', cfg.NET_G)
if cfg.NET_D != '':
state_dict = \
torch.load(cfg.NET_D,
map_location=lambda storage, loc: storage)
netD.load_state_dict(state_dict)
print('Load from: ', cfg.NET_D)
if cfg.CUDA:
netG.cuda()
netD.cuda()
return netG, netD
def load_models(load_path):
model_args = json.load(open("{}/args.json".format(load_path), "r"))
word2idx = json.load(open("{}/vocab.json".format(load_path), "r"))
idx2word = {v: k for k, v in word2idx.items()}
autoencoder = Seq2Seq(emsize=model_args['emsize'],
nhidden=model_args['nhidden'],
ntokens=model_args['ntokens'],
nlayers=model_args['nlayers'],
hidden_init=model_args['hidden_init'])
gan_gen = MLP_G(ninput=model_args['z_size'],
noutput=model_args['nhidden'],
layers=model_args['arch_g'])
gan_disc = MLP_D(ninput=model_args['nhidden'],
noutput=1,
layers=model_args['arch_d'])
print('Loading models from'+load_path)
ae_path = os.path.join(load_path, "autoencoder_model.pt")
gen_path = os.path.join(load_path, "gan_gen_model.pt")
disc_path = os.path.join(load_path, "gan_disc_model.pt")
autoencoder.load_state_dict(torch.load(ae_path))
gan_gen.load_state_dict(torch.load(gen_path))
gan_disc.load_state_dict(torch.load(disc_path))
return model_args, idx2word, autoencoder, gan_gen, gan_disc
def init_model(word2id, opt):
model = Seq2SeqLSTMAttention(
emb_dim=opt.word_vec_size,
vocab_size=opt.vocab_size,
src_hidden_dim=opt.rnn_size,
trg_hidden_dim=opt.rnn_size,
ctx_hidden_dim=opt.rnn_size,
attention_mode='dot',
batch_size=opt.batch_size,
bidirectional=opt.bidirectional,
pad_token_src = word2id[pykp.io.PAD_WORD],
pad_token_trg = word2id[pykp.io.PAD_WORD],
nlayers_src=opt.enc_layers,
nlayers_trg=opt.dec_layers,
dropout=opt.dropout,
teacher_forcing_ratio=opt.teacher_forcing_ratio,
scheduled_sampling=opt.scheduled_sampling,
scheduled_sampling_batches=opt.scheduled_sampling_batches
)
logging.info('====================== Model Parameters =========================')
if opt.train_from:
logging.info("loading previous checkpoint from %s" % opt.train_from)
if torch.cuda.is_available():
model.load_state_dict(torch.load(open(opt.train_from, 'rb')))
else:
model.load_state_dict(torch.load(
open(opt.train_from, 'rb'), map_location=lambda storage, loc: storage
))
utils.tally_parameters(model)
return model
def demo(data, save, depth=40, growth_rate=12, batch_size=256):
"""
Applies temperature scaling to a trained model.
Takes a pretrained DenseNet-CIFAR100 model, and a validation set
(parameterized by indices on train set).
Applies temperature scaling, and saves a temperature scaled version.
NB: the "save" parameter references a DIRECTORY, not a file.
In that directory, there should be two files:
- model.pth (model state dict)
- valid_indices.pth (a list of indices corresponding to the validation set).
data (str) - path to directory where data should be loaded from/downloaded
save (str) - directory with necessary files (see above)
"""
# Load model state dict
model_filename = os.path.join(save, 'model.pth')
if not os.path.exists(model_filename):
raise RuntimeError('Cannot find file %s to load' % model_filename)
state_dict = torch.load(model_filename)
# Load validation indices
valid_indices_filename = os.path.join(save, 'valid_indices.pth')
if not os.path.exists(valid_indices_filename):
raise RuntimeError('Cannot find file %s to load' % valid_indices_filename)
valid_indices = torch.load(valid_indices_filename)
# Regenerate validation set loader
mean = [0.5071, 0.4867, 0.4408]
stdv = [0.2675, 0.2565, 0.2761]
test_transforms = tv.transforms.Compose([
tv.transforms.ToTensor(),
tv.transforms.Normalize(mean=mean, std=stdv),
])
valid_set = tv.datasets.CIFAR100(data, train=True, transform=test_transforms, download=True)
valid_loader = torch.utils.data.DataLoader(valid_set, pin_memory=True, batch_size=batch_size,
sampler=SubsetRandomSampler(valid_indices))
# Load original model
if (depth - 4) % 3:
raise Exception('Invalid depth')
block_config = [(depth - 4) // 6 for _ in range(3)]
orig_model = DenseNetEfficientMulti(
growth_rate=growth_rate,
block_config=block_config,
num_classes=100
).cuda()
orig_model.load_state_dict(state_dict)
# Now we're going to wrap the model with a decorator that adds temperature scaling
model = ModelWithTemperature(orig_model)
# Tune the model temperature, and save the results
model.set_temperature(valid_loader)
model_filename = os.path.join(save, 'model_with_temperature.pth')
torch.save(model.state_dict(), model_filename)
print('Temperature scaled model sved to %s' % model_filename)
print('Done!')
def main_test():
img_net, text_net = torch.load('img_net.pt'), torch.load('text_net.pt')
tiidlst = [l.strip() for l in file('test_ids.txt')]
img_dir = '/home/datasets/coco/raw/vgg19_feat/val/'
text_dir = '/home/datasets/coco/raw/annotation_text/hglmm_pca_npy/val/'
img_feat_dataset = COCOImgFeatDataset(tiidlst, img_dir)
text_feat_dataset = COCOTextFeatDataset(tiidlst,text_dir)
test(tiidlst,img_feat_dataset,text_feat_dataset,img_net,text_net)
def __init__(self, file, labelFile):
self.train = torch.load(file)
self.label = torch.load(labelFile)
self.len = len(self.train) # get how many data points.
for i in range(0, self.len): # transform the imgs.
self.train[i] = transforms.Normalize((0.1307,), (0.3081,))(
self.train[i].view(1, -1)) # do a small transformation
self.train = self.train.view(-1, 1, 28, 28)
def load_train_valid_data(opt):
logging.info("Loading train and validate data from '%s'" % opt.data)
logging.info("Loading train/valid from disk: %s" % (opt.data))
data_dict = torch.load(opt.data, 'wb')
train_src = np.asarray([d['src'] for d in data_dict['train']])
train_trg = np.asarray([d['trg'] for d in data_dict['train']])
valid_src = np.asarray([d['src'] for d in data_dict['valid']])
valid_trg = np.asarray([d['trg'] for d in data_dict['valid']])
word2id, id2word, vocab = torch.load(opt.vocab, 'wb')
# training_data_loader = DataLoader(dataset=list(zip(train_src, train_trg)), num_workers=opt.batch_workers, batch_size=opt.batch_size, shuffle=True)
# validation_data_loader = DataLoader(dataset=list(zip(valid_src, valid_trg)), num_workers=opt.batch_workers, batch_size=opt.batch_size, shuffle=True)
src_field = torchtext.data.Field(
use_vocab = False,
init_token=word2id[pykp.io.BOS_WORD],
eos_token=word2id[pykp.io.EOS_WORD],
pad_token=word2id[pykp.io.PAD_WORD],
batch_first = True
)
trg_field = torchtext.data.Field(
use_vocab = False,
init_token=word2id[pykp.io.BOS_WORD],
eos_token=word2id[pykp.io.EOS_WORD],
pad_token=word2id[pykp.io.PAD_WORD],
batch_first=True
)
train = KeyphraseDatasetTorchText(list(zip(train_src, train_trg)), [('src', src_field), ('trg', trg_field)])
valid = KeyphraseDatasetTorchText(list(zip(valid_src, valid_trg)), [('src', src_field), ('trg', trg_field)])
if torch.cuda.is_available():
device = opt.gpuid
else:
device = -1
# training_data_loader = torchtext.data.BucketIterator(dataset=train, batch_size=opt.batch_size, train=True, repeat=True, shuffle=True, sort=False, device=device)
if torch.cuda.is_available():
training_data_loader = torchtext.data.BucketIterator(dataset=train, batch_size=opt.batch_size, train=True, shuffle=True, repeat=False, sort=True, device = None)
validation_data_loader = torchtext.data.BucketIterator(dataset=valid, batch_size=opt.batch_size, train=False, shuffle=False, repeat=False, sort=False, device = None)
else:
training_data_loader = torchtext.data.BucketIterator(dataset=train, batch_size=opt.batch_size, train=True, shuffle=True, repeat=False, sort=True, device = -1)
validation_data_loader = torchtext.data.BucketIterator(dataset=valid, batch_size=opt.batch_size, train=False, shuffle=False, repeat=False, sort=False, device = -1)
opt.word2id = word2id
opt.id2word = id2word
opt.vocab = vocab
logging.info('====================== Dataset =========================')
logging.info('#(training data pairs)=%d' % len(training_data_loader.dataset))
logging.info('#(validation data pairs)=%d' % len(validation_data_loader.dataset))
logging.info('#(vocab)=%d' % len(vocab))
logging.info('#(vocab used)=%d' % opt.vocab_size)
return training_data_loader, validation_data_loader, word2id, id2word, vocab
def setup(args, inject_train=None, inject_dev=None, inject_test=None):
torch.cuda.set_device(args.gpu)
### setup data
TEXT = data.Field()
LABEL = data.Field(sequential=False)
train_set, dev_set, test_set = datasets.SST.splits(
TEXT, LABEL, fine_grained=False, train_subtrees=True,
filter_pred=lambda x: x.label != 'neutral')
### inject special place holders to the datasets
if inject_train is not None:
train_set = inject_train(train_set)
if inject_dev is not None:
dev_set = inject_dev(dev_set)
if inject_test is not None:
test_set = inject_test(test_set)
TEXT.build_vocab(train_set)
LABEL.build_vocab(train_set)
train_iter, dev_iter, test_iter = data.BucketIterator.splits(
(train_set, dev_set, test_set),
batch_size=args.batch_size, device=args.gpu)
# load word vectors
if args.wv_type:
if os.path.isfile(args.wv_cache):
TEXT.vocab.vectors = torch.load(args.wv_cache)
else:
TEXT.vocab.load_vectors(wv_dir=args.data_cache,
wv_type=args.wv_type, wv_dim=args.embed_size)
makedirs(os.path.dirname(args.wv_cache))
torch.save(TEXT.vocab.vectors, args.wv_cache)
args.vocab_size = len(TEXT.vocab)
args.embed_size = TEXT.vocab.vectors.size(1)
args.output_size = len(LABEL.vocab)
print('vocab size', args.vocab_size)
print('embed size', args.embed_size)
print('output size', args.output_size)
### setup model
if args.resume_snapshot:
print('loading snapshot', args.resume_snapshot)
model = torch.load(args.resume_snapshot,
map_location=lambda storage, location: storage.cuda(args.gpu))
else:
model = globals()[args.model_class](args)
if args.wv_type:
model.embed.weight.data = TEXT.vocab.vectors
if args.gpu >= 0:
model.cuda()
return args, TEXT, LABEL, train_iter, dev_iter, test_iter, model
def get_outputs(image_dir, filename):
models_name = ['resnet152', 'vgg19_bn', 'densenet161', 'nasnetalarge']
res = {}
res_labels = {}
for name in models_name:
if name == 'densenet161':
model_ft = torch.load('model_pretrained_densenet161.pkl')
elif name == 'resnet152':
model_ft = torch.load('model_pretrained_resnet152.pkl')
elif name == 'vgg19_bn':
model_ft = torch.load('model_pretrained_vgg19.pkl')
data_transforms = transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])])
if name == 'nasnetalarge':
model_ft = pretrainedmodels.nasnetalarge(num_classes=1000, pretrained='imagenet')
data_transforms = transforms.Compose([
transforms.Scale(377),
transforms.CenterCrop(331),
transforms.ToTensor(),
transforms.Normalize(mean=model_ft.mean,
std=model_ft.std)])
model_ft = torch.load('model_pretrained_nasnet.pkl')
use_gpu = torch.cuda.is_available()
model_ft.eval()
test_dataset = TestData(image_dir, data_transforms)
test_dataloader = DataLoader(test_dataset, batch_size=4, shuffle=False, num_workers=4)
since = time.time()
temp = []
temp_list = []
for i, batch in enumerate(test_dataloader):
inputs, cid = batch
temp_list.append(cid)
if use_gpu:
inputs = Variable(inputs.cuda())
else:
inputs = Variable(inputs)
outputs = model_ft(inputs)
temp.append(softmax(outputs.data.cpu().numpy()))
if i % 200 == 199:
print('iter:{}'.format(i+1))
time_elapsed = time.time() - since
print('Testing complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
res[name] = np.concatenate(temp)
res_labels[name] = [y for x in temp_list for y in x]
print('{} finish'.format(name))
torch.save(res, filename)
torch.save(res_labels, filename + '_label')
return res
def load_pretrained(self):
self.D_cVAE.load_state_dict(torch.load(os.path.join(self.weight_dir, 'D_cVAE.pkl')))
self.D_cLR.load_state_dict(torch.load(os.path.join(self.weight_dir, 'D_cLR.pkl')))
self.G.load_state_dict(torch.load(os.path.join(self.weight_dir, 'G.pkl')))
self.E.load_state_dict(torch.load(os.path.join(self.weight_dir, 'E.pkl')))
log_file = open('log.txt', 'r')
line = log_file.readline()
self.start_epoch = int(line)
def _restore_checkpoint(self) -> Tuple[int, List[float]]:
"""
Restores a model from a serialization_dir to the last saved checkpoint.
This includes an epoch count and optimizer state, which is serialized separately
from model parameters. This function should only be used to continue training -
if you wish to load a model for inference/load parts of a model into a new
computation graph, you should use the native Pytorch functions:
`` model.load_state_dict(torch.load("/path/to/model/weights.th"))``
If ``self._serialization_dir`` does not exist or does not contain any checkpointed weights,
this function will do nothing and return 0.
Returns
-------
epoch: int
The epoch at which to resume training, which should be one after the epoch
in the saved training state.
"""
latest_checkpoint = self.find_latest_checkpoint()
if latest_checkpoint is None:
# No checkpoint to restore, start at 0
return 0, []
model_path, training_state_path = latest_checkpoint
# Load the parameters onto CPU, then transfer to GPU.
# This avoids potential OOM on GPU for large models that
# load parameters onto GPU then make a new GPU copy into the parameter
# buffer. The GPU transfer happens implicitly in load_state_dict.
model_state = torch.load(model_path, map_location=util.device_mapping(-1))
training_state = torch.load(training_state_path, map_location=util.device_mapping(-1))
self._model.load_state_dict(model_state)
self._optimizer.load_state_dict(training_state["optimizer"])
move_optimizer_to_cuda(self._optimizer)
# We didn't used to save `validation_metric_per_epoch`, so we can't assume
# that it's part of the trainer state. If it's not there, an empty list is all
# we can do.
if "val_metric_per_epoch" not in training_state:
logger.warning("trainer state `val_metric_per_epoch` not found, using empty list")
val_metric_per_epoch: List[float] = []
else:
val_metric_per_epoch = training_state["val_metric_per_epoch"]
if isinstance(training_state["epoch"], int):
epoch_to_return = training_state["epoch"] + 1
else:
epoch_to_return = int(training_state["epoch"].split('.')[0]) + 1
# For older checkpoints with batch_num_total missing, default to old behavior where
# it is unchanged.
batch_num_total = training_state.get('batch_num_total')
if batch_num_total is not None:
self._batch_num_total = batch_num_total
return epoch_to_return, val_metric_per_epoch
def __init__(self, num_classes, pretrained=True, caffe=False):
super(FCN8s, self).__init__()
vgg = models.vgg16()
if pretrained:
if caffe:
# load the pretrained vgg16 used by the paper's author
vgg.load_state_dict(torch.load(vgg16_caffe_path))
else:
vgg.load_state_dict(torch.load(vgg16_path))
features, classifier = list(vgg.features.children()), list(vgg.classifier.children())
'''
100 padding for 2 reasons:
1) support very small input size
2) allow cropping in order to match size of different layers' feature maps
Note that the cropped part corresponds to a part of the 100 padding
Spatial information of different layers' feature maps cannot be align exactly because of cropping, which is bad
'''
features[0].padding = (100, 100)
for f in features:
if 'MaxPool' in f.__class__.__name__:
f.ceil_mode = True
elif 'ReLU' in f.__class__.__name__:
f.inplace = True
self.features3 = nn.Sequential(*features[: 17])
self.features4 = nn.Sequential(*features[17: 24])
self.features5 = nn.Sequential(*features[24:])
self.score_pool3 = nn.Conv2d(256, num_classes, kernel_size=1)
self.score_pool4 = nn.Conv2d(512, num_classes, kernel_size=1)
self.score_pool3.weight.data.zero_()
self.score_pool3.bias.data.zero_()
self.score_pool4.weight.data.zero_()
self.score_pool4.bias.data.zero_()
fc6 = nn.Conv2d(512, 4096, kernel_size=7)
fc6.weight.data.copy_(classifier[0].weight.data.view(4096, 512, 7, 7))
fc6.bias.data.copy_(classifier[0].bias.data)
fc7 = nn.Conv2d(4096, 4096, kernel_size=1)
fc7.weight.data.copy_(classifier[3].weight.data.view(4096, 4096, 1, 1))
fc7.bias.data.copy_(classifier[3].bias.data)
score_fr = nn.Conv2d(4096, num_classes, kernel_size=1)
score_fr.weight.data.zero_()
score_fr.bias.data.zero_()
self.score_fr = nn.Sequential(
fc6, nn.ReLU(inplace=True), nn.Dropout(), fc7, nn.ReLU(inplace=True), nn.Dropout(), score_fr
)
self.upscore2 = nn.ConvTranspose2d(num_classes, num_classes, kernel_size=4, stride=2, bias=False)
self.upscore_pool4 = nn.ConvTranspose2d(num_classes, num_classes, kernel_size=4, stride=2, bias=False)
self.upscore8 = nn.ConvTranspose2d(num_classes, num_classes, kernel_size=16, stride=8, bias=False)
self.upscore2.weight.data.copy_(get_upsampling_weight(num_classes, num_classes, 4))
self.upscore_pool4.weight.data.copy_(get_upsampling_weight(num_classes, num_classes, 4))
self.upscore8.weight.data.copy_(get_upsampling_weight(num_classes, num_classes, 16))
def load_separately(opt, Model):
print("=> loading checkpoint '{}'".format(opt.id_pretrain_path))
id_pretrain = torch.load(opt.id_pretrain_path)
Model.ID_encoder = copy_state_dict(id_pretrain['model_fusion'], Model.ID_encoder)
print("=> loading checkpoint '{}'".format(opt.feature_extractor_path))
feature_extractor_check = torch.load(opt.feature_extractor_path)
Model.lip_feature_encoder = copy_state_dict(feature_extractor_check['face_encoder'], Model.lip_feature_encoder)
Model.mfcc_encoder = copy_state_dict(feature_extractor_check['mfcc_encoder'], Model.mfcc_encoder)
Model.model_fusion = copy_state_dict(feature_extractor_check['face_fusion'], Model.model_fusion)
return Model
def load(self, name):
path = os.path.join(self.save_path, name)
if not os.path.exists(path):
raise RuntimeError("Saved network does not exist")
encoder_path = os.path.join(path, "encoder.net")
decoder_path = os.path.join(path, "decoder.net")
self.encoder.load_state_dict(torch.load(encoder_path))
self.decoder.load_state_dict(torch.load(decoder_path))
def load_networks(self, which_epoch):
for name in self.model_names:
if isinstance(name, str):
save_filename = '%s_net_%s.pth' % (which_epoch, name)
save_path = os.path.join(self.save_dir, save_filename)
net = getattr(self, 'net' + name)
if len(self.gpu_ids) > 0 and torch.cuda.is_available():
net.module.load_state_dict(torch.load(save_path))
else:
net.load_state_dict(torch.load(save_path))
def get_pretrained_net(name):
"""Loads pretrained network, converted from Caffe."""
if name == 'alexnet':
os.system('wget -O data/feature_inversion/alexnet-caffe.pth --no-check-certificate -nc https://www.dropbox.com/s/e30k2myjdyhsxes/alexnet-caffe.pth?dl=1')
return torch.load('data/feature_inversion/alexnet-caffe.pth')
elif name == 'vgg19':
os.system('wget -O data/feature_inversion/vgg19-caffe.pth --no-check-certificate -nc https://www.dropbox.com/s/xlbdo688dy4keyk/vgg19-caffe.pth?dl=1')
return torch.load('data/feature_inversion/vgg19-caffe.pth')
else:
assert False
def load(self, directory):
paths = glob.glob(os.path.join(directory, "*.pth"))
gen_path = [path for path in paths if "generator" in path][0]
disc_path = [path for path in paths if "discriminator" in path][0]
self.generator.load_state_dict(torch.load(gen_path))
self.discriminator.load_state_dict(torch.load(disc_path))
self.start_epoch = int(gen_path.split(".")[0].split("_")[-1])
print("Load pretrained [{}, {}]".format(gen_path, disc_path))
def loadPrepareData(corpus):
corpus_name = corpus.split('/')[-1].split('.')[0]
try:
print("Start loading training data ...")
voc = torch.load(os.path.join(save_dir, 'training_data', corpus_name, 'voc.tar'))
pairs = torch.load(os.path.join(save_dir, 'training_data', corpus_name, 'pairs.tar'))
except FileNotFoundError:
print("Saved data not found, start preparing trianing data ...")
voc, pairs = prepareData(corpus, corpus_name)
return voc, pairs
def load_parameters(self, path):
fname, ext = os.path.splitext(path)
encoder_states = torch.load(fname + '.encoder' + ext, map_location=lambda storage, loc: storage)['state_dict']
self.encoder.load_state_dict(encoder_states)
decoder_states = torch.load(fname + '.decoder' + ext, map_location=lambda storage, loc: storage)['state_dict']
self.decoder.load_state_dict(decoder_states)
vae_states = torch.load(path, map_location=lambda storage, loc: storage)['state_dict']
self.load_state_dict(vae_states, strict=False)
def load_checkpoint(self, folder='checkpoint', filename='checkpoint.pth.tar', cpu='False'):
# https://github.com/pytorch/examples/blob/master/imagenet/main.py#L98
filepath = os.path.join(folder, filename)
print("Loading from " + str(filepath))
if not os.path.exists(filepath):
raise("No model in path {}".format(filepath))
if cpu:
checkpoint = torch.load(filepath, map_location='cpu')
else:
checkpoint = torch.load(filepath)
self.nnet.load_state_dict(checkpoint['state_dict'])
print('Saving the best model: {}'.format(best_state))
with open(checkpoint_path, 'wb') as f:
torch.save(model.state_dict(), f)
with open(checkpoint_state_path, 'w') as f:
f.write('epoch {:3d} | lr: {:5.2f} | valid loss {:5.2f} | '
'valid ppl {:8.2f}'.format(epoch, lr, val_loss,
math.exp(val_loss)))
else:
# Anneal the learning rate if no improvement has been seen in the validation dataset.
lr /= 4.0
writer.close()
# Load the best saved model.
with open(checkpoint_path, 'rb') as f:
model.load_state_dict(torch.load(f))
# after load the rnn params are not a continuous chunk of memory
# this makes them a continuous chunk, and will speed up forward pass
model.rnn.flatten_parameters()
# Run on test data.
test_loss = evaluate(test_data)
print('=' * 89)
print('| End of training | test loss {:5.2f} | test ppl {:8.2f}'.format(
test_loss, math.exp(test_loss)))
print('=' * 89)
# Move the best model to cpu and resave it
with open(model_path, 'wb') as f:
torch.save(model.cpu().state_dict(), f)
train_filename = "/share/data/DvsGesture/dvs_gestures_dense_train.pt"
test_filename = "/share/data/DvsGesture/dvs_gestures_dense_test.pt"
train_loader = DataLoader(DVSGestures(train_filename),
batch_size=batch_size,
shuffle=True,
drop_last=True)
test_loader = DataLoader(DVSGestures(test_filename),
batch_size=test_batch_size,
shuffle=False,
drop_last=True)
net = allnsmconvnet64(noise='gaussian').to(device)
from dvsgestures_classic import allconvnet64
net_ = allconvnet64().to(device)
net_ = torch.load("dvs_gestures_trained_model_full_new.pt")
dvs_gestures_replace_w(net_, net)
# x, y = next(iter(train_loader))
# init_model(net, x.to(device))
# outs = get_activities(net, x.to(device))
optimizer = optim.Adam(net.parameters(), lr=0.0003, eps=1e-4)
loss = nn.CrossEntropyLoss()
ll, mm = len(train_loader), len(test_loader)
ac_, er_ = [], []
for e in range(epochs):
rloss = 0.0
if ((e + 1) % 100) == 0:
def load_candidates(self, path, cand_type='vectors'):
"""Load fixed candidates from a path."""
print("[ Loading fixed candidate set {} from {} ]".format(
cand_type, path))
return torch.load(path, map_location=lambda cpu, _: cpu)
def load_model(load_path, model):
state_dict = torch.load(load_path, map_location=device)
model.load_state_dict(state_dict['model_state_dict'])
return state_dict['valid_loss']
def load_optimizer(optimizer, load_path, verbose=True):
if verbose:
print('Load optimizer at %s' % load_path)
weights = torch.load(load_path)
optimizer.load_state_dict(weights)
return optimizer
corpus = data.Corpus(args.data)
eval_batch_size = 10
test_batch_size = 1
train_data = batchify(corpus.train, args.batch_size, args)
val_data = batchify(corpus.valid, eval_batch_size, args)
test_data = batchify(corpus.test, test_batch_size, args)
###############################################################################
# Build the model
###############################################################################
ntokens = len(corpus.dictionary)
if args.continue_train:
model = torch.load(os.path.join(args.save, 'model.pt'))
elif args.GL:
model = model.RNNModel(args.model, ntokens, args.emsize, args.nhid, args.nhidlast, args.nlayers,
args.dropout, args.dropouth, args.dropouti, args.dropoute, args.wdrop,
args.tied, args.dropoutl, args.n_experts)
if args.start_layer > 0:
print('loading prev model...')
model = load_layers(model, os.path.join(args.load_prev, 'finetune_model.pt'))
else:
model = model.RNNModel(args.model, ntokens, args.emsize, args.nhid, args.nhidlast, args.nlayers,
args.dropout, args.dropouth, args.dropouti, args.dropoute, args.wdrop,
args.tied, args.dropoutl, args.n_experts)
if args.cuda:
if args.single_gpu:
parallel_model = model.cuda()
# set up model
class LinearODE(torch.nn.Module):
def __init__(self, A, b):
super(LinearODE, self).__init__()
self.A = torch.nn.Parameter(A.clone())
self.b = torch.nn.Parameter(b.clone())
def forward(self, time, state):
dydt = self.A @ state + self.b
return (dydt)
# load training result
load_path = os.path.dirname(
os.path.realpath(__file__)) + '/learn_linear_ode_minibatch.pt'
data = torch.load(load_path)
epoch = data['epoch']
model_state_dict = data['model_state_dict']
optimizer_state_dict = data['optimizer_state_dict']
loss_history = data['loss_history']
states_mean = data['states_mean']
states_err = data['states_err']
# load data
load_path = os.path.dirname(os.path.realpath(__file__)) + '/data.npz'
data = np.load(load_path)
moment_initial = torch.from_numpy(data['moment_initial'])
rates = data['rates']
A_true = data['A_true']
b_true = data['b_true']
num_samples = data['num_samples']
def train(self):
config = self.config
batch_queue_size = config['batch_queue_size']
n_agents = config['num_agents']
config['test'] = False
# Create directory for experiment
experiment_dir = f"{config['results_path']}/{config['env']}-{config['model']}-{datetime.now():%Y-%m-%d_%H:%M:%S}"
if not os.path.exists(experiment_dir):
os.makedirs(experiment_dir)
# Data structures
processes = []
replay_queue = torch_mp.Queue(maxsize=256)
training_on = torch_mp.Value('i', 1)
update_step = torch_mp.Value('i', 0)
global_episode = torch_mp.Value('i', 0)
learner_w_queue = torch_mp.Queue(maxsize=n_agents)
replay_priorities_queue = torch_mp.Queue(maxsize=256)
# Data sampler
batch_queue = torch_mp.Queue(maxsize=batch_queue_size)
p = torch_mp.Process(target=sampler_worker,
args=(config, replay_queue, batch_queue, replay_priorities_queue, training_on,
global_episode, update_step, experiment_dir))
processes.append(p)
# Learner (neural net training process)
target_policy_net = PolicyNetwork(config['state_dims'], config['action_dims'],
config['dense_size'], device=config['device'])
if os.path.exists(config.get("policy_weights_best", "location_not_found")):
target_policy_net.load_state_dict(torch.load(config["policy_weights_best"]))
else:
print(f"cannot load policy")
policy_net = copy.deepcopy(target_policy_net)
target_policy_net.share_memory()
p = torch_mp.Process(target=learner_worker, args=(config, training_on, policy_net, target_policy_net, learner_w_queue,
replay_priorities_queue, batch_queue, update_step, experiment_dir))
processes.append(p)
p = torch_mp.Process(target=agent_worker,
args=(config, target_policy_net, None, global_episode, 0, "exploitation", experiment_dir,
training_on, replay_queue, update_step))
processes.append(p)
# Agents (exploration processes)
if self.use_supervisor:
n_agents -= 1
for i in range(1, n_agents):
p = torch_mp.Process(target=agent_worker,
args=(config, policy_net, learner_w_queue, global_episode, i, "exploration", experiment_dir,
training_on, replay_queue, update_step))
processes.append(p)
if self.use_supervisor:
p = torch_mp.Process(target=agent_worker,
args=(config, target_policy_net, learner_w_queue, global_episode, i+1, "supervisor", experiment_dir,
training_on, replay_queue, update_step))
processes.append(p)
for p in processes:
p.start()
#time.sleep(5)
for p in processes:
p.join()
print("End.")
def run(slid_dir):
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=100, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=100, metavar='N',
help='how many batches to wait before '
'logging training status')
parser.add_argument('--resume', default='./models/model_detector.pth',
help="path to model (to continue training)")
parser.add_argument('--outname', default='./scores_detector_test',
help="path to scores' file")
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
model = Net()
if args.resume != '':
model.load_state_dict(torch.load(args.resume))
print(model)
if args.cuda:
model.cuda()
def test_eval(epoch):
model.eval()
test_loss = 0
correct = 0
scores = []
for batch_idx, (data, target) in enumerate(test_loader):
if args.cuda:
data, target = data.cuda(), target.cuda()
data, target = Variable(data, volatile=True), Variable(target)
output = model(data)
pred = output.data.max(1)[1]
correct += pred.eq(target.data).cpu().sum()
if batch_idx % args.log_interval == 0:
print('Eval Patient: {} [{}/{} ({:.0f}%)]'.format(
epoch, batch_idx * len(data), len(test_loader.dataset),
100. * batch_idx / len(test_loader)))
scores.extend((output.data).cpu().numpy())
test_loss = test_loss
test_loss /= len(test_loader)
return scores
files = os.listdir(slid_dir)
files.sort()
dist_thresh = 10
all_scores = []
all_labels = []
all_images = []
all_patients = []
all_cands = []
idPat = 0
tot_time = time.time()
for f in range(len(files)):
tmp = np.load(str(slid_dir + files[f]))
slices = tmp
slices = np.swapaxes(slices, 2, 3)
slices = np.expand_dims(slices, axis=1)
slices = slices.astype(np.float32)
print('\n Patient ' + str(f+1) + '/' + str(len(files)) + ' loaded.')
labels = np.zeros(len(slices))
labels = labels.astype(np.int64)
vdata = torch.from_numpy(slices)
vlabel = torch.from_numpy(labels)
testv = data_utils.TensorDataset(vdata, vlabel)
test_loader = data_utils.DataLoader(testv, batch_size=args.batch_size, shuffle=False)
scores = test_eval(f+1)
all_scores.extend(scores)
pat_name = str(files[f][:-4])
all_patients.extend([pat_name]) #patients names
all_labels.extend(labels) #labels
all_images.extend((idPat+1)*np.ones(len(scores))) #patient index
idPat += 1
np.savez(args.outname, all_patients, all_scores, all_labels, all_images)
def trainVAE_D(epoches,batch_size,data,ds_model,ds_emb,gan_path,style_path,pretrainD=False):
gan = torch.load(gan_path)
# gan.apply(weights_init) # apply weight init
# style_represent is the dim we choose to represent the style
# content_represent is the dim we choose to represent the content
# D_filters is a list like this [1,2,3,4]
# D_num_filters is the the filters number we want to use for each window size
# Ey_filters
# gan = GANModel(style_represent=500, content_represent=250, D_filters=[2,3,4,5,6], D_num_filters=100, Ey_filters=[1,2,3,4,5],
# Ey_num_filters=100, embedding_size=250, n_vocab=8981, temper=0.0001, max_len=40, min_len = 6, style_path=style_path)
gan = gan.cuda()
gan.train(True)
style = StyleData()
style.load(style_path)
const = Constants(style.n_words)
optimizer = optim.Adam(gan.parameters(),lr=const.Lr)
lamda1 = 1
lamda2 = 1
lamda3 = 3
cross_entropy = nn.CrossEntropyLoss()
# init the state of some model
ds_model.train(True)
ds_emb.train(True)
train_data = indexData2variable(data)
train_data = build2pairs(train_data)
for i in range(epoches):
print(("epoches:\t", i))
if pretrainD:
print("trainning Discriminator..........")
else :
print("trainning Generator..............")
sys.stdout.flush()
stime = time.time()
shuffleData(train_data)
print(len(train_data))
sys.stdout.flush()
count = 0
# for count in range(int(len(train_data))):
while count < int(10000-batch_size):
tempdata = train_data[count:count+batch_size]
if tempdata == []:
break
count += batch_size
optimizer.zero_grad()
Lrec = 0
Lcyc = 0
Ldis = 0
Ladv = 0
Loss = 0
# before we let the D lead the gradient the D model must be strong enough
if not pretrainD:
for seqs in tempdata:
seqs[0] = seqs[0].cuda()
seqs[1] = seqs[1].cuda()
dic = gan(seqs[0],seqs[1],D_train=True)
Lrec = cross_entropy(dic['x1_hat_noT'],seqs[0])+cross_entropy(dic['x2_hat_noT'],seqs[1])
Lcyc = cross_entropy(dic['x1_bar_noT'],seqs[0])+cross_entropy(dic['x2_bar_noT'],seqs[1])
emb = ds_emb(seqs[0]).unsqueeze(0).unsqueeze(0)
Ldis = (ds_model(emb)[0][1]*(dic['y1']-dic['y_star'])**2).sum()
Ladv = cross_entropy(dic['D_x1_wl'],Variable(torch.LongTensor([0]).cuda())) + cross_entropy(dic['D_x2_hat'],Variable(torch.LongTensor([1]).cuda()))
Loss += Lrec + lamda2*Lcyc + lamda3*Ldis - lamda1*Ladv
else:
for seqs in tempdata:
dic = gan(seqs[0],seqs[1],Ez_train=True,Ey_train=True,G_train=True, Lcyc=False, Lrec=False, Ldis = False)
Ladv = cross_entropy(dic['D_x1_wl'],Variable(torch.LongTensor([0]).cuda()))+ cross_entropy(dic['D_x2_hat'],Variable(torch.LongTensor([1]).cuda()))
Loss += lamda1*Ladv
# print "loss \t\t%.3f" %(Loss.data.cpu().numpy()[0])
Loss.backward(retain_graph=True)
optimizer.step()
if count%100 == 0:
print('{} / {}'.format(count,len(train_data)))
sys.stdout.flush()
torch.save(gan, "./Model/bitch_gan2.pkl")
gan.eval()
acc = get_d_acc(gan, train_data)
gan.train(True)
if acc > 0.8:
pretrainD = False
if acc < 0.6:
pretrainD = True
etime = time.time()
print(("cost time \t%.2f mins" % ((etime - stime)/60)))
sys.stdout.flush()
torch.save(gan, "./Model/bitch_gan2.pkl")
def train_fn(args):
device = torch.device("cuda" if hparams.use_cuda else "cpu")
upsample_factor = int(hparams.frame_shift_ms / 1000 * hparams.downsample_rate)
model = create_model(hparams)
model.to(device)
optimizer = optim.Adam(model.parameters(), lr=hparams.learning_rate)
for state in optimizer.state.values():
for key, value in state.items():
if torch.is_tensor(value):
state[key] = value.to(device)
if args.resume is not None:
log("Resume checkpoint from: {}:".format(args.resume))
checkpoint = torch.load(args.resume, map_location=lambda storage, loc: storage)
if torch.cuda.device_count() > 1:
model.module.load_state_dict(checkpoint['model'])
else:
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint["optimizer"])
global_step = checkpoint['steps']
else:
global_step = 0
log("receptive field: {0} ({1:.2f}ms)".format(
model.receptive_field, model.receptive_field / hparams.sample_rate * 1000))
if hparams.feature_type == "mcc":
scaler = StandardScaler()
scaler.mean_ = np.load(os.path.join(args.data_dir, 'mean.npy'))
scaler.scale_ = np.load(os.path.join(args.data_dir, 'scale.npy'))
feat_transform = transforms.Compose([lambda x: scaler.transform(x)])
else:
feat_transform = None
dataset = CustomDataset(meta_file=os.path.join(args.data_dir, 'train.txt'),
receptive_field=model.receptive_field,
sample_size=hparams.sample_size,
upsample_factor=upsample_factor,
quantization_channels=hparams.quantization_channels,
use_local_condition=hparams.use_local_condition,
noise_injecting=hparams.noise_injecting,
feat_transform=feat_transform)
dataloader = DataLoader(dataset, batch_size=hparams.batch_size,
shuffle=True, num_workers=args.num_workers,
pin_memory=True)
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
criterion = nn.CrossEntropyLoss()
ema = ExponentialMovingAverage(args.ema_decay)
for name, param in model.named_parameters():
if param.requires_grad:
ema.register(name, param.data)
writer = SummaryWriter(args.checkpoint_dir)
while global_step < hparams.training_steps:
for i, data in enumerate(dataloader, 0):
audio, target, local_condition = data
target = target.squeeze(-1)
local_condition = local_condition.transpose(1, 2)
audio, target, h = audio.to(device), target.to(device), local_condition.to(device)
optimizer.zero_grad()
output = model(audio[:,:,:-1,:], h[:,:,1:])
loss = criterion(output[:,0,:,:], target[:,0,:])
log('step [%3d]: loss: %.3f' % (global_step, loss.item()))
writer.add_scalar('loss', loss.item(), global_step)
loss.backward()
optimizer.step()
# update moving average
if ema is not None:
apply_moving_average(model, ema)
global_step += 1
if global_step % hparams.checkpoint_interval == 0:
save_checkpoint(device, hparams, model, optimizer, global_step, args.checkpoint_dir, ema)
out = output[1,0,:,:]
samples=out.argmax(0)
waveform = mu_law_decode(np.asarray(samples[model.receptive_field:].cpu().numpy()), hparams.quantization_channels)
write_wav(waveform, hparams.sample_rate, os.path.join(args.checkpoint_dir, "train_eval_{}.wav".format(global_step)))
imgData = numpy.empty([imgNum,1,256,256])
for i in range(imgNum):
img = Image.open('./256bmp/' + str(i) + '.bmp').convert('L')
imgData[i] = numpy.asarray(img).astype(float).reshape([1,256,256])
if(sys.argv[2]=='0'): # 设置是重新开始 还是继续训练
net = cNet(device).cuda()
print('create new model')
else:
net = torch.load('./models/' + sys.argv[5] + '.pkl').cuda()
print('read ./models/' + sys.argv[5] + '.pkl')
print(net)
criterion = pytorch_ssim.SSIM()
optimizer = torch.optim.Adam(net.parameters(), lr=float(sys.argv[3]))
batchSize = 16 # 一次读取?张图片进行训练
imgData = torch.from_numpy(imgData).float().cuda()
trainData = torch.empty([batchSize, 1, 256, 256]).float().cuda()
for i in range(int(sys.argv[4])):
readSeq = torch.randperm(imgNum) # 生成读取的随机序列
maxLossOfTrainData = -torch.ones(1).cuda()
j = 0
from torchvision.models.detection.rpn import AnchorGenerator
from torchvision import transforms as T
import torch.distributed as dist
from PIL import Image, ImageDraw
from collections import defaultdict, deque
import datetime
import pickle
import time
import numpy as np
from engine import train_one_epoch, evaluate
import utils
img = Image.open("./image_exp/Detection/test/10056.jpg").convert("RGB")
img_tensor = T.ToTensor()(img)
model = torch.load("./model_RCNN.pth")
model.eval()
pred = model([img_tensor.to("cuda:0")])
out = ImageDraw.Draw(img)
for b in pred[0]['boxes']:
out.rectangle(b.detach().cpu().numpy().tolist(), outline="green", width=2)
img.save("./out.png")
print(pred)
result = {"imgs": {}, "types": [
"pl30",
"pl5",
"w57",
"io",
"p5",
torch.cuda.set_device(args.gpu)
#
chnls = 512
#pca = PCA(n_components=chnls)
base = 2**4
h,w = 1170//base,827//base
is_model = False
mb_size = args.batchSize
scales=[float(s)*0.5 for s in args.scales.split(',')]
illus2vec = Illust2vecNet('models/illust2vec_tag_ver200_2.pth').eval().cuda()
if is_model:
featureEnc = FeatureEncoder().eval().cuda()
featureEnc.load_state_dict(torch.load('vae/checkpoints/%s/model_%d.pth' % (args.modelf, args.start-1)))
################
#illus2vec=nn.DataParallel(illus2vec)
################
scale = 1
origindataset = DataDataset(args.dataset, base=base, chnls=chnls, mode='img', name=folders[0])
dataloader = torch.utils.data.DataLoader(origindataset, batch_size=args.batchSize,
shuffle=False, num_workers=1)
print('Images in dataset: %s'%len(origindataset))
tdataset = DataDataset(args.testimgs, scale=scale, name='image', basic=1)
tdataloader = torch.utils.data.DataLoader(tdataset, batch_size=1,
shuffle=False, num_workers=1)
feature = torch.FloatTensor(np.random.rand(mb_size, chnls, 73, 51)).cuda()
image1 = torch.FloatTensor(np.zeros((mb_size, 1, int(1170), int(827)))).cuda()
image2 = torch.FloatTensor(np.zeros((mb_size, 1, int(1170)//2, int(827/2)))).cuda()
def main():
# Load dataset
print('Loading dataset ...\n')
dataset_train = Dataset(train=True, data_path=opt.data_path)
loader_train = DataLoader(dataset=dataset_train, num_workers=4, batch_size=opt.batchSize, shuffle=True)
print("# of training samples: %d\n" % int(len(dataset_train)))
# Build model
model = DRN(channel=3, inter_iter=opt.inter_iter, intra_iter=opt.intra_iter, use_GPU=opt.use_GPU)
print_network(model)
criterion = SSIM()
# Move to GPU
if opt.use_GPU:
model = model.cuda()
criterion.cuda()
# Optimizer
optimizer = optim.Adam(model.parameters(), lr=opt.lr)
scheduler = MultiStepLR(optimizer, milestones=opt.milestone, gamma=0.5) # learning rates
# training
writer = SummaryWriter(opt.save_folder)
step = 0
initial_epoch = findLastCheckpoint(save_dir=opt.save_folder) # load the last model in matconvnet style
if initial_epoch > 0:
print('resuming by loading epoch %03d' % initial_epoch)
model.load_state_dict(torch.load(os.path.join(opt.save_folder, 'net_epoch%d.pth' % initial_epoch)))
for epoch in range(initial_epoch, opt.epochs):
scheduler.step(epoch)
# set learning rate
for param_group in optimizer.param_groups:
#param_group["lr"] = current_lr
print('learning rate %f' % param_group["lr"])
# train
for i, (input, target) in enumerate(loader_train, 0):
# training step
loss_list = []
model.train()
model.zero_grad()
optimizer.zero_grad()
input_train, target_train = Variable(input.cuda()), Variable(target.cuda())
out_train, outs = model(input_train)
pixel_loss = criterion(target_train, out_train)
for lossi in range(opt.inter_iter):
loss1 = criterion(target_train, outs[lossi])
loss_list.append(loss1)
loss = -pixel_loss
index = 0.1
for lossi in range(opt.inter_iter):
loss += -index * loss_list[lossi]
index = index + 0.1
loss.backward()
optimizer.step()
# results
model.eval()
out_train, _ = model(input_train)
out_train = torch.clamp(out_train, 0., 1.)
psnr_train = batch_PSNR(out_train, target_train, 1.)
print("[epoch %d][%d/%d] loss: %.4f, loss1: %.4f, loss2: %.4f, loss3: %.4f, loss4: %.4f, PSNR_train: %.4f" %
(epoch + 1, i + 1, len(loader_train), loss.item(), loss_list[0].item(), loss_list[1].item(), loss_list[2].item(),
loss_list[3].item(), psnr_train))
# print("[epoch %d][%d/%d] loss: %.4f, PSNR_train: %.4f" %
# (epoch + 1, i + 1, len(loader_train), loss.item(), psnr_train))
# if you are using older version of PyTorch, you may need to change loss.item() to loss.data[0]
if step % 10 == 0:
# Log the scalar values
writer.add_scalar('loss', loss.item(), step)
writer.add_scalar('PSNR on training data', psnr_train, step)
step += 1
## the end of each epoch
model.eval()
# log the images
out_train,_ = model(input_train)
out_train = torch.clamp(out_train, 0., 1.)
Img = utils.make_grid(target_train.data, nrow=8, normalize=True, scale_each=True)
Imgn = utils.make_grid(input_train.data, nrow=8, normalize=True, scale_each=True)
Irecon = utils.make_grid(out_train.data, nrow=8, normalize=True, scale_each=True)
writer.add_image('clean image', Img, epoch)
writer.add_image('noisy image', Imgn, epoch)
writer.add_image('reconstructed image', Irecon, epoch)
# save model
torch.save(model.state_dict(), os.path.join(opt.save_folder, 'net_latest.pth'))
if epoch % opt.save_freq == 0:
torch.save(model.state_dict(), os.path.join(opt.save_folder, 'net_epoch%d.pth' % (epoch+1)))
def _load_net(checkpoint_path, model):
state = torch.load(checkpoint_path)
model.load_state_dict(state['model_state_dict'])
return model
def load_dict(self, directory, env_name):
self.policy_old.load_state_dict(
torch.load(os.path.join(directory, '{}.pth'.format(env_name))))
self.policy.load_state_dict(
torch.load(os.path.join(directory, '{}.pth'.format(env_name))))
def load_model(self, fname: str) -> None:
chkpt = torch.load(fname, map_location=map_location(self._device))
set_state_dict(self, chkpt)
def run(args):
global logging
logging = create_exp_dir(args.exp_dir, scripts_to_save=[])
if args.cuda:
logging('using cuda')
logging(str(args))
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
torch.backends.cudnn.deterministic = True
opt_dict = {"not_improved": 0, "lr": 1., "best_loss": 1e4}
vocab = {}
with open(args.vocab_file) as fvocab:
for i, line in enumerate(fvocab):
vocab[line.strip()] = i
vocab = VocabEntry(vocab)
train_data = MonoTextData(args.train_data, label=args.label, vocab=vocab)
vocab_size = len(vocab)
val_data = MonoTextData(args.val_data, label=args.label, vocab=vocab)
test_data = MonoTextData(args.test_data, label=args.label, vocab=vocab)
logging('Train data: %d samples' % len(train_data))
logging('finish reading datasets, vocab size is %d' % len(vocab))
logging('dropped sentences: %d' % train_data.dropped)
#sys.stdout.flush()
log_niter = max(1, (len(train_data)//(args.batch_size * args.update_every))//10)
model_init = uniform_initializer(0.01)
emb_init = uniform_initializer(0.1)
#device = torch.device("cuda" if args.cuda else "cpu")
device = "cuda" if args.cuda else "cpu"
args.device = device
if args.enc_type == 'lstm':
encoder = GaussianLSTMEncoder(args, vocab_size, model_init, emb_init)
args.enc_nh = args.dec_nh
else:
raise ValueError("the specified encoder type is not supported")
decoder = LSTMDecoder(args, vocab, model_init, emb_init)
vae = VAE(encoder, decoder, args).to(device)
if args.load_path:
loaded_state_dict = torch.load(args.load_path)
#curr_state_dict = vae.state_dict()
#curr_state_dict.update(loaded_state_dict)
vae.load_state_dict(loaded_state_dict)
logging("%s loaded" % args.load_path)
# if args.eval:
# logging('begin evaluation')
# vae.load_state_dict(torch.load(args.load_path))
# vae.eval()
# with torch.no_grad():
# test_data_batch = test_data.create_data_batch(batch_size=args.batch_size,
# device=device,
# batch_first=True)
# test(vae, test_data_batch, test_labels_batch, "TEST", args)
# au, au_var = calc_au(vae, test_data_batch)
# logging("%d active units" % au)
# # print(au_var)
# test_data_batch = test_data.create_data_batch(batch_size=1,
# device=device,
# batch_first=True)
# calc_iwnll(vae, test_data_batch, args)
# return
if args.discriminator == "linear":
discriminator = LinearDiscriminator(args, vae.encoder).to(device)
elif args.discriminator == "mlp":
discriminator = MLPDiscriminator(args, vae.encoder).to(device)
if args.opt == "sgd":
optimizer = optim.SGD(discriminator.parameters(), lr=args.lr, momentum=args.momentum)
opt_dict['lr'] = args.lr
elif args.opt == "adam":
optimizer = optim.Adam(discriminator.parameters(), lr=0.001)
opt_dict['lr'] = 0.001
else:
raise ValueError("optimizer not supported")
iter_ = decay_cnt = 0
best_loss = 1e4
# best_kl = best_nll = best_ppl = 0
# pre_mi = 0
discriminator.train()
start = time.time()
# kl_weight = args.kl_start
# if args.warm_up > 0:
# anneal_rate = (1.0 - args.kl_start) / (args.warm_up * (len(train_data) / args.batch_size))
# else:
# anneal_rate = 0
# dim_target_kl = args.target_kl / float(args.nz)
train_data_batch, train_labels_batch = train_data.create_data_batch_labels(batch_size=args.batch_size,
device=device,
batch_first=True)
val_data_batch, val_labels_batch = val_data.create_data_batch_labels(batch_size=128,
device=device,
batch_first=True)
test_data_batch, test_labels_batch = test_data.create_data_batch_labels(batch_size=128,
device=device,
batch_first=True)
acc_cnt = 1
acc_loss = 0.
for epoch in range(args.epochs):
report_loss = 0
report_correct = report_num_words = report_num_sents = 0
acc_batch_size = 0
optimizer.zero_grad()
for i in np.random.permutation(len(train_data_batch)):
batch_data = train_data_batch[i]
if batch_data.size(0) < 2:
continue
batch_labels = train_labels_batch[i]
batch_labels = [int(x) for x in batch_labels]
batch_labels = torch.tensor(batch_labels, dtype=torch.long, requires_grad=False, device=device)
batch_size, sent_len = batch_data.size()
# not predict start symbol
report_num_words += (sent_len - 1) * batch_size
report_num_sents += batch_size
acc_batch_size += batch_size
# (batch_size)
loss, correct = discriminator.get_performance(batch_data, batch_labels)
acc_loss = acc_loss + loss.sum()
if acc_cnt % args.update_every == 0:
acc_loss = acc_loss / acc_batch_size
acc_loss.backward()
torch.nn.utils.clip_grad_norm_(discriminator.parameters(), clip_grad)
optimizer.step()
optimizer.zero_grad()
acc_cnt = 0
acc_loss = 0
acc_batch_size = 0
acc_cnt += 1
report_loss += loss.sum().item()
report_correct += correct
if iter_ % log_niter == 0:
#train_loss = (report_rec_loss + report_kl_loss) / report_num_sents
train_loss = report_loss / report_num_sents
logging('epoch: %d, iter: %d, avg_loss: %.4f, acc %.4f,' \
'time %.2fs' %
(epoch, iter_, train_loss, report_correct / report_num_sents,
time.time() - start))
#sys.stdout.flush()
iter_ += 1
logging('lr {}'.format(opt_dict["lr"]))
discriminator.eval()
with torch.no_grad():
loss, acc = test(discriminator, val_data_batch, val_labels_batch, "VAL", args)
# print(au_var)
if loss < best_loss:
logging('update best loss')
best_loss = loss
best_acc = acc
print(args.save_path)
torch.save(discriminator.state_dict(), args.save_path)
if loss > opt_dict["best_loss"]:
opt_dict["not_improved"] += 1
if opt_dict["not_improved"] >= decay_epoch and epoch >= args.load_best_epoch:
opt_dict["best_loss"] = loss
opt_dict["not_improved"] = 0
opt_dict["lr"] = opt_dict["lr"] * lr_decay
discriminator.load_state_dict(torch.load(args.save_path))
logging('new lr: %f' % opt_dict["lr"])
decay_cnt += 1
if args.opt == "sgd":
optimizer = optim.SGD(discriminator.parameters(), lr=opt_dict["lr"], momentum=args.momentum)
opt_dict['lr'] = opt_dict["lr"]
elif args.opt == "adam":
optimizer = optim.Adam(discriminator.parameters(), lr=opt_dict["lr"])
opt_dict['lr'] = opt_dict["lr"]
else:
raise ValueError("optimizer not supported")
else:
opt_dict["not_improved"] = 0
opt_dict["best_loss"] = loss
if decay_cnt == max_decay:
break
if epoch % args.test_nepoch == 0:
with torch.no_grad():
loss, acc = test(discriminator, test_data_batch, test_labels_batch, "TEST", args)
discriminator.train()
# compute importance weighted estimate of log p(x)
discriminator.load_state_dict(torch.load(args.save_path))
discriminator.eval()
with torch.no_grad():
loss, acc = test(discriminator, test_data_batch, test_labels_batch, "TEST", args)
# print(au_var)
return acc
default=0,
help='if true, turn on schedule sampling')
parser.add_argument('--plot_freq',
type=int,
default=30,
help='number of epochs to save model')
parser.add_argument('--save_freq',
type=int,
default=60,
help='number of epochs to save model')
opt = parser.parse_args()
if opt.model_dir != '':
# load model and continue training from checkpoint
saved_model = torch.load('%s/model.pth' % opt.model_dir)
optimizer = opt.optimizer
model_dir = opt.model_dir
opt = saved_model['opt']
opt.optimizer = optimizer
opt.model_dir = model_dir
opt.log_dir = '%s/continued' % opt.log_dir
else:
name = 'model=%s%dx%d-rnn_size=%d-predictor-posterior-prior-rnn_layers=%d-%d-%d-n_past=%d-n_future=%d-lr=%.4f-g_dim=%d-z_dim=%d-last_frame_skip=%s-beta=%.7f%s-use_action=%d-schedule_sampling=%d' % (
opt.model, opt.image_width, opt.image_width, opt.rnn_size,
opt.predictor_rnn_layers, opt.posterior_rnn_layers,
opt.prior_rnn_layers, opt.n_past, opt.n_future, opt.lr, opt.g_dim,
opt.z_dim, opt.last_frame_skip, opt.beta, opt.name, opt.use_action,
opt.schedule_sampling)
if opt.dataset == 'smmnist':
opt.log_dir = '%s/%s-%d/%s' % (opt.log_dir, opt.dataset,
p = (0.6, 0.2)[args.version == 'RFB_mobile']
num_classes = (21, 81)[args.dataset == 'COCO']
batch_size = args.batch_size
weight_decay = 0.0005
gamma = 0.1
momentum = 0.9
if args.visdom:
import visdom
viz = visdom.Visdom()
net = build_net(img_dim, num_classes)
print(net)
if not args.resume_net:
base_weights = torch.load(args.basenet)
print('Loading base network...')
net.base.load_state_dict(base_weights)
def xavier(param):
init.xavier_uniform(param)
def weights_init(m):
for key in m.state_dict():
if key.split('.')[-1] == 'weight':
if 'conv' in key:
init.kaiming_normal(m.state_dict()[key], mode='fan_out')
if 'bn' in key:
m.state_dict()[key][...] = 1
def main():
params = dict()
params['batch_size'] = 1
params['data_dir'] = args.path_to_train_data
params['major'] = 'users'
params['itemIdInd'] = 1
params['userIdInd'] = 0
print("Loading training data")
data_layer = input_layer.UserItemRecDataProvider(params=params)
print("Data loaded")
print("Total items found: {}".format(len(data_layer.data.keys())))
print("Vector dim: {}".format(data_layer.vector_dim))
print("Loading eval data")
eval_params = copy.deepcopy(params)
# must set eval batch size to 1 to make sure no examples are missed
eval_params['batch_size'] = 1
eval_params['data_dir'] = args.path_to_eval_data
eval_data_layer = input_layer.UserItemRecDataProvider(
params=eval_params,
user_id_map=data_layer.userIdMap,
item_id_map=data_layer.itemIdMap)
rencoder = model.AutoEncoder(
layer_sizes=[data_layer.vector_dim] +
[int(l) for l in args.hidden_layers.split(',')],
nl_type=args.non_linearity_type,
is_constrained=args.constrained,
dp_drop_prob=args.drop_prob,
last_layer_activations=not args.skip_last_layer_nl)
path_to_model = Path(args.save_path)
if path_to_model.is_file():
print("Loading model from: {}".format(path_to_model))
rencoder.load_state_dict(torch.load(args.save_path))
print('######################################################')
print('######################################################')
print('############# AutoEncoder Model: #####################')
print(rencoder)
print('######################################################')
print('######################################################')
rencoder.eval()
if use_gpu: rencoder = rencoder.cuda()
inv_userIdMap = {v: k for k, v in data_layer.userIdMap.items()}
inv_itemIdMap = {v: k for k, v in data_layer.itemIdMap.items()}
eval_data_layer.src_data = data_layer.data
with open(args.predictions_path, 'w') as outf:
for i, ((out, src), majorInd) in enumerate(
eval_data_layer.iterate_one_epoch_eval(for_inf=True)):
inputs = Variable(
src.cuda().to_dense() if use_gpu else src.to_dense())
targets_np = out.to_dense().numpy()[0, :]
outputs = rencoder(inputs).cpu().data.numpy()[0, :]
non_zeros = targets_np.nonzero()[0].tolist()
major_key = inv_userIdMap[majorInd]
for ind in non_zeros:
outf.write("{}\t{}\t{}\t{}\n".format(major_key,
inv_itemIdMap[ind],
outputs[ind],
targets_np[ind]))
if i % 10000 == 0:
print("Done: {}".format(i))
json.dump(dd, json_file, ensure_ascii=False)
print('json finished')
pose_path = 'weights_pose/model.pt'
jitter_path = 'weights/model.pt'
data_pose = Data_pose()
data_jitter = Data()
model_pose = MGN_pose().to('cuda')
model_jitter = MGN().to('cuda')
print('start evaluate')
model_pose.load_state_dict(torch.load(pose_path))
model_jitter.load_state_dict(torch.load(jitter_path))
model_pose.eval()
model_jitter.eval()
qf_pose = extract_feature_pose(model_pose, tqdm(data_pose.query_loader)).numpy()
gf_pose = extract_feature_pose(model_pose, tqdm(data_pose.test_loader)).numpy()
qf_jitter = extract_feature(model_jitter, tqdm(data_jitter.query_loader)).numpy()
gf_jitter = extract_feature(model_jitter, tqdm(data_jitter.test_loader)).numpy()
qf = np.concatenate((qf_pose, qf_jitter), 1)
gf = np.concatenate((gf_pose, gf_jitter), 1)
# setup optimizer
optimizer = optim.SGD(
net.parameters(),
lr=opt.lr,
momentum=0.9,
weight_decay=5e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, T_max=total_epoch, eta_min=1e-4)
# setup checkpoint
if opt.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isdir(path), 'Error: no checkpoint directory found!'
checkpoint = torch.load(os.path.join(path, 'best_model.pth'))
net.load_state_dict(checkpoint['net'])
best_Test_acc = checkpoint['acc']
best_Test_acc_epoch = checkpoint['epoch']
start_epoch = checkpoint['epoch'] + 1
for x in range(start_epoch):
scheduler.step()
else:
print('==> Preparing %s %s %d' %(opt.model, opt.dataset, total_epoch))
print('==> Building model..')
# covert net to GPU
if use_cuda:
net = net.cuda()
def main(grid):
# size of obstacle block
global size
size = 1
# Load trained model for path generation
global mlp
mlp = MLP(32, 2) # simple @D
mlp.load_state_dict(
torch.load('models/mlp_100_4000_PReLU_ae_dd_final_pb0.pkl')
) #newccfinaldata.pkl'))#_pba.pkl'))
#mlp.load_state_dict(torch.load('models/mlp_100_4000_PReLU_ae_dd_finalnew100.pkl'))
if torch.cuda.is_available():
mlp.cuda()
agent: Agent = grid.agent
goal: Goal = grid.goal
obstaclespb: Obstacle = grid.obstacles
global xw
global yw
xw = grid.size.width
yw = grid.size.height
# make empty map
# mp = [[1 for i in range(yw)] for i in range(xw)]
# zero array of 1 x n x 2 (each row is an obstacle's coordinates )
global oblen
oblen = 1400
#oblen = len(obstaclespb)
print('len(obs)', len(obstaclespb))
#print('obstacles', obstaclespb[5].position.x, obstaclespb[5].position.y)
global obc
obc = np.zeros((1, oblen, 2), dtype=np.int32)
count = 0
for i in range(0, 1):
for ob in obstaclespb:
# this if statement is for houseexpo maps
#if ob.position.x >=20 and ob.position.x <= 82 and ob.position.y >=5 and ob.position.y <= 95:
obc[0][count][0] = ob.position.x
obc[0][count][1] = ob.position.y
count += 1
#print(ob.position.x, ob.position.y)
# if count ==1400:
# break
#print('idx ----',idx)
# array of obstacle coordinates
print('obc --------', obc[0][:20])
print("obc.size -----------", obc.size)
number1 = obc.size
global counter99
counter99 = int(len(obstaclespb))
counter = count
#print('counter ------',counter)
if counter != 1400:
for i in range(0, 1):
while counter != 1400:
#for idx,ob in enumerate(obstaclespb):
obc[0][counter][0] = obc[0][0][0]
obc[0][counter][1] = obc[0][0][1]
counter += 1
# obs_rep set up
Q = Encoder()
Q.load_state_dict(
torch.load('./models/cae_encoderpb1.pkl')) #.pkl'))#pb1.pkl'))
#Q.load_state_dict(torch.load('./models/cae_encoder_withitem.pkl'))
if torch.cuda.is_available():
Q.cuda()
obs_rep = np.zeros((1, 28), dtype=np.float32)
k = 0
for i in range(0, 1):
#temp=np.fromfile('./models/obc0.dat')
temp = obc
# for i in range(0,1):
# for idx,ob in enumerate(obstaclespb):
# obc[0][idx][0]=ob.position.x
# obc[0][idx][1]=ob.position.y
# nx2 matrix of all obstacles' coordinates (2800 elements)
newtemp = np.zeros((1400, 2), dtype=np.int32) #float32)
temp = temp.reshape(temp.size // 2, 2)
#print('temp88888',temp.shape)
newtemp[0:oblen, 0:] = temp
#print("newtempppppppp",newtemp)
obstacles = np.zeros((1, 2800), dtype=np.int32) #float32)
#print("obstacles",obstacles,"\nlen",obstacles.size)
obstacles[0] = newtemp.flatten()
inp = torch.from_numpy(obstacles).float() ## added .float() at end
#print("obstacles",obstacles[0],"\nlen",obstacles.size)
#inp=Variable(inp).cuda()
inp = Variable(inp).cpu()
output = Q(inp)
output = output.data.cpu()
#print('output--------------',output.numpy())
obs_rep[k] = output.numpy()
#print("obs_rep",obs_rep[0],"\nlen",obs_rep.size)
k = k + 1
## calculating length of the longest trajectory
# max_length=0
# path_lengths=np.zeros((N,NP),dtype=np.int8)
# for i in range(0,N):
# for j in range(0,NP):
# fname='./dataset2/e'+str(i+s)+'/path'+str(j+sp)+'.dat'
# if os.path.isfile(fname):
# path=np.fromfile(fname)
# path=path.reshape(len(path)//2,2)
# path_lengths[i][j]=len(path)
# if len(path)> max_length:
# max_length=len(path)
# paths=np.zeros((N,NP,max_length,2), dtype=np.float32) ## padded paths
# for i in range(0,N):
# for j in range(0,NP):
# fname='./dataset2/e'+str(i+s)+'/path'+str(j+sp)+'.dat'
# if os.path.isfile(fname):
# path=np.fromfile(fname)
# path=path.reshape(len(path)//2,2)
# for k in range(0,len(path)):
# paths[i][j][k]=path[k]
#print("______________________________________________________________________")
#obc is nx2 matrix of all obstacle coordinates
#obs_rep
#paths is coordinates provided in path file
#path_length is number of coordinates (waypoint) of the path
#print("obc ----", obc)
#print('length of obc', len(obc))
#print("obs_rep (latent space model) ----", obs_rep)
#print("paths ----", paths)
#print("path_lengths ----", path_lengths)
i = 0
j = 0
tp = 0
fp = 0
tot = []
et = []
p1_ind = 0
p2_ind = 0
p_ind = 0
#if path_lengths[i][j]>0:
#
start = np.zeros((2), dtype=np.int32) #float32)
goals = np.zeros((2), dtype=np.int32) #float32)
# load start and goal position
for l in range(0, 1):
start[l] = agent.position.x
start[l + 1] = agent.position.y
for l in range(0, 1):
goals[l] = goal.position.x
goals[l + 1] = goal.position.y
#print('start and goal', start,goals)
#start and goal for bidirectional generation
## starting point
start1 = torch.from_numpy(start)
goal2 = torch.from_numpy(start)
##goal point
goal1 = torch.from_numpy(goals)
start2 = torch.from_numpy(goals)
oldstart2 = start2
##obstacles
obs = obs_rep[0]
#print('start1 and start2',start1, start2)
#print("______________________________________________________________________")
#print("\n")
#print("---- planning starts ")
#print("\n")
#print("______________________________________________________________________")
#print ('obs torch', obs)
obs = torch.from_numpy(obs)
#print ('obs torch2', len(obs))
##generated paths
path1 = []
path1.append(start1)
path2 = []
path2.append(start2)
path = []
target_reached = 0
step = 0
path = [] # stores end2end path by concatenating path1 and path2
tree = 0
tic = time.clock() #perf_counter
newstart1 = None
newstart2 = None
# start planning with network
while target_reached == 0 and step < 300:
step = step + 1
if tree == 0:
#while start
oldstart = start1
#print('oldstart =',oldstart)
inp1 = torch.cat((obs, start1, start2)).float()
#print('inpl---1',inp1)
inp1 = to_var(inp1) #.float()
#print('inpl---2',inp1)
start1 = mlp(inp1) #.float()
#print('start1---1',start1)
start1 = start1.data.cpu()
print('start1---2', start1)
#if start1
#print ('#############################################start1 and inp1',start1, inp1)
#print ('plan from start: ',start1[0], start1[1])
if (start1[0] >= 0
and start1[0] < xw - 0.5) and (start1[1] >= 0
and start1[1] < yw - 0.5):
#if (start1[0]>=20 and start1[0]<82-0.5) and (start1[1]>=5 and start1[1]<95-0.5):
#if (start1[0]>=22 and start1[0]<77-0.5) and (start1[1]>=49 and start1[1]<71-0.5):
path1.append(start1)
tree = 1
# else:
# start1 = oldstart
# tree=0
else:
start1 = oldstart
tree = 0
else:
#while True:
oldstart2 = start2
inp2 = torch.cat((obs, start2, start1)).float()
#print('inp2---1',inp2)
inp2 = to_var(inp2) #.float()
#print('inp2---1',inp2)
start2 = mlp(inp2) #.float()
#print('start2---1',start2)
start2 = start2.data.cpu()
print('start2---2', start2)
#print ('plan from end: ',start2[0], start2[1])
if (start2[0] >= 0
and start2[0] < xw - 0.5) and (start2[1] >= 0
and start2[1] < yw - 0.5):
#if (start2[0]>=20 and start2[0]<82-0.5) and (start2[1]>=5 and start2[1]<95-0.5):
#if (start2[0]>=22 and start2[0]<77-0.5) and (start2[1]>=49 and start2[1]<71-0.5):
path2.append(start2)
tree = 0
# else:
# start2 = oldstart2
# tree=1
else:
start2 = oldstart2
tree = 1
#check if a straight line can be connected between the 2 points
# steerTo is taking a long time
if (list(oldstart) != list(start1)
and tree != 0) or (list(oldstart2) != list(start2)
and tree != 1):
target_reached = steerTo(start1, start2, i, counter99, grid)
#print('-----------------------target_reached-------------------------',target_reached)
tp = tp + 1
if target_reached == 1:
for p1 in range(0, len(path1)):
path.append(path1[p1])
for p2 in range(len(path2) - 1, -1, -1):
path.append(path2[p2])
#print ('path before lvc = ', path)
path = lvc(path, i, counter99, grid) #oblen)
#print ('path after lvc = ', path)
#print('*************feasibility_check start*************')
indicator = feasibility_check(path, i, counter99, grid) #oblen)
#print('---------------------------indictor = ', indicator)
if indicator == 0:
for count1 in range(len(path)):
path[count1] = path[count1]
#print('--------------------------path = ', path)
if indicator == 1:
for count1 in range(len(path)):
path[count1] = [
round(path[count1].tolist()[0]),
round(path[count1].tolist()[1])
]
#print('path[count1]===', path[count1])
#print('--------------------------path = ', path)
if indicator == 1:
#print ("_______________________________")
print("planning is done")
# toc = time.clock() #time.perf_counter
# t=toc-tic
# et.append(t)
# print ("path[0]:")
# for p in range(0,len(path)):
# print (path[p][0])
# print ("path[1]:")
# for p in range(0,len(path)):
# print (path[p][1])
else:
sp = 0
indicator = 0
#print("______________________________________________________________________")
#print("\n")
#print("----- path is invalid. need to replan now ")
#print("\n")
#print("______________________________________________________________________")
while indicator == 0 and sp < 10 and path != 0:
sp = sp + 1
g = np.zeros(2, dtype=np.int32)
#print('path[-1] ============', [path[-1][0],path[-1][1]])
# g gives the last point in path
g = torch.from_numpy(np.array(
[path[-1][0],
path[-1][1]])) #paths[i][j][path_lengths[i][j]-1])
#print('g --',g)
#replan at coarse level -> while for map constraint
path = replan_path(
path, g, i, obs, counter99, grid,
linepath) #oblen) #replanning at coarse level
#print('new path --', path)
#print('indicator --', indicator)
if path != 0:
# condense new path and check if new path is feasible
path = lvc(path, i, counter99, grid) #oblen)
indicator = feasibility_check(path, i, counter99, grid)
#print('inside indicator --', indicator)
if indicator == 1:
#print ("_______________________________")
#print ("planning is done")
for count1 in range(len(path)):
path[count1] = [
round(path[count1].tolist()[0]),
round(path[count1].tolist()[1])
]
#print('path[count1]===', path[count1])
#print('--------------------------path = ', path)
# toc = time.clock()
# t=toc-tic
# if len(path)<20:
# print ("new_path[0]:")
# for p in range(0,len(path)):
# print (path[p][0])
# print ("new_path[1]:")
# for p in range(0,len(path)):
# print (path[p][1])
# print ("path found, dont worry")
if indicator == 0:
return path == None
else:
return path == None
#print('final path', path)
return path
you shuld use this script in this way:
python trainVAE_D.py <epoches> <batch_size> <pretrainD?> <traindatafilename> <styledatafilename> ganName
for instance:
python trainVAE_D.py 1000 20 yes/no ./data/trainDataOfIndex.npy ./data/style ./Model/gan.pkl
"""
booldic = {'yes':True,
'y':True,
'Y':True,
'Yes':True,
'YES':True,
'no':False,
'N':False,
'n':False,
'NO':False,
'No':False,}
ds = torch.load('./Model/Ds.pkl').cuda()
ds_emb = torch.load('./Model/Ds_emb.pkl').cuda()
train_data = np.load(sys.argv[4])
epoches = int(sys.argv[1])
batch_size = int(sys.argv[2])
pretrainD = booldic[sys.argv[3]]
trainVAE_D(epoches,batch_size,train_data,ds,ds_emb,pretrainD)
print("finished trainning.......................")
scores.append(
sentence_bleu([ref], hyp, smoothing_function=cc.method3) * 100.)
print('BLEU: {:.4}'.format(sum(scores) / len(test_pairs)))
if __name__ == "__main__":
'''
Evaluation is mostly the same as training,
but there are no targets so we simply feed the decoder's predictions back to itself for each step.
Every time it predicts a word, we add it to the output string,
and if it predicts the EOS token we stop there.
'''
config = argparser()
input_lang, output_lang, pairs = loader.prepareData('eng', 'fra', True)
encoder = seq2seq.LSTMEncoder(input_size=input_lang.n_words,
embedding_size=config.embedding_size,
hidden_size=config.hidden_size).to(device)
decoder = seq2seq.LSTMDecoder(output_size=output_lang.n_words,
embedding_size=config.embedding_size,
hidden_size=config.hidden_size).to(device)
encoder.load_state_dict(torch.load(config.encoder))
encoder.eval()
decoder.load_state_dict(torch.load(config.decoder))
decoder.eval()
evaluateiters(pairs, encoder, decoder)
def resume(self, args):
resume_model_file = args.output + "/pytorch_model.bin"
logging.info("=> loading checkpoint '{}'".format(resume_model_file))
checkpoint = torch.load(resume_model_file, map_location='cpu')
self.model.load_state_dict(checkpoint)
return best_epoch
def compute_test(loader, which="val"):
model.eval()
correct = 0.0
loss_test = 0.0
testResult = []
asli = []
for data in loader:
data = data.to(args.device)
out = model(data)
pred = out.max(dim=1)[1]
testResult.append(pred)
asli.append(data.y)
correct += pred.eq(data.y).sum().item()
loss_test += F.nll_loss(out, data.y).item()
# print("test results", testResult)
# print("asli results", asli)
return correct / len(loader.dataset), loss_test
if __name__ == '__main__':
best_model = train()
# Restore best model for test set
model.load_state_dict(torch.load('{}.pth'.format(best_model)))
print("ALL DONE")
test_acc, test_loss = compute_test(test_loader,"test")
print('Test set results, loss = {:.6f}, accuracy = {:.6f}'.format(test_loss, test_acc))
def fit(model_params, ts, vs, es, **kwargs):
"""
Train a dependency parser using PyTorch
:param model_params: The model to train
:param ts: A training data set
:param vs: A validation data set
:param es: A test data set, can be None
:param kwargs: See below
:Keyword Arguments:
* *do_early_stopping* (``bool``) -- Stop after eval data is not improving. Default to True
* *epochs* (``int``) -- how many epochs. Default to 20
* *outfile* -- Model output file, defaults to classifier-model.pyth
* *patience* --
How many epochs where evaluation is no longer improving before we give up
* *reporting* --
Callbacks which may be used on reporting updates
* *optim* --
Optimizer to use, defaults to `sgd`
* *eta, lr* (``float``) --
Learning rate, defaults to 0.01
* *mom* (``float``) --
Momentum (SGD only), defaults to 0.9 if optim is `sgd`
:return:
"""
do_early_stopping = bool(kwargs.get('do_early_stopping', True))
verbose = kwargs.get('verbose', {'console': kwargs.get('verbose_console', False), 'file': kwargs.get('verbose_file', None)})
epochs = int(kwargs.get('epochs', 20))
model_file = get_model_file('deps', 'pytorch', kwargs.get('basedir'))
output = kwargs.get('output')
txts = kwargs.get('txts')
num_loader_workers = int(kwargs.get('num_loader_workers', 0))
pin_memory = bool(kwargs.get('pin_memory', True))
if not isinstance(ts, DataLoader):
ts = DataLoader(ts, num_workers=num_loader_workers, batch_size=None, pin_memory=pin_memory)
if not isinstance(vs, DataLoader):
vs = DataLoader(vs, batch_size=None, pin_memory=pin_memory)
if es and not isinstance(es, DataLoader):
es = DataLoader(es, batch_size=None, pin_memory=pin_memory)
best_metric = 0
if do_early_stopping:
early_stopping_metric = kwargs.get('early_stopping_metric', 'acc')
early_stopping_cmp, best_metric = get_metric_cmp(early_stopping_metric, kwargs.get('early_stopping_cmp'))
patience = kwargs.get('patience', epochs)
logger.info('Doing early stopping on [%s] with patience [%d]', early_stopping_metric, patience)
reporting_fns = listify(kwargs.get('reporting', []))
logger.info('reporting %s', reporting_fns)
trainer = create_trainer(model_params, **kwargs)
last_improved = 0
for epoch in range(epochs):
trainer.train(ts, reporting_fns)
test_metrics = trainer.test(vs, reporting_fns)
if do_early_stopping is False:
trainer.save(model_file)
elif early_stopping_cmp(test_metrics[early_stopping_metric], best_metric):
last_improved = epoch
best_metric = test_metrics[early_stopping_metric]
logger.info('New best %.3f', best_metric)
trainer.save(model_file)
elif (epoch - last_improved) > patience:
logger.info('Stopping due to persistent failures to improve')
break
if do_early_stopping is True:
logger.info('Best performance on %s: %.3f at epoch %d', early_stopping_metric, best_metric, last_improved)
if es is not None:
logger.info('Reloading best checkpoint')
model = torch.load(model_file)
trainer = create_trainer(model, **kwargs)
test_metrics = trainer.test(es, reporting_fns, phase='Test', verbose=verbose, output=output, txts=txts)
return test_metrics
