def test_cells(self):
for cell in [nn.RNN, nn.GRU, nn.LSTM]:
Encoder(10, 5, cell=cell)
with self.assertRaises(ValueError):
Encoder(10, 5, object)
def __init__(self, params, experience_replay_buffer,metrics,results_dir,env):
self.parms = params
self.D = experience_replay_buffer
self.metrics = metrics
self.env = env
self.tested_episodes = 0
self.statistics_path = results_dir+'/statistics'
self.model_path = results_dir+'/model'
self.video_path = results_dir+'/video'
self.rew_vs_pred_rew_path = results_dir+'/rew_vs_pred_rew'
self.dump_plan_path = results_dir+'/dump_plan'
#if folder do not exists, create it
os.makedirs(self.statistics_path, exist_ok=True)
os.makedirs(self.model_path, exist_ok=True)
os.makedirs(self.video_path, exist_ok=True)
os.makedirs(self.rew_vs_pred_rew_path, exist_ok=True)
os.makedirs(self.dump_plan_path, exist_ok=True)
# Create models
self.transition_model = TransitionModel(self.parms.belief_size, self.parms.state_size, self.env.action_size, self.parms.hidden_size, self.parms.embedding_size, self.parms.activation_function).to(device=self.parms.device)
self.observation_model = ObservationModel(self.parms.belief_size, self.parms.state_size, self.parms.embedding_size, self.parms.activation_function).to(device=self.parms.device)
self.reward_model = RewardModel(self.parms.belief_size, self.parms.state_size, self.parms.hidden_size, self.parms.activation_function).to(device=self.parms.device)
self.encoder = Encoder(self.parms.embedding_size,self.parms.activation_function).to(device=self.parms.device)
self.param_list = list(self.transition_model.parameters()) + list(self.observation_model.parameters()) + list(self.reward_model.parameters()) + list(self.encoder.parameters())
self.optimiser = optim.Adam(self.param_list, lr=0 if self.parms.learning_rate_schedule != 0 else self.parms.learning_rate, eps=self.parms.adam_epsilon)
self.planner = MPCPlanner(self.env.action_size, self.parms.planning_horizon, self.parms.optimisation_iters, self.parms.candidates, self.parms.top_candidates, self.transition_model, self.reward_model,self.env.action_range[0], self.env.action_range[1])
global_prior = Normal(torch.zeros(self.parms.batch_size, self.parms.state_size, device=self.parms.device), torch.ones(self.parms.batch_size, self.parms.state_size, device=self.parms.device)) # Global prior N(0, I)
self.free_nats = torch.full((1, ), self.parms.free_nats, dtype=torch.float32, device=self.parms.device) # Allowed deviation in KL divergence
class INVAE(nn.Module):
def __init__(self, data, nhid=32, latent_dim=16):
super(INVAE, self).__init__()
self.encoder = Encoder(data, nhid, latent_dim)
self.decoder = InverseDecoder(data, latent_dim, nhid)
def reset_parameters(self):
self.encoder.reset_parameters()
self.decoder.reset_parameters()
def recon_loss(self, data, output):
adj_recon = output['adj_recon']
return data.norm * F.binary_cross_entropy_with_logits(adj_recon, data.adjmat, pos_weight=data.pos_weight)
def loss_function(self, data, output):
recon_loss = self.recon_loss(data, output)
mu, logvar = output['mu'], output['logvar']
kl = - 1 / (2 * data.num_nodes) * torch.mean(torch.sum(
1 + 2 * logvar - mu.pow(2) - torch.exp(logvar).pow(2), 1))
return recon_loss + kl
def forward(self, data):
mu, logvar = self.encoder(data)
z = reparameterize(mu, logvar, self.training)
recon_feat = self.decoder(z)
return {'recon_feat': recon_feat, 'z': z, 'mu': mu, 'logvar': logvar}
def main():
parser = argparse.ArgumentParser(description="AAE")
parser.add_argument("--num_epochs", type=int, default=100)
parser.add_argument("--batch_size", type=int, default=64)
parser.add_argument("--device", type=str, default="cuda")
parser.add_argument("--data_root", type=str, default="./data")
parser.add_argument("--data_name", type=str, default="mnist")
parser.add_argument("--distribution", type=str, default="gaussian")
parser.add_argument("--image_size", type=int, default=32)
parser.add_argument("--image_channels", type=int, default=1)
parser.add_argument("--latent_dim", type=int, default=2)
parser.add_argument("--num_classes", type=int, default=10)
opt = parser.parse_args()
os.makedirs("./outputs/encode", exist_ok=True)
os.makedirs("./outputs/decode", exist_ok=True)
os.makedirs("./weights", exist_ok=True)
encoder = Encoder(opt.image_size, opt.image_channels, opt.latent_dim).to(opt.device)
decoder = Decoder(opt.image_size, opt.image_channels, opt.latent_dim).to(opt.device)
discriminator = Discriminator(opt.latent_dim, opt.num_classes, True).to(opt.device)
for epoch in range(opt.num_epochs):
reconstruct_loss, e_loss, d_loss = train(encoder, decoder, discriminator, opt)
print("reconstruct loss: {:.4f} encorder loss: {:.4f} discriminator loss: {:.4f}".format(reconstruct_loss, e_loss, d_loss))
eval_encoder("./outputs/encode/{}.jpg".format(epoch), encoder, opt)
eval_decoder("./outputs/decode/{}.jpg".format(epoch), decoder, opt)
torch.save(encoder.state_dict(), "./weights/encoder.pth")
torch.save(decoder.state_dict(), "./weights/decoder.pth")
torch.save(discriminator.state_dict(), "./weights/discriminator.pth")
def __init__(self):
self.train_lr = 1e-4
self.num_classes = 9
self.clf_target = Classifier().cuda()
self.clf2 = Classifier().cuda()
self.clf1 = Classifier().cuda()
self.encoder = Encoder().cuda()
self.pretrain_lr = 1e-4
self.weights_coef = 1e-3
def save_model():
f_q = Encoder(input_shape)
f_k = Encoder(input_shape)
optimizer = tf.keras.optimizers.Adam(0.01, decay=0.0001)
checkpoint = tf.train.Checkpoint(f_q=f_q, f_k=f_k, optimizer=optimizer)
checkpoint.restore(tf.train.latest_checkpoint('checkpoints'))
if False == os.path.exists('models'): os.mkdir('models')
f_k.save(os.path.join('models', 'resnet50.h5'))
def init_encoder(self):
leaky_relu_parmas = self.encoder_leky_reul
dropout_params = self.encoder_dropout
encoder = Encoder(self.mu_dim, self.update_set_size, leaky_relu_parmas,
dropout_params)
encoder.cuda()
return encoder
def main():
parser = argparse.ArgumentParser(description='Implementation of SimCLR')
parser.add_argument('--EPOCHS',
default=10,
type=int,
help='Number of epochs for training')
parser.add_argument('--BATCH_SIZE',
default=64,
type=int,
help='Batch size')
parser.add_argument('--TEMP',
default=0.5,
type=float,
help='Temperature parameter for NT-Xent')
parser.add_argument(
'--LOG_INT',
default=100,
type=int,
help='How many batches to wait before logging training status')
parser.add_argument('--DISTORT_STRENGTH',
default=0.5,
type=float,
help='Strength of colour distortion')
parser.add_argument('--SAVE_NAME', default='model')
args = parser.parse_args()
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
online_transform = transforms.Compose([
transforms.RandomResizedCrop((32, 32)),
transforms.RandomHorizontalFlip(),
get_color_distortion(s=args.DISTORT_STRENGTH),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])
])
trainset = CIFAR10_new(root='./data',
train=True,
download=True,
transform=online_transform)
# Need to drop last minibatch to prevent matrix multiplication erros
train_loader = torch.utils.data.DataLoader(trainset,
batch_size=args.BATCH_SIZE,
shuffle=True,
drop_last=True)
model = Encoder().to(device)
optimizer = optim.Adam(model.parameters())
loss_func = losses.NTXentLoss(args.TEMP)
for epoch in range(args.EPOCHS):
train(args, model, device, train_loader, optimizer, loss_func, epoch)
torch.save(model.state_dict(), './ckpt/{}.pth'.format(args.SAVE_NAME))
def main(args):
# load datasets
vocab = pickle.load(open(args.vocab_path, 'rb'))
train_data = get_loader(args.json_file,
args.mat_file,
vocab,
args.batch_size,
shuffle=True,
num_workers=args.num_workers)
# get vocab
# build model
if args.encoder:
encoder = Encoder(args.embed_size, True)
decoder = Decoder(args.in_features, len(vocab),
args.embed_size, args.hidden_size)
# define loss and optimizer
criterion = nn.CrossEntropyLoss()
params = list(decoder.parameters())
if args.encoder:
params = list(decoder.parameters()) + list(encoder.cnn.fc.parameters())
optimizer = optim.Adam(params, lr=args.learning_rate)
# train
total_step = len(train_data)
for epoch in range(args.num_epochs):
for i, (images, captions, lengths) in enumerate(train_data):
if args.encoder:
images_features = encoder(Variable(images))
else:
images_features = Variable(images)
captions = Variable(captions)
targets = pack_padded_sequence(
captions, lengths, batch_first=True)[0]
decoder.zero_grad()
outputs = decoder(images_features, captions, lengths)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
if i % args.disp_step == 0:
print('Epoch [%d/%d], step [%d/%d], loss: %.4f, Perplexity: %5.4f'
% (epoch, args.num_epochs, i, total_step, loss.data[0], np.exp(loss.data[0])))
# Save the models
if (i + 1) % args.save_step == 0:
torch.save(decoder.state_dict(),
os.path.join(args.model_path,
'decoder-%d-%d.pkl' % (epoch + 1, i + 1)))
torch.save(encoder.state_dict(),
os.path.join(args.model_path,
'encoder-%d-%d.pkl' % (epoch + 1, i + 1)))
def build_network(self):
print('[info] Build the network architecture')
self.encoder = Encoder(z_dim=self.opt.latent_dim)
if self.opt.dataset == 'SMPL':
num_verts = 6890
elif self.opt.dataset == 'all_animals':
num_verts = 3889
self.decoder = Decoder(num_verts=num_verts, z_dim=self.opt.latent_dim)
self.discriminator = Discriminator(input_dim=self.opt.latent_dim)
self.encoder.cuda()
self.decoder.cuda()
self.discriminator.cuda()
def initEncoderDecoder(self):
if self.opt.dataset == 'SMPL':
num_verts = 6890
elif self.opt.dataset == 'all_animals':
num_verts = 3889
encoder = Encoder()
decoder = Decoder(num_verts=num_verts)
encoder.load_state_dict(torch.load(self.encoder_weights))
decoder.load_state_dict(torch.load(self.decoder_weights))
self.encoder = encoder.eval()
self.decoder = decoder.eval()
def main():
# query and key feature extractor
f_q = Encoder(input_shape); # update this model more frequently
f_k = Encoder(input_shape); # update this model less frequently
f_k.set_weights(np.array(f_q.get_weights()));
# utils for training
optimizer = tf.keras.optimizers.SGD(0.001, momentum = 0.9, decay = 0.0001);
trainset = iter(tfds.load(name = 'imagenet_resized/64x64', split = tfds.Split.TRAIN, download = False).repeat(-1).map(parse_function).shuffle(batch_size).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE));
checkpoint = tf.train.Checkpoint(f_q = f_q, f_k = f_k, optimizer = optimizer);
checkpoint.restore(tf.train.latest_checkpoint('checkpoints'));
log = tf.summary.create_file_writer('checkpoints');
avg_loss = tf.keras.metrics.Mean(name = 'loss', dtype = tf.float32);
# stuff 10 batches feature into queue
queue = Queue(trainset, f_k, 10);
augmentation = RandomAugmentation(input_shape, rotation_range = (-10, 10));
while True:
x, label = next(trainset);
# two augmented versions of the same batch data
x_q = augmentation(x); # x_q.shape = (batch, 64, 64, 3)
x_k = augmentation(x); # x_k.shape = (batch, 64, 64, 3)
with tf.GradientTape() as tape:
q = f_q(x_q); # q.shape = (batch, 128)
k = f_k(x_k); # k.shape = (batch, 128)
l_pos = tf.reshape(tf.linalg.matmul(tf.reshape(q, (-1, 1, 128)), tf.reshape(k, (-1, 128, 1))), (-1, 1)); # l_pos.shape = (batch, 1)
l_neg = tf.reshape(tf.linalg.matmul(tf.reshape(q, (-1, 1, 128)), queue.get()), (-1, 10)); # l_neg.shape = (batch, 10)
logits = tf.concat([l_pos, l_neg], axis = 1); # logits.shape = (batch, 11)
# contrastive loss
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits = True)(tf.zeros((batch_size,)), logits / temp);
grads = tape.gradient(loss, f_q.trainable_variables); avg_loss.update_state(loss);
[tf.debugging.Assert(tf.math.logical_not(tf.math.reduce_any(tf.math.is_nan(grad))), grads + [optimizer.iterations,]) for grad in grads];
[tf.debugging.Assert(tf.math.logical_not(tf.math.reduce_any(tf.math.is_inf(grad))), grads + [optimizer.iterations,]) for grad in grads];
tf.debugging.Assert(tf.math.logical_not(tf.math.reduce_any(tf.math.is_nan(f_q(tf.constant(np.random.normal(size = (1, 64, 64, 3)), dtype = tf.float32))))), [optimizer.iterations]);
optimizer.apply_gradients(zip(grads, f_q.trainable_variables));
# momentum update
tf.debugging.Assert(tf.math.logical_not(tf.math.reduce_any(tf.math.is_nan(f_q(tf.constant(np.random.normal(size = (1, 64, 64, 3)), dtype = tf.float32))))), [optimizer.iterations]);
for i in range(len(f_q.trainable_variables)):
f_k.trainable_variables[i] = beta * f_k.trainable_variables[i] + (1 - beta) * f_q.trainable_variables[i];
# update dictionary
queue.update(k);
# write log
if tf.equal(optimizer.iterations % 500, 0):
with log.as_default():
tf.summary.scalar('loss', avg_loss.result(), step = optimizer.iterations);
print('Step #%d Loss: %.6f' % (optimizer.iterations, avg_loss.result()));
avg_loss.reset_states();
if tf.equal(optimizer.iterations % 5000, 0):
# save model
checkpoint.save(os.path.join('checkpoints', 'ckpt'));
if False == os.path.exists('models'): os.mkdir('models');
f_k.save(os.path.join('models', 'model.h5'));
def inference(from_file_path, args):
with tf.Graph().as_default(), tf.Session() as sess:
alpha = args[0]
encoder = Encoder()
decoder = Decoder()
content_input = tf.placeholder(tf.float32,
shape=(1, None, None, 3),
name='content_input')
style_input = tf.placeholder(tf.float32,
shape=(1, None, None, 3),
name='style_input')
# switch RGB to BGR
content = tf.reverse(content_input, axis=[-1])
style = tf.reverse(style_input, axis=[-1])
# preprocess image
content = encoder.preprocess(content)
style = encoder.preprocess(style)
# encode image
# we should initial global variables before restore model
enc_c_net = encoder.encode(content, 'content/')
enc_s_net = encoder.encode(style, 'style/')
# pass the encoded images to AdaIN
target_features = AdaIN(enc_c_net.outputs,
enc_s_net.outputs,
alpha=alpha)
# decode target features back to image
dec_net = decoder.decode(target_features, prefix="decoder/")
generated_img = dec_net.outputs
# deprocess image
generated_img = encoder.deprocess(generated_img)
# switch BGR back to RGB
generated_img = tf.reverse(generated_img, axis=[-1])
# clip to 0..255
generated_img = tf.clip_by_value(generated_img, 0.0, 255.0)
sess.run(tf.global_variables_initializer())
encoder.restore_model(sess, ENCODER_PATH, enc_c_net)
encoder.restore_model(sess, ENCODER_PATH, enc_s_net)
decoder.restore_model(sess, DECODER_PATH, dec_net)
model_args = (sess, generated_img, content_input, style_input)
if from_file_path:
run_from_file_paths(model_args, args)
else:
return run_from_layers(model_args, args)
def pretrain(source_data_loader,
test_data_loader,
no_classes,
embeddings,
epochs=20,
batch_size=128,
cuda=False):
classifier = Classifier()
encoder = Encoder(embeddings)
if cuda:
classifier.cuda()
encoder.cuda()
''' Jointly optimize both encoder and classifier '''
encoder_params = filter(lambda p: p.requires_grad, encoder.parameters())
optimizer = optim.Adam(
list(encoder_params) + list(classifier.parameters()))
# Use weights to normalize imbalanced in data
c = [1] * len(no_classes)
weights = torch.FloatTensor(len(no_classes))
for i, (a, b) in enumerate(zip(c, no_classes)):
weights[i] = 0 if b == 0 else a / b
loss_fn = nn.CrossEntropyLoss(weight=Variable(weights))
print('Training encoder and classifier')
for e in range(epochs):
# pretrain with whole source data -- use groups with DCD
for sample in source_data_loader:
x, y = Variable(sample[0]), Variable(sample[1])
optimizer.zero_grad()
if cuda:
x, y = x.cuda(), y.cuda()
output = model_fn(encoder, classifier)(x)
loss = loss_fn(output, y)
loss.backward()
optimizer.step()
print("Epoch", e, "Loss", loss.data[0], "Accuracy",
eval_on_test(test_data_loader, model_fn(encoder, classifier)))
return encoder, classifier
def build_model(options):
''' build model, loss function, optimizer controlled by options '''
# detector module
if options.use_bi_lstm:
context_encoder = Encoder.ContextEncoder(options)
else:
context_encoder = Encoder.EmbeddingEncoder(options)
if options.tree_type == "DRN":
tree_model = DynamicRecursiveNetwork(options)
else:
tree_model = HierarchicalTreeLSTMs(options)
tree_embed = TreeEmbedding(options)
mlp = MLP(options)
# clause detector
detector = ClauseDetector(options=options,
context_encoder=context_encoder,
tree_embed=tree_embed,
tree_encoder=tree_model,
classifier=mlp)
crit = nn.NLLLoss(reduce=options.loss_reduce)
# get optimizer
if options.optim == "SGD":
optimizer = optim.SGD(detector.parameters(),
lr=options.lr,
momentum=options.momentum,
weight_decay=options.weight_decay)
elif options.optim == "Adagrad":
optimizer = optim.Adagrad(detector.parameters(),
lr=options.lr,
lr_decay=options.lr_decay,
weight_decay=options.weight_decay)
else:
optimizer = optim.Adam(detector.parameters(),
lr=options.lr,
betas=options.betas,
eps=options.eps,
weight_decay=options.weight_decay)
if options.use_cuda:
detector.switch2gpu()
crit = crit.cuda()
return detector, crit, optimizer
def __init__(self, action_size, state_size, config):
self.seed = config["seed"]
torch.manual_seed(self.seed)
np.random.seed(seed=self.seed)
self.env = gym.make(config["env_name"])
self.env = FrameStack(self.env, config)
self.env.seed(self.seed)
self.action_size = action_size
self.state_size = state_size
self.tau = config["tau"]
self.gamma = config["gamma"]
self.batch_size = config["batch_size"]
self.lr = config["lr"]
self.history_length = config["history_length"]
self.size = config["size"]
if not torch.cuda.is_available():
config["device"] == "cpu"
self.device = config["device"]
self.eval = config["eval"]
self.vid_path = config["vid_path"]
print("actions size ", action_size)
self.critic = QNetwork(state_size, action_size, config["fc1_units"],
config["fc2_units"]).to(self.device)
self.q_optim = torch.optim.Adam(self.critic.parameters(),
config["lr_critic"])
self.target_critic = QNetwork(state_size, action_size,
config["fc1_units"],
config["fc2_units"]).to(self.device)
self.target_critic.load_state_dict(self.critic.state_dict())
self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)
self.alpha = self.log_alpha.exp()
self.alpha_optim = Adam([self.log_alpha], lr=config["lr_alpha"])
self.policy = SACActor(state_size, action_size).to(self.device)
self.policy_optim = Adam(self.policy.parameters(),
lr=config["lr_policy"])
self.encoder = Encoder(config).to(self.device)
self.encoder_optimizer = torch.optim.Adam(self.encoder.parameters(),
self.lr)
self.episodes = config["episodes"]
self.memory = ReplayBuffer((self.history_length, self.size, self.size),
(1, ), config["buffer_size"],
config["image_pad"], self.seed, self.device)
pathname = config["seed"]
tensorboard_name = str(config["res_path"]) + '/runs/' + str(pathname)
self.writer = SummaryWriter(tensorboard_name)
self.steps = 0
self.target_entropy = -torch.prod(
torch.Tensor(action_size).to(self.device)).item()
def __init__(
self,
ensemble_size,
in_dim,
out_dim,
encoder_hidden_dim,
decoder_hidden_dim,
latent_dim,
n_hidden,
learn_rate=0.0001,
):
super(DynamicsEnsemble, self).__init__()
self.ensemble_size = ensemble_size
self.encoder = Encoder(in_dim,
encoder_hidden_dim,
latent_dim,
n_hidden=n_hidden)
self.decoders = self.build_decoder_ensemble(out_dim,
decoder_hidden_dim,
latent_dim, n_hidden)
self.opt = optim.Adam(self.parameters(), lr=learn_rate)
self.gaussian = Gaussian(latent_dim)
self.next_obs = None
self.reward = None
def main(test_data_file, checkpoint_dir, training_info_file, beam_width,
sample_content, cpd_model_file, print_utt):
training_info = helpers.load_from_pickle(training_info_file)
encoder = Encoder(
len(training_info['mr_word2idx']) + 1, training_info['embedding_dim'],
training_info['units'])
decoder = Decoder(len(training_info['ref_word2idx']) + 1,
training_info['embedding_dim'],
training_info['units'] * 2,
training=False)
optimizer = tf.keras.optimizers.Adam()
checkpoint = tf.train.Checkpoint(optimizer=optimizer,
encoder=encoder,
decoder=decoder)
print('Restoring checkpoint from', checkpoint_dir)
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
# get test data
test_data = load_text_data(test_data_file, 2000)
if print_utt:
print_generations(test_data, encoder, decoder, training_info,
beam_width, sample_content, cpd_model_file)
bleu_mean, bleu_var = calculate_mean_bleu_score(test_data, encoder,
decoder, training_info,
beam_width, sample_content,
cpd_model_file)
print(bleu_mean, bleu_var)
def main():
train_iterator, valid_iterator, test_iterator, params = prepare_data()
(INPUT_DIM, OUTPUT_DIM, ENC_EMB_DIM, DEC_EMB_DIM,
ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT, DEC_DROPOUT) = params
# INPUT_DIM = len(SRC.vocab), 7855
# OUTPUT_DIM = len(TRG.vocab), 5893
# ENC_EMB_DIM = 256
# DEC_EMB_DIM = 256
# ENC_HID_DIM = 512
# DEC_HID_DIM = 512
# ENC_DROPOUT = 0.5
# DEC_DROPOUT = 0.5
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
attn = Attention(ENC_HID_DIM, DEC_HID_DIM)
enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM,
DEC_HID_DIM, ENC_DROPOUT)
dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM,
DEC_HID_DIM, DEC_DROPOUT, attn)
model = Seq2Seq(enc, dec, device).to(device)
model.apply(init_weights)
print(f'The model has {count_parameters(model):,} trainable parameters')
for i, batch in enumerate(train_iterator):
print(f'ITER: {i}')
example = batch
print("Input Length:", example.src.shape, "[src_len, batch_size]")
output = model.forward(example.src, example.trg)
print(output.shape)
print('')
if i > 3: break
def captioning(image_path):
loader = data_loader(
features_shape=2048,
attention_features_shape=64,
batch_size=256,
buffer_size=1000,
top_k=5000
)
## loadm odel and checkpoint
embedding_matrix = np.load("./content/drive/My Drive/datasets/embeddingmatrix.npy")
encoder = Encoder(200)
decoder = Decoder(embedding_dim=200, vocab_size=loader.top_k + 1, units=512, embedding_matrix = embedding_matrix)
optimizer = tf.keras.optimizers.Adam()
checkpoint_path = "./content/drive/My Drive/datasets/modelcheckpoint/embedding"
ckpt = tf.train.Checkpoint(encoder=encoder, decoder=decoder, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=3)
if ckpt_manager.latest_checkpoint:
ckpt.restore(ckpt_manager.latest_checkpoint)
## inference time
result, _ = evaluate(
encoder,
decoder,
loader.tokenizer,
loader.max_length,
loader.attention_features_shape,
image_path
)
result = " ".join(result)
return result
def evaluate(path):
with open('tokenizer.pickle', 'rb') as handle:
tokenizer = pickle.load(handle)
vocab_size = len(tokenizer.word_index) + 1
encoder = Encoder(config.embedding_dim)
decoder = Decoder(config.units, config.embedding_dim, vocab_size)
checkpoint_dir = './checkpoints'
checkpoint = tf.train.Checkpoint(encoder=encoder, decoder=decoder)
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
image = load_image(path)
encoder_outputs = encoder(tf.expand_dims(image, 0))
dec_state = tf.zeros((1, config.units))
dec_input = tf.expand_dims([tokenizer.word_index['<start>']], 0)
result = result = beam_search(config.beam_width, decoder, dec_input,
dec_state, encoder_outputs,
tokenizer.word_index['<end>'], vocab_size)
result = tokenizer.sequences_to_texts([result])
print(result)
def evaluate(text):
with open('input_tokenizer.pickle', 'rb') as handle:
input_tokenizer = pickle.load(handle)
with open('output_tokenizer.pickle', 'rb') as handle:
output_tokenizer = pickle.load(handle)
input_vocab_size = len(input_tokenizer.word_index) + 1
output_vocab_size = len(output_tokenizer.word_index) + 1
text = preprocess_text(text)
seq = input_tokenizer.texts_to_sequences([text])
inputs = tf.keras.preprocessing.sequence.pad_sequences(seq, truncating='post', padding='post')
inputs = tf.convert_to_tensor(inputs)
result = ""
encoder = Encoder(input_vocab_size, constants.embedding_dim, constants.units, constants.BATCH_SIZE)
decoder = Decoder(output_vocab_size, constants.embedding_dim, constants.units, constants.BATCH_SIZE)
checkpoint_dir = './checkpoints'
checkpoint = tf.train.Checkpoint(encoder=encoder, decoder=decoder)
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
enc_outputs, enc_hidden = encoder(inputs)
dec_hidden = enc_hidden
dec_input = tf.expand_dims([output_tokenizer.word_index['<start>']], 0)
result = beam_search(constants.beam_width, decoder, dec_input, dec_hidden,
enc_outputs, output_tokenizer.word_index['<end>'], output_vocab_size)
result = output_tokenizer.sequences_to_texts([result])
print(result[0])
def __init__(self, args, n_agents, n_cities, device, data_loader):
self.n_agents = n_agents
self.n_cities = n_cities
self.device = device
self.args = args
self.Encoder = Encoder(K=args.steps,
M=self.n_cities,
L=args.len_encoder).to(self.device)
self.DQN = DQN(N=self.n_agents,
K=args.steps,
L=args.len_encoder,
M=n_cities).to(self.device)
self.data_loader = data_loader
self.iter_data = iter(data_loader)
self.n_envs = len(data_loader)
self.idx_env = -1
self.env = None
self.EPS_START = self.args.eps_start
self.EPS_END = self.args.eps_end
self.EPS_DECAY = self.args.eps_decay
self.criterion = nn.MSELoss()
self.optimizer = torch.optim.RMSprop(self.DQN.parameters(), lr=args.lr)
def _build(self, is_training):
self.encoder = Encoder(self.from_embeddings.shape,
self.num_layers,
self.units,
is_training=is_training)
if is_training:
self.decoder = TrainingDecoder(self.Ty, self.to_embeddings.shape,
self.to_start_index,
self.to_end_index,
self.to_vocabulary_size,
self.num_layers, self.units,
self.batch_size)
elif self.beam_width > 1:
self.decoder = BeamSearchDecoder(
self.beam_width, self.Ty, self.to_embeddings.shape,
self.to_start_index, self.to_end_index,
self.to_vocabulary_size, self.num_layers, self.units,
self.batch_size)
else:
self.decoder = GreedyDecoder(self.Ty, self.to_embeddings.shape,
self.to_start_index,
self.to_end_index,
self.to_vocabulary_size,
self.num_layers, self.units,
self.batch_size)
def __init__(self,
z_dim=32,
h_dim=128,
filter_num=64,
channel_num=3,
lr=1e-3,
cuda=False):
# Are we cuda'ing it
self.cuda = cuda
# Encoder, decoder, discriminator
self.encoder = self.cudafy_(
Encoder(z_dim,
h_dim=h_dim,
filter_num=filter_num,
channel_num=channel_num))
self.encoder.apply(weight_init)
self.decoder = self.cudafy_(
Decoder(z_dim, filter_num=filter_num, channel_num=channel_num))
self.decoder.apply(weight_init)
self.discrim = self.cudafy_(Discriminator(z_dim))
self.discrim.apply(weight_init)
# Optimizers
generator_params = list(self.encoder.parameters()) + \
list(self.decoder.parameters())
self.optim_enc = optim.Adam(self.encoder.parameters(), lr=lr)
self.optim_dec = optim.Adam(self.decoder.parameters(), lr=lr)
self.optim_dis = optim.Adam(self.discrim.parameters(), lr=lr)
self.optim_gen = optim.Adam(generator_params, lr=lr)
self.start_epoch = 0
def test_different_batch_dimensions(self):
input = torch.Tensor(4, 8, 10).random_()
lengths = torch.Tensor([3, 8, 2]).long()
encoder = Encoder(10, 5, cell=nn.GRU)
with self.assertRaises(AssertionError):
outputs, last_hidden = encoder(input, lengths)
def __init__(self, **kwargs):
super().__init__()
self.save_hyperparameters()
self.encoder = Encoder()
self.decoder = Decoder()
self.loss_func = nn.MSELoss()
def load():
encoder_net = Encoder(vocab_enc, 150, 200, 1, 0.3).to("cpu")
decoder_net = Decoder(
vocab_dec,
150,
200,
vocab_dec,
1,
0.3,
).to("cpu")
encoder_net.state_dict(
torch.load("/home/aradhya/Desktop/hacks/model_for_faq_encoder.pt"))
decoder_net.state_dict(
torch.load("/home/aradhya/Desktop/hacks/model_for_faq_decoder.pt"))
return encoder_net, decoder_net
def __init__(self, config: Config):
super().__init__()
self.encoder = Encoder()
self.decoder = Decoder()
self.loss_func = nn.MSELoss()
self.config: Config = config
def __init__(self): super(VAE, self).__init__() self.E, self.D = Encoder(), Decoder() self.memory = [] self.memory_num = 0 self.opt = torch.optim.Adam(self.parameters(), lr = VAE_LEARNING_RATE)
from layers import LSTM, FullConnected, TimeDistributed from models import Decoder, Encoder, Seq2seq, Sequential from utils import masking, padding rng.seed(123) # Preprocess data x1 = [2, 1, 1, 1, 2, 4, 2] x2 = [2, 1] x3 = [2, 1, 4, 3, 1] batch_value = np.asarray([x1, x2, x3]) vocab_size = 5 embedding_size = 4 encoder_hidden_size = 6 encoder = Encoder(vocab_size + 1, embedding_size, encoder_hidden_size) mask_value = masking(batch_value) padded_batch_value = padding(batch_value, 0) mask = shared(mask_value, name='mask') padded_batch = shared(padded_batch_value, name='padded_batch') H, C = encoder.forward(padded_batch, mask) (h1, c1) = encoder.forward2(x1) (h2, c2) = encoder.forward2(x2) (h3, c3) = encoder.forward2(x3) print(T.isclose(H, T.as_tensor_variable([h1, h2, h3])).eval()) print(T.isclose(C, T.as_tensor_variable([c1, c2, c3])).eval())
