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())