def phase_3_train_encoder(params): from io_modules.dataset import Dataset from models.encoder import Encoder from trainers.encoder import Trainer trainset = Dataset("data/processed/train") devset = Dataset("data/processed/dev") sys.stdout.write('Found ' + str(len(trainset.files)) + ' training files and ' + str(len(devset.files)) + ' development files\n') character2int = {} for train_file in trainset.files: from io_modules.dataset import DatasetIO dio = DatasetIO() lab_list = dio.read_lab(train_file + ".txt") for entry in lab_list: if entry.phoneme not in character2int: character2int[entry.phoneme] = len(character2int) sys.stdout.write('Found ' + str(len(character2int)) + ' unique phonemes\n') f = open('data/models/encoder.chars', 'w') for char in character2int: f.write( char.encode('utf-8') + '\t' + str(character2int[char]) + '\n') f.close() encoder = Encoder(params, len(character2int), character2int) if params.resume: sys.stdout.write('Resuming from previous checkpoint\n') encoder.load('data/models/rnn_encoder') trainer = Trainer(encoder, trainset, devset) trainer.start_training(10, 1000)
def detect(path, encoder=None, decoder=None): torch.backends.cudnn.benchmark = True dataset = LoadImages(path, img_size=config.IMAGE_SIZE, used_layers=config.USED_LAYERS) if not encoder or not decoder: in_channels = num_channels(config.USED_LAYERS) encoder = Encoder(in_channels=in_channels) decoder = Decoder(num_classes=config.NUM_CLASSES+1) encoder = encoder.to(config.DEVICE) decoder = decoder.to(config.DEVICE) _, encoder, decoder = load_checkpoint(encoder, decoder, config.CHECKPOINT_FILE, config.DEVICE) encoder.eval() decoder.eval() for _, layers, path in dataset: with torch.no_grad(): layers = torch.from_numpy(layers).to(config.DEVICE, non_blocking=True) if layers.ndimension() == 3: layers = layers.unsqueeze(0) features = encoder(layers) predictions = decoder(features) _, out = predictions, predictions.sigmoid() plot_volumes(to_volume(out, config.VOXEL_THRESH).cpu(), [path], config.NAMES)
def _build(self, images): embedder = Embedder() embedded_grads_weights = embedder.embed_all_grads_weights( self._placeholders) # Fake batching embedded_grads_weights = tf.expand_dims(embedded_grads_weights, 0) encoder = Encoder(self._source_num_way, self._target_num_way) encoded = encoder.encode(embedded_grads_weights) decoded = encoder.decode(encoded) # Fake batching decoded = tf.squeeze(decoded, [0]) weight_updates = embedder.unembed_all_weights(decoded) the_list = [tf.nn.moments(w, [0]) for w in weight_updates] mean_means = tf.reduce_mean([tf.reduce_mean(v[0]) for v in the_list]) mean_vars = tf.reduce_mean([tf.reduce_mean(v[1]) for v in the_list]) tf.summary.scalar('weight_updates_mean', mean_means, [META_TRAIN_COMBINED_SUMMARIES]) tf.summary.scalar('weight_updates_var', mean_vars, [META_TRAIN_COMBINED_SUMMARIES]) # Get the updated model new_weights = [ self._placeholders[0][1] + weight_updates[0], self._placeholders[1][1] + weight_updates[1], self._placeholders[2][1] + weight_updates[2], self._placeholders[3][1] + weight_updates[3], self._placeholders[4][1] + weight_updates[4] ] self.outputs = self.new_model_forward(new_weights, images) return self.outputs
def synthesize(speaker, input_file, output_file, params): print("[Encoding]") from io_modules.dataset import Dataset from io_modules.dataset import Encodings from models.encoder import Encoder from trainers.encoder import Trainer encodings = Encodings() encodings.load('data/models/encoder.encodings') encoder = Encoder(params, encodings, runtime=True) encoder.load('data/models/rnn_encoder') seq = create_lab_input(input_file, speaker) mgc, att = encoder.generate(seq) _render_spectrogram(mgc, output_file + '.png') print("[Vocoding]") from models.vocoder import Vocoder from trainers.vocoder import Trainer vocoder = Vocoder(params, runtime=True) vocoder.load('data/models/rnn_vocoder') import time start = time.time() signal = vocoder.synthesize(mgc, batch_size=1000, temperature=params.temperature) stop = time.time() sys.stdout.write(" execution time=" + str(stop - start)) sys.stdout.write('\n') sys.stdout.flush() from io_modules.dataset import DatasetIO dio = DatasetIO() enc = dio.b16_dec(signal, discreete=True) dio.write_wave(output_file, enc, params.target_sample_rate)
def evaluate_hand_draw_net(cfg): # Enable the inbuilt cudnn auto-tuner to find the best algorithm to use torch.backends.cudnn.benchmark = True IMG_SIZE = cfg.CONST.IMG_H, cfg.CONST.IMG_W CROP_SIZE = cfg.CONST.CROP_IMG_H, cfg.CONST.CROP_IMG_W eval_transforms = utils.data_transforms.Compose([ utils.data_transforms.CenterCrop(IMG_SIZE, CROP_SIZE), utils.data_transforms.RandomBackground(cfg.TEST.RANDOM_BG_COLOR_RANGE), utils.data_transforms.Normalize(mean=cfg.DATASET.MEAN, std=cfg.DATASET.STD), utils.data_transforms.ToTensor(), ]) # Set up networks encoder = Encoder(cfg) decoder = Decoder(cfg) azi_classes, ele_classes = int(360 / cfg.CONST.BIN_SIZE), int( 180 / cfg.CONST.BIN_SIZE) view_estimater = ViewEstimater(cfg, azi_classes=azi_classes, ele_classes=ele_classes) if torch.cuda.is_available(): encoder = torch.nn.DataParallel(encoder).cuda() decoder = torch.nn.DataParallel(decoder).cuda() view_estimater = torch.nn.DataParallel(view_estimater).cuda() # Load weight # Load weight for encoder, decoder print('[INFO] %s Loading reconstruction weights from %s ...' % (dt.now(), cfg.EVALUATE_HAND_DRAW.RECONSTRUCTION_WEIGHTS)) rec_checkpoint = torch.load(cfg.EVALUATE_HAND_DRAW.RECONSTRUCTION_WEIGHTS) encoder.load_state_dict(rec_checkpoint['encoder_state_dict']) decoder.load_state_dict(rec_checkpoint['decoder_state_dict']) print('[INFO] Best reconstruction result at epoch %d ...' % rec_checkpoint['epoch_idx']) # Load weight for view estimater print('[INFO] %s Loading view estimation weights from %s ...' % (dt.now(), cfg.EVALUATE_HAND_DRAW.VIEW_ESTIMATION_WEIGHTS)) view_checkpoint = torch.load( cfg.EVALUATE_HAND_DRAW.VIEW_ESTIMATION_WEIGHTS) view_estimater.load_state_dict( view_checkpoint['view_estimator_state_dict']) print('[INFO] Best view estimation result at epoch %d ...' % view_checkpoint['epoch_idx']) for img_path in os.listdir(cfg.EVALUATE_HAND_DRAW.INPUT_IMAGE_FOLDER): eval_id = int(img_path[:-4]) input_img_path = os.path.join( cfg.EVALUATE_HAND_DRAW.INPUT_IMAGE_FOLDER, img_path) print(input_img_path) evaluate_hand_draw_img(cfg, encoder, decoder, view_estimater, input_img_path, eval_transforms, eval_id)
def __init__(self, config): super().__init__() self.encoder_word = Encoder(config, config.src_vocab_size) self.encoder_char = Encoder(config, config.tgt_vocab_size) self.pointer = Pointer(config) self.attention = Luong_Attention(config) self.decoder = Decoder(config) self.linear_out = nn.Linear(config.model_size, config.tgt_vocab_size) self.softmax = nn.Softmax(dim=-1) self.s_len = config.s_len self.bos = config.bos
def load_encoder(params, base_path='data/models'): from io_modules.dataset import Encodings from models.encoder import Encoder encodings = Encodings() encodings.load('%s/encoder.encodings' % base_path) encoder = Encoder(params, encodings, runtime=True) encoder.load('%s/rnn_encoder' % base_path) return encoder
def phase_3_train_encoder(params): from io_modules.dataset import Dataset from io_modules.dataset import Encodings from models.encoder import Encoder from trainers.encoder import Trainer trainset = Dataset("data/processed/train") devset = Dataset("data/processed/dev") sys.stdout.write('Found ' + str(len(trainset.files)) + ' training files and ' + str(len(devset.files)) + ' development files\n') encodings = Encodings() count = 0 if not params.resume: for train_file in trainset.files: count += 1 if count % 100 == 0: sys.stdout.write('\r' + str(count) + '/' + str(len(trainset.files)) + ' processed files') sys.stdout.flush() from io_modules.dataset import DatasetIO dio = DatasetIO() lab_list = dio.read_lab(train_file + ".lab") for entry in lab_list: encodings.update(entry) sys.stdout.write('\r' + str(count) + '/' + str(len(trainset.files)) + ' processed files\n') sys.stdout.write('Found ' + str(len(encodings.char2int)) + ' unique symbols, ' + str(len(encodings.context2int)) + ' unique features and ' + str(len(encodings.speaker2int)) + ' unique speakers\n') encodings.store('data/models/encoder.encodings') else: encodings.load('data/models/encoder.encodings') if params.resume: runtime = True # avoid ortonormal initialization else: runtime = False encoder = Encoder(params, encodings, runtime=runtime) if params.resume: sys.stdout.write('Resuming from previous checkpoint\n') encoder.load('data/models/rnn_encoder') if params.no_guided_attention: sys.stdout.write('Disabling guided attention\n') if params.no_bounds: sys.stdout.write( 'Using internal stopping condition for synthesis\n') trainer = Trainer(encoder, trainset, devset) trainer.start_training(10, 1000, params)
class Visualization_demo(): def __init__(self, cfg, output_dir): self.encoder = Encoder(cfg) self.decoder = Decoder(cfg) self.refiner = Refiner(cfg) self.merger = Merger(cfg) checkpoint = torch.load(cfg.CHECKPOINT) encoder_state_dict = clean_state_dict(checkpoint['encoder_state_dict']) self.encoder.load_state_dict(encoder_state_dict) decoder_state_dict = clean_state_dict(checkpoint['decoder_state_dict']) self.decoder.load_state_dict(decoder_state_dict) if cfg.NETWORK.USE_REFINER: refiner_state_dict = clean_state_dict( checkpoint['refiner_state_dict']) self.refiner.load_state_dict(refiner_state_dict) if cfg.NETWORK.USE_MERGER: merger_state_dict = clean_state_dict( checkpoint['merger_state_dict']) self.merger.load_state_dict(merger_state_dict) if not os.path.exists(output_dir): os.makedirs(output_dir) self.output_dir = output_dir def run_on_images(self, imgs, sid, mid, iid, sampled_idx): dir1 = os.path.join(output_dir, str(sid), str(mid)) if not os.path.exists(dir1): os.makedirs(dir1) deprocess = imagenet_deprocess(rescale_image=False) image_features = self.encoder(imgs) raw_features, generated_volume = self.decoder(image_features) generated_volume = self.merger(raw_features, generated_volume) generated_volume = self.refiner(generated_volume) mesh = cubify(generated_volume, 0.3) # mesh = voxel_to_world(meshes) save_mesh = os.path.join(dir1, "%s_%s.obj" % (iid, sampled_idx)) verts, faces = mesh.get_mesh_verts_faces(0) save_obj(save_mesh, verts, faces) generated_volume = generated_volume.squeeze() img = image_to_numpy(deprocess(imgs[0][0])) save_img = os.path.join(dir1, "%02d.png" % (iid)) # cv2.imwrite(save_img, img[:, :, ::-1]) cv2.imwrite(save_img, img) img1 = image_to_numpy(deprocess(imgs[0][1])) save_img1 = os.path.join(dir1, "%02d.png" % (sampled_idx)) cv2.imwrite(save_img1, img1) # cv2.imwrite(save_img1, img1[:, :, ::-1]) get_volume_views(generated_volume, dir1, iid, sampled_idx)
def main(model_filename, pitch_model_filename, output_dir, batch_size): model = torch.nn.Module() model.add_module('encoder', Encoder(**encoder_config)) model.add_module('generator', Generator(sum(encoder_config['n_out_channels']))) model = load_checkpoint(model_filename, model).cuda() model.eval() if os.path.isfile(pitch_model_filename): global pitch_model, use_predicted_pitch use_predicted_pitch = True pitch_model = PitchModel(**pitch_config) pitch_model = load_checkpoint(pitch_model_filename, pitch_model).cuda() pitch_model.eval() testset = TestSet(**(data_config)) cond, name = testset[0] for files in chunker(testset, batch_size): files = list(zip(*files)) cond_input, file_paths = files[:-1], files[-1] cond_input = [ utils.to_gpu(torch.from_numpy(np.stack(x))).float() for x in cond_input ] #cond_input = model.encoder(cond_input.transpose(1, 2)).transpose(1, 2) cond_input = model.encoder(cond_input[0]) audio = model.generator(cond_input) for i, file_path in enumerate(file_paths): print("writing {}".format(file_path)) wav = audio[i].cpu().squeeze().detach().numpy() * 32768.0 write("{}/{}.wav".format(output_dir, file_path), data_config['sampling_rate'], wav.astype(np.int16))
def test_train_method(self): file_name = 'test/test_data/attention_test.txt' fine_tune_model_name = '../models/glove_model_40.pth' self.test_data_loader_attention = DataLoaderAttention( file_name=file_name) self.test_data_loader_attention.load_data() source2index, index2source, target2index, index2target, train_data = \ self.test_data_loader_attention.load_data() EMBEDDING_SIZE = 50 HIDDEN_SIZE = 32 encoder = Encoder(len(source2index), EMBEDDING_SIZE, HIDDEN_SIZE, 3, True) decoder = Decoder(len(target2index), EMBEDDING_SIZE, HIDDEN_SIZE * 2) self.trainer = Trainer(fine_tune_model=fine_tune_model_name) self.trainer.train_attention( train_data=train_data, source2index=source2index, target2index=target2index, index2source=index2source, index2target=index2target, encoder_model=encoder, decoder_model=decoder, )
def __init__(self, client, username, password, url, cache_key_name): self.client = client self.username = username self.password = password self.url = url self.cache_key_name = cache_key_name self.encoder = Encoder()
def __init__(self, args, text_data): super(ModelGumbel, self).__init__() self.args = args self.text_data = text_data # embedding layer if self.args.pre_embedding and not self.args.elmo: # pre_trained embeddings are 300 dimensional, trainable self.embedding_layer = nn.Embedding.from_pretrained(torch.Tensor( self.text_data.pre_trained_embedding), freeze=False) elif self.args.elmo: self.embedding_layer = Elmo(options_file, weight_file, 1, dropout=1.0 - self.args.drop_out, requires_grad=self.args.train_elmo) else: self.embedding_layer = nn.Embedding( num_embeddings=self.text_data.getVocabularySize(), embedding_dim=self.args.embedding_size) # first generator self.generator = Generator(args=self.args) # then encoder self.encoder = Encoder(args=self.args)
def __init__(self, args): """ Basic initialization of Transformer. Arguments --------- args: <argparse.Namespace> Arguments used for overall process. """ super().__init__() self.args = args self.num_stacks = self.args.num_stacks self.d_model = self.args.d_model self.vocab_size = self.args.vocab_size self.emb = EmbeddingLayer(self.args) encoders = [Encoder(self.args) for _ in range(self.num_stacks)] self.encoder_stack = nn.Sequential(*encoders) decoders = [Decoder(self.args) for _ in range(self.num_stacks)] self.decoder_stack = nn.ModuleList(decoders) self.output_linear = nn.Linear(in_features=self.d_model, out_features=self.vocab_size, bias=False) self.output_linear.weight = self.emb.embedding_layer.weight self.softmax = nn.LogSoftmax(dim=-1) self.dropout = nn.Dropout(p=0.1)
class StepsCache: def __init__(self, client, logger, username, password, url, cache_key_name): self.client = client self.logger = logger self.username = username self.password = password self.url = url self.cache_key_name = cache_key_name self.encoder = Encoder() def get_key_name(self): return self.cache_key_name def add_script_steps_data(self): script_steps = self.get_steps_information() for value in script_steps: self.client.sadd(self.get_key_name(), self.encoder.encode(value)) def get_steps_information(self): try: response = self.get_authorized_response(self.url) data = json.loads(response.read()) return data["steps"] except Exception, e: self.logger.error("Error when getting registration steps data %s", e) return []
def __init__(self, vocabulary_size, sos_token, eos_token, pad_token, max_string_length=default_eda['string_max_length'], attention_size=default_attention['size'], embedding_size=default_embedding['size'], hidden_size=default_gru['hidden_size'], num_layers=default_gru['num_layers'], dropout=default_gru['dropout'], fixed_encoder=None): super().__init__() self.max_string_length = max_string_length self.attention_size = attention_size self.vocabulary_size = vocabulary_size if fixed_encoder: # Fix encoder's weights for p in fixed_encoder.parameters(): p.requires_grad_(False) self.encoder = fixed_encoder else: self.encoder = Encoder(vocabulary_size, embedding_size, hidden_size, num_layers, dropout) # self.decoder = Decoder(vocabulary_size) self.decoder = DecoderAndPointer(vocabulary_size, embedding_size, hidden_size, num_layers, dropout, attention_size, pad_token, shift_focus=True) self.sos_token = sos_token self.eos_token = eos_token
def __init__(self, h_dim, res_h_dim, n_res_layers, n_embeddings, embedding_dim, beta, restart=True): super(VQVAE, self).__init__() # encode image into continuous latent space self.encoder = Encoder(in_dim=256, h_dim=h_dim, n_res_layers=n_res_layers, res_h_dim=res_h_dim) self.pre_quantization_conv = nn.Conv1d(h_dim, embedding_dim, kernel_size=3, stride=1, padding=1) # Define discretization bottleneck if not restart: self.vector_quantization = VectorQuantizer(n_embeddings, embedding_dim, beta) else: self.vector_quantization = VectorQuantizerRandomRestart( n_embeddings, embedding_dim, beta) # decode the discrete latent representation self.decoder = Decoder(embedding_dim, h_dim, n_res_layers, res_h_dim) #E_indices used in sampling, just save last to rep last latent state self.e_indices = None
def __init__(self, enc_in, dec_in, c_out, seq_len, label_len, out_len, factor=5, d_model=512, n_heads=8, e_layers=3, d_layers=2, d_ff=512, dropout=0.0, attn='prob', embed='fixed', data='ETTh', activation='gelu', device=torch.device('cuda:0')): super(Informer, self).__init__() self.pred_len = out_len self.attn = attn # Encoding self.enc_embedding = DataEmbedding(enc_in, d_model, embed, data, dropout) self.dec_embedding = DataEmbedding(dec_in, d_model, embed, data, dropout) # Attention Attn = ProbAttention if attn == 'prob' else FullAttention # Encoder self.encoder = Encoder([ EncoderLayer(AttentionLayer( Attn(False, factor, attention_dropout=dropout), d_model, n_heads), d_model, d_ff, dropout=dropout, activation=activation) for l in range(e_layers) ], [ConvLayer(d_model) for l in range(e_layers - 1)], norm_layer=torch.nn.LayerNorm(d_model)) # Decoder self.decoder = Decoder([ DecoderLayer( AttentionLayer( FullAttention(True, factor, attention_dropout=dropout), d_model, n_heads), AttentionLayer( FullAttention(False, factor, attention_dropout=dropout), d_model, n_heads), d_model, d_ff, dropout=dropout, activation=activation, ) for l in range(d_layers) ], norm_layer=torch.nn.LayerNorm(d_model)) # self.end_conv1 = nn.Conv1d(in_channels=label_len+out_len, out_channels=out_len, kernel_size=1, bias=True) # self.end_conv2 = nn.Conv1d(in_channels=d_model, out_channels=c_out, kernel_size=1, bias=True) self.projection = nn.Linear(d_model, c_out, bias=True)
def __init__(self): hidden_dim = embedding_dim = 128 data_dim = 101 self.encoder = Encoder(input_dim=data_dim, embedding_dim=embedding_dim, hidden_dim=hidden_dim) self.decoder = PtrDecoder(output_dim=data_dim, embedding_dim=embedding_dim, hidden_dim=hidden_dim) checkpoint = torch.load('./e1i0.ckpt', map_location='cpu') self.encoder.load_state_dict(checkpoint['encoder']) self.decoder.load_state_dict(checkpoint['decoder'])
def __init__(self, config): super().__init__() self.encoder = Encoder(config, config.src_vocab_size) self.decoder = Decoder(config) self.bos = config.bos self.s_len = config.s_len self.linear_out = nn.Linear(config.model_size, config.tgt_vocab_size)
def _build_encoder(self): loader = self.loader inputs = self.inputs contextualized_embeddings = None if sum(('elmo' in inputs, 'bert-base' in inputs, 'bert-large' in inputs)) > 1: raise ValueError( 'at most 1 contextualized emebeddings can be chosen') elif 'elmo' in inputs: contextualized_embeddings = ElmoEmbedding(usage='weighted_sum') elif 'bert-base' in inputs: contextualized_embeddings \ = BertBaseEmbedding(usage='second_to_last') elif 'bert-large' in inputs: contextualized_embeddings \ = BertLargeEmbedding(usage='second_to_last') encoder = Encoder( loader.get_embeddings( 'word', normalize=lambda W: W / np.std(W) if loader.use_pretrained_embed and np.std(W) > 0. else W), loader.get_embeddings('pos') if 'postag' in inputs else None, loader.get_embeddings('char') if 'char' in inputs else None, contextualized_embeddings, self.char_feature_size, self.char_pad_id, self.char_window_size, self.char_dropout, self.n_lstm_layers, self.lstm_hidden_size, self.embeddings_dropout, self.lstm_dropout, self.recurrent_dropout, self.bert_model, self.bert_dir) return encoder
def __init__(self, channels, h_dim, res_h_dim, n_res_layers, n_embeddings, embedding_dim, beta, save_img_embedding_map=False): super(VQVAE, self).__init__() # encode image into continuous latent space self.encoder = Encoder(channels, h_dim, n_res_layers, res_h_dim) self.pre_quantization_conv = nn.Conv2d(h_dim, embedding_dim, kernel_size=1, stride=1) # pass continuous latent vector through discretization bottleneck self.vector_quantization = VectorQuantizer(n_embeddings, embedding_dim, beta) # decode the discrete latent representation self.decoder = Decoder(channels, embedding_dim, h_dim, n_res_layers, res_h_dim) if save_img_embedding_map: self.img_to_embedding_map = {i: [] for i in range(n_embeddings)} else: self.img_to_embedding_map = None
def run(): """ Run the experiment. """ is_ptr = False np.random.seed(RANDOM_SEED) max_val, max_length, pairs = read_data(name="test") np.random.shuffle(pairs) training_pairs = [tensors_from_pair(pair) for pair in pairs] data_dim = max_val + 1 hidden_dim = embedding_dim = 256 encoder = Encoder(input_dim=data_dim, embedding_dim=embedding_dim, hidden_dim=hidden_dim).to(device) if is_ptr: decoder = PtrDecoder(output_dim=data_dim, embedding_dim=embedding_dim, hidden_dim=hidden_dim).to(device) else: decoder = AttnDecoder(output_dim=data_dim, embedding_dim=embedding_dim, hidden_dim=hidden_dim).to(device) checkpoint = load_checkpoint("ptr" if is_ptr else "vanilla") if checkpoint: encoder.load_state_dict(checkpoint["encoder"]) decoder.load_state_dict(checkpoint["decoder"]) else: print("Count not find checkpoint file.") permutation_count, nondecreasing_count = 0, 0 for i in range(len(training_pairs)): input_tensor, target_tensor = training_pairs[i] output_tensor = evaluate(encoder=encoder, decoder=decoder, input_tensor=training_pairs[i][0], is_ptr=is_ptr) target, output = list(np.asarray( input_tensor.data).squeeze()), output_tensor[:-1] if is_permutation(target, output): permutation_count += 1 if nondecreasing(output) == 0: nondecreasing_count += 1 print("Permutation: %s" % (permutation_count / len(training_pairs))) print("Nondecreasing: %s" % (nondecreasing_count / len(training_pairs)))
def test(encoder=None, decoder=None): torch.backends.cudnn.benchmark = True _, dataloader = create_dataloader(config.IMG_DIR + "/test", config.MESH_DIR + "/test", batch_size=config.BATCH_SIZE, used_layers=config.USED_LAYERS, img_size=config.IMAGE_SIZE, map_size=config.MAP_SIZE, augment=config.AUGMENT, workers=config.NUM_WORKERS, pin_memory=config.PIN_MEMORY, shuffle=False) if not encoder or not decoder: in_channels = num_channels(config.USED_LAYERS) encoder = Encoder(in_channels=in_channels) decoder = Decoder(num_classes=config.NUM_CLASSES+1) encoder = encoder.to(config.DEVICE) decoder = decoder.to(config.DEVICE) _, encoder, decoder = load_checkpoint(encoder, decoder, config.CHECKPOINT_FILE, config.DEVICE) loss_fn = LossFunction() loop = tqdm(dataloader, leave=True) losses = [] ious = [] encoder.eval() decoder.eval() for i, (_, layers, volumes, img_files) in enumerate(loop): with torch.no_grad(): layers = layers.to(config.DEVICE, non_blocking=True) volumes = volumes.to(config.DEVICE, non_blocking=True) features = encoder(layers) predictions = decoder(features) loss = loss_fn(predictions, volumes) losses.append(loss.item()) iou = predictions_iou(to_volume(predictions, config.VOXEL_THRESH), volumes) ious.append(iou) mean_iou = sum(ious) / len(ious) mean_loss = sum(losses) / len(losses) loop.set_postfix(loss=mean_loss, mean_iou=mean_iou) if i == 0 and config.PLOT: plot_volumes(to_volume(predictions, config.VOXEL_THRESH).cpu(), img_files, config.NAMES) plot_volumes(volumes.cpu(), img_files, config.NAMES)
def __init__(self, d_model, d_ff, d_K, d_V, n_heads, n_layers, sourceVocabSize, sourceLength, targetVocabSize, targetLength): super(Transformer, self).__init__() self.encoder = Encoder(sourceVocabSize, sourceLength, d_model, d_ff, d_K, d_V, n_heads, n_layers) self.decoder = Decoder(targetVocabSize, targetLength, d_model, d_ff, d_K, d_V, n_heads, n_layers) self.projection = nn.Linear(d_model, targetVocabSize, bias=False)
def extract_imgs_feat(): encoder = Encoder(opt.resnet101_file) encoder.to(opt.device) encoder.eval() imgs = os.listdir(opt.imgs_dir) imgs.sort() if not os.path.exists(opt.out_feats_dir): os.makedirs(opt.out_feats_dir) with h5py.File(os.path.join(opt.out_feats_dir, '%s_fc.h5' % opt.dataset_name)) as file_fc, \ h5py.File(os.path.join(opt.out_feats_dir, '%s_att.h5' % opt.dataset_name)) as file_att: try: for img_nm in tqdm.tqdm(imgs, ncols=100): img = skimage.io.imread(os.path.join(opt.imgs_dir, img_nm)) with torch.no_grad(): img = encoder.preprocess(img) img = img.to(opt.device) img_fc, img_att = encoder(img) file_fc.create_dataset(img_nm, data=img_fc.cpu().float().numpy()) file_att.create_dataset(img_nm, data=img_att.cpu().float().numpy()) except BaseException as e: file_fc.close() file_att.close() print( '--------------------------------------------------------------------' ) raise e
def __init__(self, que_dim: int, que_input_embs: list, que_output_embs: list, pro_dim: int, pro_input_embs: list, pro_output_embs: list, inter_dim: int, output_dim: int): super().__init__() self.que_model = Encoder(que_dim, inter_dim, output_dim, que_input_embs, que_output_embs) self.pro_model = Encoder(pro_dim, inter_dim, output_dim, pro_input_embs, pro_output_embs) self.merged = Concatenate()( [self.que_model.outputs[0], self.pro_model.outputs[0]]) self.inter = Dense(16, activation='tanh')(self.merged) self.outputs = Dense(1, activation='sigmoid')(self.inter) super().__init__([self.que_model.inputs[0], self.pro_model.inputs[0]], self.outputs)
def __init__(self, num_classes, fixed_height = 48, net='efficientnet'): super(Model, self).__init__() self.encoder = Encoder(net = net) self.decoder = Decoder(input_dim=int(fixed_height * 288 / 8), num_class=num_classes) self.crnn = nn.Sequential( self.encoder, self.decoder ) self.log_softmax = nn.LogSoftmax(dim=2)
def test_forward(self): encoder = Encoder(self.input_size, self.hidden_size, self.num_layers, bidirectional=self.bidirectional, rnn_type=self.rnn_type) output, hidden = encoder(self.padded_input, self.input_lengths) self.assertTrue(output.size(), torch.Size([self.N, self.T, self.hidden_size]))
def __init__(self, h_dim, res_h_dim, n_res_layers, embedding_dim, n_dimension_changes): super(E2EEncoder, self).__init__() # encode image into continuous latent space self.encoder = Encoder(3, h_dim, n_res_layers, res_h_dim, n_dimension_changes) self.pre_quantization_conv = nn.Conv2d(h_dim, embedding_dim, kernel_size=1, stride=1)
class Quantitative_analysis_demo(): def __init__(self, cfg, output_dir): self.encoder = Encoder(cfg) self.decoder = Decoder(cfg) self.refiner = Refiner(cfg) self.merger = Merger(cfg) # self.thresh = cfg.VOXEL_THRESH self.th = cfg.TEST.VOXEL_THRESH checkpoint = torch.load(cfg.CHECKPOINT) encoder_state_dict = clean_state_dict(checkpoint['encoder_state_dict']) self.encoder.load_state_dict(encoder_state_dict) decoder_state_dict = clean_state_dict(checkpoint['decoder_state_dict']) self.decoder.load_state_dict(decoder_state_dict) if cfg.NETWORK.USE_REFINER: refiner_state_dict = clean_state_dict( checkpoint['refiner_state_dict']) self.refiner.load_state_dict(refiner_state_dict) if cfg.NETWORK.USE_MERGER: merger_state_dict = clean_state_dict( checkpoint['merger_state_dict']) self.merger.load_state_dict(merger_state_dict) self.output_dir = output_dir def calculate_iou(self, imgs, GT_voxels, sid, mid, iid): dir1 = os.path.join(self.output_dir, str(sid), str(mid)) if not os.path.exists(dir1): os.makedirs(dir1) image_features = self.encoder(imgs) raw_features, generated_volume = self.decoder(image_features) generated_volume = self.merger(raw_features, generated_volume) generated_volume = self.refiner(generated_volume) generated_volume = generated_volume.squeeze() sample_iou = [] for th in self.th: _volume = torch.ge(generated_volume, th).float() intersection = torch.sum(_volume.mul(GT_voxels)).float() union = torch.sum(torch.ge(_volume.add(GT_voxels), 1)).float() sample_iou.append((intersection / union).item()) return sample_iou
def train(): torch.backends.cudnn.benchmark = True _, dataloader = create_dataloader(config.IMG_DIR + "/train", config.MESH_DIR + "/train", batch_size=config.BATCH_SIZE, used_layers=config.USED_LAYERS, img_size=config.IMAGE_SIZE, map_size=config.MAP_SIZE, augment=config.AUGMENT, workers=config.NUM_WORKERS, pin_memory=config.PIN_MEMORY, shuffle=True) in_channels = num_channels(config.USED_LAYERS) encoder = Encoder(in_channels=in_channels) decoder = Decoder(num_classes=config.NUM_CLASSES+1) encoder.apply(init_weights) decoder.apply(init_weights) encoder_solver = torch.optim.Adam(filter(lambda p: p.requires_grad, encoder.parameters()), lr=config.ENCODER_LEARNING_RATE, betas=config.BETAS) decoder_solver = torch.optim.Adam(decoder.parameters(), lr=config.DECODER_LEARNING_RATE, betas=config.BETAS) encoder_lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(encoder_solver, milestones=config.ENCODER_LR_MILESTONES, gamma=config.GAMMA) decoder_lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(decoder_solver, milestones=config.DECODER_LR_MILESTONES, gamma=config.GAMMA) encoder = encoder.to(config.DEVICE) decoder = decoder.to(config.DEVICE) loss_fn = LossFunction() init_epoch = 0 if config.CHECKPOINT_FILE and config.LOAD_MODEL: init_epoch, encoder, decoder = load_checkpoint(encoder, decoder, config.CHECKPOINT_FILE, config.DEVICE) output_dir = os.path.join(config.OUT_PATH, re.sub("[^0-9a-zA-Z]+", "-", dt.now().isoformat())) for epoch_idx in range(init_epoch, config.NUM_EPOCHS): encoder.train() decoder.train() train_one_epoch(encoder, decoder, dataloader, loss_fn, encoder_solver, decoder_solver, epoch_idx) encoder_lr_scheduler.step() decoder_lr_scheduler.step() if config.TEST: test(encoder, decoder) if config.SAVE_MODEL: save_checkpoint(epoch_idx, encoder, decoder, output_dir) if not config.TEST: test(encoder, decoder) if not config.SAVE_MODEL: save_checkpoint(config.NUM_EPOCHS - 1, encoder, decoder, output_dir)
class BlacklistCache: def __init__(self, client): self.client = client self.encoder = Encoder() def add_to_blacklist(self, text): encoded_text = self.encoder.encode(text) self.client.sadd(self.key_name(), encoded_text) def key_name(self): return "ureport-high-priority-blacklist"
class StepsCache: def __init__(self, client, username, password, url, cache_key_name): self.client = client self.username = username self.password = password self.url = url self.cache_key_name = cache_key_name self.encoder = Encoder() def get_key_name(self): return self.cache_key_name def add_script_steps_data(self): script_steps = self.get_steps_information() for value in script_steps: self.client.sadd(self.get_key_name(), self.encoder.encode(value)) def get_steps_information(self): response = self.get_authorized_response(self.url) data = json.loads(response.read()) return data["steps"] def delete_script_steps_data(self): self.client.delete(self.get_key_name()) def has_text(self, text): return self.client.sismember(self.get_key_name(), self.encoder.encode(text)) def get_authorized_response(self, url): request = urllib2.Request(url) base64string = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\n', '') request.add_header("Authorization", "Basic %s" % base64string) response = urllib2.urlopen(request) return response
def test_that_encode_text_using_md5(self): text = u"why dòn't ìnsért sòme strànge chàrs? ù.ù" encoder = Encoder() encoded_text = encoder.encode(text) self.assertEquals(encoded_text, 'encrypted_value')
def __init__(self, client): self.client = client self.encoder = Encoder()
def test_that_encode_text_using_md5(self): text = "important text" encoder = Encoder() encoded_text = encoder.encode(text) self.assertEquals(encoded_text, 'encrypted_value')