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