def main():
"""
Testing the convolutional example on the mnist dataset.
"""
dataset = ConvMNIST(64)
print(dataset.get_train().x.shape)
inputs = Value(type=tf.float32, shape=(None, 28, 28, 1), cls=None)
targets = Value(type=tf.int64, shape=(None), cls=10)
learning_rate = 0.0001
fc_hidden = [1024, 500]
c_h = [(3, 3, 1, 32), (3, 3, 32, 64)]
conv_hidden = ConvHidden(conv_weights=c_h, fc_weights=fc_hidden)
config = Config(inputs, targets, conv_hidden, learning_rate)
network = ConvNetworkBuilder(config)
hidden = FFConvHiddenBuilder()
_ = network.build_network(hidden)
train_config = TrainerConfig(epochs=EPOCHS,
display_after=DISPLAY_STEP,
keep_prob=KEEP_PROB,
checkpoint_path=None,
summary_path=None)
trainer = Trainer(network, train_config)
trainer.train(dataset)
def main():
"""
Testing the convolutional example on the mnist dataset.
"""
dataset = RNNMNIST(BATCH_SIZE)
print(dataset.get_train().y.shape)
in_shape = (None, N_STEPS, N_INPUT)
inputs = Value(type=tf.float32, shape=in_shape, cls=None)
targets = Value(type=tf.int32, shape=(None), cls=10)
fc_hidden = [500, 150]
rnn_config = RNNHidden(rnn_weights=RNN_HIDDEN,
depth=1,
fc_weights=fc_hidden)
config = Config(inputs, targets, rnn_config, LEARNING_RATE)
network = ConvNetworkBuilder(config)
hidden = SimpleRNNBuilder()
_ = network.build_network(hidden)
train_config = TrainerConfig(epochs=EPOCHS,
display_after=DISPLAY_STEP,
keep_prob=KEEP_PROB,
checkpoint_path=None,
summary_path=None)
trainer = Trainer(network, train_config)
trainer.train(dataset)
def start_exp(args):
trainer = Trainer(dataset_dict[args.dataset], args.cuda)
results = trainer.train_model(args)
if not path.exists('results'):
os.mkdir('results')
f = open(
"results/" + args.dataset + '_teacher_emb_' +
str(args.teacher_embed_size) + '_teacher_heads_' +
str(args.teacher_n_heads) + '_window_' + str(args.window) +
'_student_emb_' + str(args.student_emb) + '_student_heads_' +
str(args.student_heads) + '_distillation_' + str(args.distillation) +
'.pkl', "wb")
pkl.dump(results, f)
f.close()
def get_trainer(self, config, model, optimizer, loss, train_loader,
test_loader):
if self.trainer_id == 0:
return Trainer(config, model, optimizer, loss, train_loader,
test_loader)
else:
raise NameError('Trainer id unknown {}'.format(self.trainer_id))
def main():
opt = TrainOptions().parse()
# create dataloaders for each phase
dataloaders = create_dataloader(opt)
print("type of subset: ", type(dataloaders[0]))
# Create model
model = create_model(opt)
model.setup(
opt) # regular setup: load and print networks; create schedulers
visualizer = Visualizer(
opt) # create a visualizer that display/save images and plots
# initialize trainer
trainer = Trainer(dataloaders, model, visualizer, opt)
trainer.train()
def main():
args = get_args()
m_config = process_config(args.config)
config = tf.ConfigProto(log_device_placement=False)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
# create_dirs([config.summary_dir, config.checkpoint_dir])
data_loader = SiameseDataLoader(config=m_config)
model = ConvNet(data_loader=data_loader, config=m_config)
logger = Logger(sess=sess, config=m_config)
trainer = Trainer(sess=sess,
model=model,
config=m_config,
logger=logger,
data_loader=data_loader)
trainer.train()
def main():
"""
Testing the feedforward framework on the mnist dataset.
"""
dataset = MNIST(BATCH_SIZE)
inputs = Value(type=tf.float32, shape=(None, 784), cls=None)
targets = Value(type=tf.int64, shape=(None), cls=10)
fc_hidden = FCHidden(weights=[300, 150])
config = Config(inputs, targets, fc_hidden, LEARNING_RATE)
network_builder = FFNetworkBuilder(config)
hidden_builder = FFHiddenBuilder()
_ = network_builder.build_network(hidden_builder)
train_config = TrainerConfig(epochs=EPOCHS,
display_after=DISPLAY_STEP,
keep_prob=KEEP_PROB,
checkpoint_path=None,
summary_path=None)
trainer = Trainer(network_builder, train_config)
trainer.train(dataset)
all_gram_idx = torch.arange(
self.n_gram).cuda() if use_cuda else torch.arange(self.n_gram)
all_vocab_idx = torch.arange(
self.vocab_size).cuda() if use_cuda else torch.arange(
self.vocab_size)
position_matrix = self.C(all_gram_idx).reshape(-1, self.embedding_dim,
self.embedding_dim)
context_features = torch.tensordot(context_word_features,
position_matrix)
all_word = self.embeddings_word_output(all_vocab_idx)
decoded = torch.mm(
context_features,
all_word.T) + self.embedding_bias(all_vocab_idx).view(-1)
logits = F.log_softmax(decoded, dim=1)
return logits
TEXT, train_iter, val_iter, test_iter = get_iter(args.batch_size)
model = LBLModel(TEXT=TEXT,
embedding_dim=args.embedding_dim,
batch_size=args.batch_size,
n_gram=args.n_gram)
if use_cuda:
model.cuda()
trainer = Trainer(train_iter=train_iter,
val_iter=val_iter,
TEXT=TEXT,
lr=args.lr,
n_gram=args.n_gram)
trainer.train_model(model=model, num_epochs=args.num_epochs)
self.vocab_size).cuda() if use_cuda else torch.arange(
self.vocab_size)
context_word_boxes.data = torch.mean(context_word_boxes.data,
dim=1).view(
-1, 1, 2, self.embedding_dim)
all_word = self.embeddings_word(all_vocab_idx * self.n_gram)
all_word.data = all_word.data.view(1, self.vocab_size, 2,
self.embedding_dim)
dec = all_word.intersection_log_soft_volume(context_word_boxes)
decoded = dec + self.embedding_bias(all_vocab_idx).view(-1)
logits = F.log_softmax(decoded, dim=1)
return logits
TEXT, train_iter, val_iter, test_iter = get_iter(args.batch_size)
model = BoxModel(TEXT=TEXT,
embedding_dim=args.embedding_dim,
batch_size=args.batch_size,
n_gram=args.n_gram)
if use_cuda:
model.cuda()
trainer = Trainer(train_iter=train_iter,
val_iter=val_iter,
TEXT=TEXT,
lr=args.lr,
n_gram=args.n_gram)
trainer.train_model(model=model, num_epochs=args.num_epochs)
smoothing=cfg['model']['smoothing'])
testset = PixWiseDataset(root_dir=cfg['dataset']['root'],
csv_file=cfg['dataset']['test_set'],
map_size=cfg['model']['map_size'],
transform=test_transform,
smoothing=cfg['model']['smoothing'])
trainloader = torch.utils.data.DataLoader(
dataset=trainset,
batch_size=cfg['train']['batch_size'],
shuffle=True,
num_workers=0)
testloader = torch.utils.data.DataLoader(dataset=testset,
batch_size=cfg['test']['batch_size'],
shuffle=True,
num_workers=0)
trainer = Trainer(cfg=cfg,
network=network,
optimizer=optimizer,
loss=loss,
lr_scheduler=None,
device=device,
trainloader=trainloader,
testloader=testloader,
writer=writer)
trainer.train()
writer.close()
position_matrix,
dim=1)
if args.sep_output:
all_word = self.embeddings_word_output(all_vocab_idx)
else:
all_word = self.embeddings_word(all_vocab_idx)
decoded = torch.mm(
context_features,
all_word.T) + self.embedding_bias(all_vocab_idx).view(-1)
logits = F.log_softmax(decoded, dim=1)
return logits
TEXT, train_iter, val_iter, test_iter = get_iter(args.batch_size, args.dataset)
model = LBLModel(TEXT=TEXT,
embedding_dim=args.embedding_dim,
batch_size=args.batch_size,
n_gram=args.n_gram)
if use_cuda:
model.cuda()
trainer = Trainer(train_iter=train_iter,
val_iter=val_iter,
TEXT=TEXT,
lr=args.lr,
n_gram=args.n_gram)
trainer.train_model(model=model,
num_epochs=args.num_epochs,
path=wandb.run.dir)
if args["multiG_overwrite"] is True:
DICT_DIR_train = f"{DIR}/data/dict/{id2lang[0]}/{id2lang[0]}-{id2lang[1]}.0-5000.txt"
DICT_DIR_test = f"{DIR}/data/dict/{id2lang[0]}/{id2lang[0]}-{id2lang[1]}.5000-6500.txt"
KG1 = KG()
KG2 = KG()
KG1.load_data(dir=KG_DIR, id=0, emb_path=args["emb_ew1"])
KG2.load_data(dir=KG_DIR, id=1, emb_path=args["emb_ew2"])
multiG1 = multiG(KG1, KG2, id2lang[0], id2lang[1])
multiG1.load_align(KG_DIR=KG_DIR)
multiG1.load_bidict(DICT_DIR_train=DICT_DIR_train,
DICT_DIR_test=DICT_DIR_test)
# multiG1.save(f"{DIR}/data/KG/{DATASET}/{id2lang[0]}_{id2lang[1]}")
else:
multiG1 = multiG()
multiG1.load(args["multiG"])
if args["restore"] == False:
this_trainer = Trainer(multiG1, args["SG_corpus0"], args["SG_corpus1"],
args, args_SG)
else:
this_model = torch.load(args["load_path"])
this_trainer = Trainer(multiG1,
args["SG_corpus0"],
args["SG_corpus1"],
args,
args_SG,
this_model,
restore=True)
this_trainer.train_all()
def __init__(self):
Trainer.__init__(self)
from model.network import build_d
from model.vunet.vae_unet import *
import yaml
from trainer.Trainer import Trainer
import os
from generator.dataIter import DataIter
os.environ['CUDA_VISIBLE_DEVICE'] = '0'
if __name__ == '__main__':
with open('config/config.yaml') as f:
config = yaml.load(f, Loader=yaml.FullLoader)
vunet = Vunet()
g_net = vunet.net
d_net = build_d(config)
g_net.summary()
d_net.summary()
dataIter = DataIter(
'/media/newbot/software/Pose-Transfer-master/fashion_data/train/',
'/media/newbot/software/Pose-Transfer-master/fashion_data/trainK/',
'/media/newbot/software/Pose-Transfer-master/fashion_data/fasion-resize-pairs-train.csv',
batch_size=config['batch_size'])
trainer = Trainer(config, g_net, d_net, dataIter)
if not os.path.exists(
'/media/newbot/software/Pose-Transfer-master/fashion_data'):
raise Exception
trainer.train()