def main():
flags(sys.argv)
model_params = Inferencer_Params(image_size=256,
model_path=flags.model_dir)
model_inferencer = Inferencer(model_params)
pipeline_params = Pipeline_Inferencer_Params(data_dir_x=os.path.join(
flags.dataset, 'test_X'),
data_dir_y=None)
pipeline = Pipeline_Inferencer(inferencer=model_inferencer,
params=pipeline_params,
pre_processing=None)
count = 0
first_pass = True
while first_pass or img_out is not None:
if first_pass:
first_pass = False
if not os.path.exists(flags.outdir):
os.makedirs(flags.outdir)
img_out = pipeline.run()
if img_out is not None:
filename = get_filename(count, 'mask_')
imageio.imwrite(os.path.join(flags.outdir, filename), img_out)
print(' [*] save file ' + filename)
count += 1
def main():
input_directory = sys.argv[1];
output_directory = sys.argv[2];
if len(sys.argv)==4 and len(sys.argv[3])>0:
log_beta_path = sys.argv[3]
else:
log_beta_path = None;
from inferencer import Inferencer;
lda_inferencer = Inferencer();
lda_inferencer.load_params(os.path.join(output_directory, "current-params"));
lda_inferencer.load_tree(os.path.join(output_directory, "current-tree"));
lda_inferencer.format_output(input_directory);
if lda_inferencer._update_hyper_parameter:
lda_inferencer.dump_parameters(os.path.join(output_directory, "current-params"));
lda_inferencer.dump_E_log_beta(os.path.join(output_directory, "current-E-log-beta"));
if log_beta_path!=None:
lda_inferencer.export_E_log_beta(log_beta_path);
#if not hybrid_mode:
#lda_inferencer.dump_gamma(os.path.join(output_directory, "current-gamma"));
lda_inferencer.export_gamma(os.path.join(output_directory, "gamma"));
def main(config_file, run_type='train', checkpoint=''):
# pylint: disable=no-member
config = Config(config_file)
print(config)
if run_type == 'train':
from trainer import Trainer
trainer = Trainer(dataset_dir=config.dataset_dir,
log_dir=config.log_dir,
generator_channels=config.generator_channels,
discriminator_channels=config.discriminator_channels,
nz=config.nz,
style_depth=config.style_depth,
lrs=config.lrs,
betas=config.betas,
eps=config.eps,
phase_iter=config.phase_iter,
batch_size=config.batch_size,
n_cpu=config.n_cpu,
opt_level=config.opt_level)
trainer.run(log_iter=config.log_iter, checkpoint=checkpoint)
elif run_type == 'inference':
from inferencer import Inferencer
inferencer = Inferencer(
generator_channels=config.generator_channels,
nz=config.nz,
style_depth=config.style_depth,
)
inferencer.inference(n=8)
else:
raise NotImplementedError
def test(config):
_config_test(config)
de2idx, idx2de = load_de_vocab()
en2idx, idx2en = load_en_vocab()
model = ConvSeq2Seq(config)
graph_handler = GraphHandler(config)
inferencer = Inferencer(config, model)
sess = tf.Session()
graph_handler.initialize(sess)
global_step = 0
refs = []
hypotheses = []
with codecs.open(os.path.join(config.eval_dir, config.model_name), "w", "utf-8") as fout:
for i, batch in tqdm(enumerate(get_batch_for_test())):
preds = inferencer.run(sess, batch)
sources = batch['source']
targets = batch['target']
for source, target, pred in zip(sources, targets, preds):
got = " ".join(idx2en[idx] for idx in pred).split("</S>")[0].strip()
fout.write("- source: " + source +"\n")
fout.write("- expected: " + target + "\n")
fout.write("- got: " + got + "\n\n")
fout.flush()
ref = target.split()
hypothesis = got.split()
if len(ref) > 3 and len(hypothesis) > 3:
refs.append([ref])
hypotheses.append(hypothesis)
score = corpus_bleu(refs, hypotheses)
fout.write("Bleu Score = " + str(100*score))
def main():
A1 = fset.LeftSkewTrapezoid('A1', (0, 0), (1, 1), (4, 0))
A2 = fset.Triangle('A2', (2, 0), (5, 1), (8, 0))
A3 = fset.RightSkewTrapezoid('A3', (6, 0), (8, 1), (10, 0))
rule1 = 'IF x IS A1 THEN y IS B1'
rule2 = 'IF x IS A2 THEN y IS B2'
rule3 = 'IF x IS A3 THEN y IS B3'
fsets = [A1, A2, A3]
rules = [rule1, rule2, rule3]
inferencer = Inferencer()
inferencer.add_fsets(fsets)
inferencer.add_rules(rules)
input_test = {'x': 7}
print inferencer.evaluate(input_test)
def main(
metadata_path,
source_dir,
target_dir,
output_dir,
root,
batch_size,
reload,
reload_dir,
):
"""Main function"""
# import Inferencer module
inferencer = Inferencer(root)
device = inferencer.device
sample_rate = inferencer.sample_rate
print(f"[INFO]: Inferencer is loaded from {root}.")
metadata = json.load(open(metadata_path))
print(f"[INFO]: Metadata list is loaded from {metadata_path}.")
output_dir = Path(output_dir) / Path(root).stem / \
f"{metadata['source_corpus']}2{metadata['target_corpus']}"
output_dir.mkdir(parents=True, exist_ok=True)
if reload:
metadata, conv_mels = reload_from_numpy(device, metadata, reload_dir)
else:
metadata, conv_mels = conversion(inferencer, device, root, metadata,
source_dir, target_dir, output_dir)
waveforms = []
max_memory_use = conv_mels[0].size(0) * batch_size
with torch.no_grad():
pbar = tqdm(total=metadata["n_samples"])
left = 0
while (left < metadata["n_samples"]):
batch_size = max_memory_use // conv_mels[left].size(0) - 1
right = left + min(batch_size, metadata["n_samples"] - left)
waveforms.extend(
inferencer.spectrogram2waveform(conv_mels[left:right]))
pbar.update(batch_size)
left += batch_size
pbar.close()
for pair, waveform in tqdm(zip(metadata["pairs"], waveforms)):
waveform = waveform.detach().cpu().numpy()
prefix = Path(pair["src_utt"]).stem
postfix = Path(pair["tgt_utts"][0]).stem
file_path = output_dir / f"{prefix}_to_{postfix}.wav"
pair["converted"] = f"{prefix}_to_{postfix}.wav"
if Path(root).stem == "BLOW":
wavfile.write(file_path, sample_rate, waveform)
else:
sf.write(file_path, waveform, sample_rate)
metadata_output_path = output_dir / "metadata.json"
json.dump(metadata, metadata_output_path.open("w"), indent=2)
def main(TYPE="train", W_PATH=None):
print("TYPE", TYPE)
print("W_PATH", W_PATH)
engine = Trainer(W_PATH) if TYPE == "train" else Inferencer(W_PATH)
engine.run()
TRAIN_PATH, VAL_PATH, TEST_PATH, DH_PATH, LOAD_FROM_DUMP, 3)
""" model setup """
INPUT_DIM, OUTPUT_DIM = len(m_dh.de_vocab), len(m_dh.en_vocab)
enc = Encoder(INPUT_DIM, ENC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, ENC_DROPOUT)
attn = Attention(ENC_HID_DIM, DEC_HID_DIM, ATTN_DIM)
dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, ENC_HID_DIM, DEC_HID_DIM, DEC_DROPOUT,
attn)
model = Seq2Seq(enc, dec)
""" load model """
state_dict = torch.load('ckpts/best.pt')
model.load_state_dict(state_dict['model_state'])
model.eval()
en_infer = Inferencer(m_dh.en_vocab)
src, trg = next(iter(test_loader))
""" ______________ """
import matplotlib.pyplot as plt
import numpy
def plot_head_map(mma, target_labels, source_labels):
fig, ax = plt.subplots()
heatmap = ax.pcolor(mma, cmap=plt.cm.Blues)
# put the major ticks at the middle of each cell
ax.set_xticks(numpy.arange(mma.shape[1]) + 0.5,
minor=False) # mma.shape[1] = target seq 길이
ax.set_yticks(numpy.arange(mma.shape[0]) + 0.5,
minor=False) # mma.shape[0] = input seq 길이
