def train_model(grade_mode):
# Check that function parameters are valid
if not grade_mode in ['no_grade', 'post_grade', 'pre_grade']:
raise ValueError(
'Invalid grade_mode for model training. Use no_grade, post_grade or pre_grade as the grade_mode parameter.'
)
# Find directories
base_save_dir = '{}/data/lstm_files/{}/'.format(script_parent_directory,
grade_mode)
# Train the model
train.build_model(base_save_dir)
def main():
digit2idx, idx2digit = load_vocab()
X, I = load_test_data()
model = build_model(Hyperparams.ctxlen)
latest_ckpt = get_the_latest_ckpt()
model.load_weights(latest_ckpt)
with open('../result.csv', 'w') as fout:
fout.write("Id, Last\n")
for step in range(0, len(X), Hyperparams.batch_size):
xs = X[step:step + Hyperparams.batch_size]
ids = I[step:step + Hyperparams.batch_size]
_preds = []
for _ in range(10):
preds = model.predict(xs)
preds = preds[:, -1, :]
preds = np.argmax(preds, axis=-1)
_preds.append(preds)
preds = np.expand_dims(preds, -1)
xs = np.concatenate((xs, preds), 1)[:, 1:]
_preds = np.array(_preds).transpose()
for p, id in zip(_preds, ids):
p = "".join(idx2digit[idx] for idx in p).split(",")[0]
fout.write("{},{}\n".format(id, p))
fout.flush()
def main(path: str):
_configs = load_configs(path)
_batch_size = _configs['hyperparams']['batch_size']
_epochs = _configs['hyperparams']['epochs']
_embedding_size = _configs['hyperparams']['embedding_size']
_conv_dim = _configs['hyperparams']['convolution_dims']
_eval_steps = _configs['hyperparams']['evaluation_steps']
print('Getting dataset...')
_data_manager = prepare_dataset(_configs)
_vocab_size = _data_manager.get_vocabulary_size()
_pretrained_embeddings = _data_manager.get_pretrained_word_embedding()
print('Now build model...')
model = build_model(_vocab_size, _embedding_size, _conv_dim, embeddings=_pretrained_embeddings)
train_dataloader = _data_manager.get_train_data_loader(_batch_size)
test_dataloader = _data_manager.get_test_data_loader(_batch_size)
print('Train start!')
train_manager = TrainManager(train_dataloader,
test_dataloader,
model,
_epochs,
_eval_steps)
train_manager.train()
def test_train_pipeline(fix_seed, config, gpus):
config = OmegaConf.create(config)
train_dataloader, test_dataloader = get_data_loaders(config=config)
lr_logger = LearningRateLogger()
model = build_model(model_conf=config.model)
runner = Runner(model=model, config=config.runner)
trainer = Trainer(
distributed_backend=config.runner.trainer.distributed_backend,
fast_dev_run=True,
gpus=gpus,
amp_level="O2",
row_log_interval=10,
callbacks=[lr_logger],
max_epochs=1,
weights_summary="top",
reload_dataloaders_every_epoch=False,
resume_from_checkpoint=None,
benchmark=False,
deterministic=True,
num_sanity_val_steps=5,
overfit_batches=0.0,
precision=32,
profiler=True,
)
trainer.fit(model=runner,
train_dataloader=train_dataloader,
val_dataloaders=test_dataloader)
def train_selected_model(activation,
learning_rate,
momentum,
n_points,
n_epochs,
batch_size,
plot_points=False):
train_data, test_data = data.generate_data(n_points)
model = train.build_model(activation)
optimizer = optim.SGD(model.parameters(),
lr=learning_rate,
momentum=momentum)
criterion = framework.MSELoss()
t0 = time.perf_counter()
history = train.train_model(model, optimizer, criterion, train_data,
test_data, n_epochs, batch_size)
t1 = time.perf_counter()
result = {
'train_loss': train.compute_loss(model, criterion, train_data,
batch_size),
'test_loss': train.compute_error(model, train_data, batch_size) * 100,
'train_err': train.compute_loss(model, criterion, test_data,
batch_size),
'test_err': train.compute_error(model, test_data, batch_size) * 100,
'time': t1 - t0
}
if plot_points:
plot.plot_points(test_data, train_data, model, plot_points)
return history, result
def eval_one_mol(smiles, model_save_dir_root, gpu):
# smiles = Chem.MolToSmiles(mol, isomericSmiles=True)
featurizer = dc.feat.CircularFingerprint(size=1024)
loader = dc.data.CSVLoader(tasks=[],
smiles_field='smiles',
featurizer=featurizer)
test_file = io.StringIO(f"smiles\n{smiles}\n")
test_dataset = loader.create_dataset(test_file, shard_size=8096)
device = f"/gpu:{gpu}"
pred_list = []
config = tf.compat.v1.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.1 # 程序最多只能占用指定gpu50%的显存
config.gpu_options.allow_growth = True # 不全部占满显存, 按需分配
sess = tf.compat.v1.Session(config=config)
backend.set_session(sess)
for m in ['seed0', 'seed1', 'seed2']:
model_save_dir = f"{model_save_dir_root}/{m}"
checkpoint = find_best_model_checkpoint(model_save_dir)
with tf.device(device):
model = build_model(model_save_dir)
model.restore(checkpoint)
model.batch_size = 2
# model.to(device)
result = model.predict(test_dataset)
if result.shape[-1] == 1:
result = result.squeeze(-1)
pred_list.append(result[0][55])
return mean(pred_list)
def load(self, checkpoint_path, fast=True):
# Presets
if hparams.preset is not None and hparams.preset != "":
preset = hparams.presets[hparams.preset]
import json
hparams.parse_json(json.dumps(preset))
print("Override hyper parameters with preset \"{}\": {}".format(
hparams.preset, json.dumps(preset, indent=4)))
self._frontend = getattr(frontend, hparams.frontend)
import train
train._frontend = self._frontend
from train import build_model
# Model
self.model = build_model()
# Load checkpoints separately
checkpoint = torch.load(checkpoint_path)
self.model.load_state_dict(checkpoint["state_dict"])
#model.seq2seq.decoder.max_decoder_steps = max_decoder_steps
self.use_cuda = torch.cuda.is_available()
if self.use_cuda:
self.model = self.model.cuda()
self.model.eval()
if fast:
self.model.make_generation_fast_()
def main(path: str):
_configs = load_configs(path)
_batch_size = _configs['hyperparams']['batch_size']
_epochs = _configs['hyperparams']['epochs']
_eval_steps = _configs['hyperparams']['evaluation_steps']
_model_params = _configs['hyperparams']['model']
print('Getting dataset...')
_data_manager = prepare_dataset(_configs)
_vocab_size = _data_manager.get_vocabulary_size()
_model_params['vocab_size'] = _vocab_size
print('Now build model...')
model = build_model(_model_params)
train_dataloader = _data_manager.get_train_data_loader(_batch_size)
test_dataloader = _data_manager.get_test_data_loader(100)
print(model)
print('Train start!')
train_manager = TrainManager(train_dataloader, test_dataloader, model,
_epochs, _eval_steps)
train_manager.train()
def build(self):
self.model_file = tf.train.get_checkpoint_state(
'./out').model_checkpoint_path
graph = tf.Graph()
with graph.as_default():
self.source_ids = tf.placeholder(
tf.int32,
[self.options.batch_size, self.options.max_source_length])
self.target_ids = tf.placeholder(
tf.int32,
[self.options.batch_size, self.options.max_target_length])
self.source_mask = tf.placeholder(
tf.int32,
[self.options.batch_size, self.options.max_source_length])
self.target_mask = tf.placeholder(
tf.int32,
[self.options.batch_size, self.options.max_target_length])
self.ouputs = train.build_model(self.source_ids, self.target_ids,
self.source_mask, self.target_mask,
False, self.options)
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
self.sess = tf.Session(graph=graph, config=sess_config)
tf_vars_dict = {i.name: i for i in tf.trainable_variables()}
a_map = get_assign_map(tf_vars_dict)
tf.train.init_from_checkpoint(self.model_file, a_map)
self.sess.run(tf.global_variables_initializer())
def damage_by_segmentation(path):
"""
Generate solution .png files, using a single multiclass segmentation
model to do so.
"""
model = train.build_model(classes=6, damage=True)
model = train.load_weights(model,
"damage-motokimura-mobilenetv2-best.hdf5")
#model.load_individual_weights()# = train.load_weights(model, S.DMG_MODELSTRING_BEST)
df = flow.Dataflow(files=flow.get_test_files(),
transform=False,
batch_size=1,
buildings_only=False,
shuffle=False,
return_postmask=False,
return_stacked=True,
return_average=False)
pbar = tqdm.tqdm(total=len(df))
for image, filename in df:
filename = os.path.basename(filename)
filename = filename.replace("pre", "localization").replace(
".png", "_prediction.png")
#if os.path.exists(os.path.join("solution", filename)):
# continue
# localization (segmentation)
pred = model.predict([image])
mask = infer.convert_prediction(pred)
write_solution(names=[filename], images=[mask], path=path)
filename = filename.replace("localization", "damage")
write_solution(names=[filename], images=[mask], path=path)
pbar.update(1)
def damage_random(path):
"""
Generate solution .png files using random damage.
"""
model = train.build_model(
train=False) #, save_path="motokimura-stacked-2.hdf5")
model = train.load_weights(model, S.MODELSTRING_BEST)
df = flow.Dataflow(files=flow.get_test_files(),
transform=False,
batch_size=1,
buildings_only=False,
shuffle=False,
return_postmask=False,
return_stacked=True,
return_average=False)
pbar = tqdm.tqdm(total=len(df))
for image, filename in df:
filename = os.path.basename(filename)
filename = filename.replace("pre", "localization").replace(
".png", "_prediction.png")
#if os.path.exists(os.path.join("solution", filename)):
# continue
# localization (segmentation)
pred = model.predict([image])
mask = infer.convert_prediction(pred)
write_solution(names=[filename], images=[mask], path=path)
mask = randomize_damage(mask)
filename = filename.replace("localization", "damage")
write_solution(names=[filename], images=[mask], path=path)
pbar.update(1)
def single_worker(device, num_jobs, args, idx_beg=0):
if idx_beg > 0 and num_jobs == 1:
local_writers = [open(f"{args.output_dir}/decode.{args.nj}.ark", 'wb')]
else:
local_writers = [open(f"{args.output_dir}/decode.{i+1}.ark", 'wb')
for i in range(num_jobs)]
inferset = InferDataset(args.input_scp)
inferset.dataset = inferset.dataset[idx_beg:]
testloader = DataLoader(
inferset, batch_size=1, shuffle=False,
num_workers=args.workers, pin_memory=True)
with open(args.config, 'r') as fi:
configures = json.load(fi)
model = build_model(args, configures, train=False)
model = model.to(device)
model.load_state_dict(torch.load(
args.resume, map_location=device))
model.eval()
print("> Model built.")
print(" Model size:{:.2f}M".format(
utils.count_parameters(model)/1e6))
cal_logit(model, testloader, device, local_writers)
def predict(img):
inputs, pred = train.build_model()
model = keras.Model(inputs, pred)
model.load_weights('model/result.h5')
y = model.predict(img)
return y
def eval_test(model_save_dir_root, test_file, pred_path, gpu):
featurizer = dc.feat.CircularFingerprint(size=1024)
loader = dc.data.CSVLoader(tasks=[],
smiles_field='smiles',
featurizer=featurizer)
test_dataset = loader.create_dataset(test_file, shard_size=8096)
device = f"cuda:{gpu}"
pred_list = []
for m in ['seed0', 'seed1', 'seed2']:
model_save_dir = f"{model_save_dir_root}/{m}"
model = build_model(model_save_dir)
checkpoint = find_best_model_checkpoint(model_save_dir)
model.restore(checkpoint)
# model.to(device)
result = model.predict(test_dataset)
if result.shape[-1] == 1:
pred = pd.DataFrame(result.squeeze(-1))
else:
pred = pd.DataFrame(result)
pred['smiles'] = test_dataset.ids.tolist()
# dummmy column for next pipeline
pred['label'] = 0
pred_list.append(pred)
pred = pd.concat(pred_list)
score_colnames = [c for c in pred.columns]
score_colnames.remove('smiles')
score_colnames.remove('label')
# average the values from 3 models as the score
pred.groupby(['smiles'],
sort=False)[score_colnames].apply(lambda x: mean(x))
# pred = pred.reset_index()
cols = ['smiles', 'label']
cols.extend(score_colnames)
pred.to_csv(pred_path, index=False, columns=cols)
def load_model(checkpoint):
"""
This funtion builds the NN model with its associated weights from the
checkpoint folder. It returns this model and the class to name dictionary for
later use in the identification of the flower type.
"""
# Checks that directory exists. If not, uses the default directory
if os.path.isdir(checkpoint) == False:
print(
"Checkpoint path does not exist. Using the default checkpoint folder.\n"
)
checkpoint = 'checkpoint'
# Loads the number of hidden neurons
hidden = torch.load(checkpoint + '/hidden.pth')
# Loads the VGG type used
arch = torch.load(checkpoint + '/vgg_ver.pth')
# Builds the initial model
model, hidden = build_model(arch, hidden)
# Converts to the cpu to upload
model.to('cpu')
# Loads the state dictionary and weights from checkpoint.pth file
state_dict = torch.load(checkpoint + '/checkpoint.pth')
# Loads the state dictionary into the model
model.load_state_dict(state_dict)
# Loads the class to index map into the class_to_idx dictionary
class_to_idx = torch.load(checkpoint + '/class_to_idx.pth')
return model, class_to_idx
def freezon_graph(params):
# from tensorflow.python.framework.graph_util import convert_variables_to_constants
# https://github.com/tensorflow/tensorflow/issues/31331
import tensorflow as tf
import tensorflow.compat.v1.keras.backend as K
from tensorflow.python.tools import freeze_graph
K.set_learning_phase(0)
model = build_model(params)
sess = K.get_session()
graph = sess.graph
pb_file = "test.pb"
outdir = "./test/"
print(model.outputs, model.inputs)
# unfriendly ops: tf.newaxis, dims more than 4
mid, lge = model.outputs
if params.tflite:
mid = tf.reshape(mid, (
tf.shape(mid)[0],
-1,
tf.shape(mid)[-1],
))
lge = tf.reshape(lge, (
tf.shape(lge)[0],
-1,
tf.shape(lge)[-1],
))
merge_branch = tf.concat([mid, lge], axis=1)
model.inputs[0].set_shape([1, params.test_input, params.test_input, 3])
converter = tf.compat.v1.lite.TFLiteConverter.from_session(
sess, model.inputs, [merge_branch])
converter.optimizations = [tf.lite.Optimize.DEFAULT]
#converter.target_spec.supported_types = [tf.compat.v1.lite.constants.FLOAT16]
tflite_model = converter.convert()
open("gesture.tflite", "wb").write(tflite_model)
return
tf.compat.v1.saved_model.simple_save(K.get_session(),
outdir,
inputs={"input": model.inputs[0]},
outputs={
"output0": mid,
"output1": lge
})
freeze_graph.freeze_graph(None,
None,
None,
None,
mid.op.name + "," + lge.op.name,
None,
None,
os.path.join(outdir, pb_file),
False,
"",
input_saved_model_dir=outdir)
def load_model(model_name):
from train import build_model
from train import restore_parts, load_checkpoint
checkpoint_path = model_name
model = build_model()
model = load_checkpoint(checkpoint_path, model, None, True)
return model
def main():
model = build_model('resnet34', 'square_crop', pretrained=True)
print(model)
input1 = torch.zeros(32, 1, 137, 236)
input2 = torch.zeros(32, 1, 128, 128)
out = model.forward((input1, input2))
print(out.shape)
def init_model():
model = build_model(3)
device = torch.device('cpu')
checkpoint = torch.load("./checkpoint/chkpoint_9.pt",
map_location={'cuda:0':
'cpu'}) #read from last checkpoint
model.load_state_dict(checkpoint['state_dict'])
model.eval() #evaluation mode
return model
def test_train_success(self):
train_root_dir = self._config['train_root_dir']
if not tf.gfile.Exists(train_root_dir):
tf.gfile.MakeDirs(train_root_dir)
for stage_id in train.get_stage_ids(**self._config):
tf.reset_default_graph()
real_images = provide_random_data()
model = train.build_model(stage_id, real_images, **self._config)
train.add_model_summaries(model, **self._config)
train.train(model, **self._config)
def damage_by_building_classification(path):
"""
Generate solution .png files, classifying damage using contiguous
regions in the segmentation model's predicted masks in order to extract
individual building polygons from pre-disaster and post-disaster images.
"""
# load the localization (segmentation) model
S.BATCH_SIZE = 1
model = train.build_model(architecture=S.ARCHITECTURE, train=True)
model = train.load_weights(
model, S.MODELSTRING_BEST) #.replace(".hdf5", "-best.hdf5"))
# load the damage classification model
dmg_model = damage.build_model()
dmg_model = damage.load_weights(dmg_model, S.DMG_MODELSTRING_BEST)
# get a dataflow for the test files
df = flow.Dataflow(files=flow.get_test_files(),
transform=False,
shuffle=False,
buildings_only=False,
batch_size=1,
return_stacked=True)
i = 0
pbar = tqdm.tqdm(total=len(df))
# x = pre-disaster image, y = post-disaster image
for stacked, filename in df:
filename = os.path.basename(filename)
x = stacked
#filename = os.path.basename(df.samples[i][0].img_name)
filename = filename.replace("pre", "localization").replace(
".png", "_prediction.png")
#if os.path.exists(os.path.join("solution", filename)):
# continue
# localization (segmentation)
pred = model.predict(x)
mask = infer.convert_prediction(pred)
write_solution(names=[filename], images=[mask], path=path)
# damage classification
filename = filename.replace("localization", "damage")
pre, post = stacked[..., :3], stacked[
..., 3:] #df.samples[i][0].image(), df.samples[i][1].image()
boxes, coords = flow.Building.get_all_in(pre, post, mask)
if len(boxes) > 0:
labels = dmg_model.predict(boxes)
for k, c in enumerate(coords):
x, y, w, h = c
mask[y:y + h, x:x + w] = np.argmax(labels[k]) + 1
write_solution(names=[filename], images=[mask], path=path)
pbar.update(1)
i += 1
def test_train_success(self):
train_root_dir = self._config['train_root_dir']
if not tf.gfile.Exists(train_root_dir):
tf.gfile.MakeDirs(train_root_dir)
for stage_id in train.get_stage_ids(**self._config):
tf.reset_default_graph()
real_images = provide_random_data()
model = train.build_model(stage_id, real_images, **self._config)
train.add_model_summaries(model, **self._config)
train.train(model, **self._config)
def apply(beginning, num_of_chars, save_to_JS=False):
# load model
# model = keras.models.load_model(os.path.join(MODEL_PATH, 'model.h5'))
with open(os.path.join(MODEL_PATH, 'text_to_int.pickle'), 'rb') as handle:
text_to_int = pickle.load(handle)
with open(os.path.join(MODEL_PATH, 'int_to_text.pickle'), 'rb') as handle:
int_to_text = pickle.load(handle)
with open(os.path.join(MODEL_PATH, 'vocab_size.pickle'), 'rb') as handle:
vocab_size = pickle.load(handle)
model = build_model(vocab_size=vocab_size,
embedding_dim=EMBEDDING_DIM,
rnn_units=RNN_UNITS,
batch_size=1)
model.load_weights(os.path.join(MODEL_PATH, 'model'))
print('Load model successfully.')
# for Tensorflowjs
if save_to_JS:
if Path(JS_PATH).is_dir():
shutil.rmtree(JS_PATH)
data = {'text_to_int': text_to_int, 'int_to_text': int_to_text}
with open('data.json', 'w', encoding='utf-8') as f:
f.write(json.dumps(data))
print('Dict written to data.json.')
tfjs.converters.save_keras_model(model, JS_PATH)
print('Model for JS saved to %s.' % JS_PATH)
input_seq_jieba = [l for l in list(jieba.cut(beginning)) if l != ' ']
input_seq_int = [
text_to_int[w] for w in input_seq_jieba if w in text_to_int
]
if len(input_seq_int) == 0:
input_seq_int = [text_to_int['<br>']]
input_seq = tf.expand_dims(input_seq_int, axis=0) # Add a dim
text_generated = ''
model.reset_states() # Add this because 'stateful=True'
while len(text_generated) < num_of_chars:
predictions = model.predict(input_seq)
predictions = tf.squeeze(predictions, axis=0)
predictions /= TEMPERATURE
predicted_id = tf.random.categorical(predictions,
num_samples=1).numpy()[-1][0]
input_seq = tf.expand_dims([predicted_id], 0) # Add a dim
text_generated += int_to_text[
predicted_id] if int_to_text[predicted_id] != '<br>' else '\n'
return text_generated
def __init__(self, config, **opt):
# Load config used for training and merge with testing options
self.config = yaml.load(open(config, "r"))
self.config = Namespace(**{**self.config, **opt})
# Load training data.pkl for src and tgt vocabs
self.data = load_data(self.config)
# Load trained model checkpoints
device, devices_ids = misc_utils.set_cuda(self.config)
self.model, _ = build_model(None, self.config, device)
self.model.eval()
def load_model(checkpoint_path):
''' Load the model from checkpoint
'''
checkpoint = torch.load(checkpoint_path)
# Get model from checkpoint
model = build_model(architecture=checkpoint['model'])
## Build classifier architecture
# Define first layer
architecture = OrderedDict([
('fc1', nn.Linear(checkpoint['input'], checkpoint['hidden'][0])),
('re1', nn.ReLU()),
('dr1', nn.Dropout(p=checkpoint['p_drop'])),
])
## If 1+ hidden layers
if len(checkpoint['hidden']) > 1:
# Define the hidden layer(s)
for index, layer_size in enumerate(
zip(checkpoint['hidden'][:-1], checkpoint['hidden'][1:])):
architecture.update({
'fc{}'.format(index + 2):
nn.Linear(layer_size[0], layer_size[1])
})
architecture.update({'re{}'.format(index + 2): nn.ReLU()})
architecture.update(
{'dr{}'.format(index + 2): nn.Dropout(p=p_drop)})
# Define the last layer
architecture.update({
'fc{}'.format(index + 3):
nn.Linear(checkpoint['hidden'][-1], checkpoint['output'])
})
architecture.update({'log': nn.LogSoftmax(dim=1)})
## If no hidden layers
if len(checkpoint['hidden']) == 1:
architecture.update(
{'fc2': nn.Linear(checkpoint['hidden'][0], checkpoint['output'])})
architecture.update({'log': nn.LogSoftmax(dim=1)})
classifier = nn.Sequential(architecture)
model.classifier = classifier
# Load state dict
model.load_state_dict(checkpoint['state_dict'])
# Load classifier
optimizer = optim.SGD(params=model.classifier.parameters(),
lr=checkpoint['lr'],
momentum=checkpoint['momentum'])
optimizer.load_state_dict(checkpoint['optimizer'])
return model, optimizer
def load(checkpoint_path):
checkpoint = torch.load(checkpoint_path)
model = build_model(checkpoint['architecture'],
checkpoint['hidden_layers'], checkpoint['output_size'],
checkpoint['class_to_idx'])
model.load_state_dict(checkpoint['state_dict'])
# optimizer.load_state_dict(checkpoint['optimizer'])
# print("Loaded '{}' (arch={}, hidden_layers={})".format(
# checkpoint_path,
# checkpoint['architecture'],
# checkpoint['hidden_layers']))
return model
def test_inference_vs_train(self):
self.assertTrue(False) # disable and auto fail this test for now
tf.reset_default_graph()
with tf.Session() as sess:
conf = config.generate_config(keep_prob=1.0)
conf['batch_size'] = 1
data = data_pipe.Data('./example_data/', conf['batch_size'], conf['max_word_len'], conf['max_line_len'])
model, free_model = train.build_model(data, conf)
data.initialize(sess, data.datadir + '*')
sess.run(tf.tables_initializer())
sess.run(tf.global_variables_initializer())
(out_logits_4,
src_sentence_3,
src_sent_len_1,
trg_sentence_3,
trg_sent_len_1) = sess.run([model.out_logits_4,
data.src.to_tensor(-1),
data.src_sentence_len,
data.trg.to_tensor(-1),
data.trg_sentence_len])
src = data.array_to_strings(src_sentence_3)[0].replace(data.go_stop_token, '')
trg = data.array_to_strings(trg_sentence_3)[0].replace(data.go_stop_token, '')
# trg is the concatenation of itself with src. Restore the stop word that delimits them
trg = trg[len(src):]
trg = src + ' ' + data.go_stop_token + ' ' + trg.strip() # recombine src and trg
print src
print trg
feed = {data.src_place:src, data.trg_place:trg}
(free_logits_4,
src_sentence_inference,
trg_sentence_inference) = sess.run([free_model.out_logits_4,
data.src_inference.to_tensor(-1),
data.trg_inference.to_tensor(-1)], feed_dict=feed)
# Get the fist batch line and trim potential batch padding from the model's logits
out_logits_3 = out_logits_4[0, :free_logits_4.shape[1], :free_logits_4.shape[2], :]
# Check that the model's outputs are the same regardless of what data pipeline is used
self.assertTrue((np.abs(out_logits_3 - free_logits_4[0]) < 1e-5).all())
# Run the inference model as though generating one char at time, and check the outputs
feed = {data.src_place:src, data.trg_place:''} # Start with no input
free_logits_4 = sess.run(free_model.out_logits_4, feed_dict=feed)
self.assertTrue((np.abs(free_logits_4[0,0,0,:] - out_logits_3[0,0,:]) <= 1e-5).all())
trg = trg.split()
trg_so_far = ''
for word_idx, trg_word in enumerate(trg):
for chr_num in range(len(trg_word)):
trg_so_far += trg_word[chr_num]
feed = {data.src_place:src, data.trg_place:trg_so_far}
free_logits_4 = sess.run(free_model.out_logits_4, feed_dict=feed)
# print (free_logits_4[0, word_idx, chr_num + 1,:] - out_logits_3[word_idx, chr_num + 1, :]) < 1e-4
self.assertTrue((np.abs(free_logits_4[0, word_idx, chr_num + 1,:] - out_logits_3[word_idx, chr_num + 1, :]) <= 1e-5).all())
trg_so_far += ' '
def main():
args = get_args()
weight_path = args.weight_path
if not os.path.exists(RESPATH):
os.makedirs(RESPATH)
viddata, auddata = train.load_data(DATAPATH)
net_out = auddata.shape[1]
viddata, auddata_norm, auddata_means, auddata_stds = standardize_data(
viddata, auddata)
model = train.build_model(net_out)
model.compile(loss='mse', optimizer='adam')
model.load_weights(weight_path)
aud_pred = train.predict(model, viddata, auddata_means, auddata_stds)
np.save(join(RESPATH, 'aud_pred.npy'), aud_pred)
def load_checkpoint(checkpoint):
state = torch.load(checkpoint)
arch = state['arch']
lr = float(state['learning_rate'])
hidden_units = int(state['hidden_units'])
model, optimizer, criterion = \
train.build_model(arch, hidden_units, lr)
model.class_to_idx = state['class_to_idx']
model.load_state_dict(state['state_dict'])
optimizer.load_state_dict(state['optimizer'])
return model
def main():
args = get_args()
weight_path = args.weight_path
if not os.path.exists(RESPATH):
os.makedirs(RESPATH)
(Xtr, Ytr), (Xte, Yte) = train.load_data(DATAPATH)
net_out = Ytr.shape[1]
Xtr, Ytr_norm, Xte, Yte_norm, Y_means, Y_stds = train.standardize_data(
Xtr, Ytr, Xte, Yte)
model = train.build_model(net_out)
model.compile(loss='mse', optimizer='adam')
model.load_weights(weight_path)
Ytr_pred, Yte_pred = train.predict(model, Xtr, Xte, Y_means, Y_stds)
train.savedata(Ytr, Ytr_pred, Yte, Yte_pred, respath=RESPATH)
def setup():
os.chdir(ROOT)
if not exists(NAME):
url = "https://github.com/r9y9/" + NAME
os.system("git clone %s" % url)
os.chdir(NAME)
os.system("pip install -q -e \'.[bin]\'") # THIS MIGHT NOT WORK: TEST
#os.system("./dependency_scipt.sh") # Install python dependcies
#os.system("./dependency_scipt.sh") # Install bash dependcies
os.system("python -m nltk.downloader cmudict") # English text processing
# Get the model
os.system("git checkout %s --quiet" % BRANCH)
if not exists(PRESET):
url = "https://www.dropbox.com/s/0ck82unm0bo0rxd/" + PRESET
os.system("curl -O -L %s" % url)
if not exists(CHECKPOINT):
url = "https://www.dropbox.com/s/5ucl9remrwy5oeg/" + CHECKPOINT
os.system("curl -O -L %s" % url)
# Hyper parameters
import hparams
import json
# Load parameters from preset
with open(PRESET) as f:
hparams.hparams.parse_json(f.read())
# Inject frontend text processor
import synthesis
import train
from deepvoice3_pytorch import frontend
synthesis._frontend = getattr(frontend, "en")
train._frontend = getattr(frontend, "en")
# alises
fs = hparams.hparams.sample_rate
hop_length = hparams.hparams.hop_size
print(os.path.dirname(os.path.realpath(__file__)))
# Load model
from train import build_model
from train import restore_parts, load_checkpoint
print("Building model")
model = build_model()
model = load_checkpoint(CHECKPOINT, model, None, True)
return model
def main(_):
if not tf.gfile.Exists(FLAGS.train_root_dir):
tf.gfile.MakeDirs(FLAGS.train_root_dir)
config = _make_config_from_flags()
logging.info('\n'.join(['{}={}'.format(k, v) for k, v in config.iteritems()]))
for stage_id in train.get_stage_ids(**config):
tf.reset_default_graph()
with tf.device(tf.train.replica_device_setter(FLAGS.ps_tasks)):
real_images = None
with tf.device('/cpu:0'), tf.name_scope('inputs'):
real_images = _provide_real_images(**config)
model = train.build_model(stage_id, real_images, **config)
train.add_model_summaries(model, **config)
train.train(model, **config)
def yield_chars():
text, char_indices, indices_char = load_data()
model = build_model(indices_char)
load_latest_model(model)
start_index = random.randint(0, len(text) - MAXLEN - 1)
gen = sample_from_model(text, start_index, char_indices, model, indices_char)
next_letter_upper = False
for c in gen:
if next_letter_upper and c.upper() != c:
yield c.upper()
next_letter_upper = False
else:
yield c
if c == '.':
next_letter_upper = True
import train
udp_host = "localhost"
udp_port = 4000
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
key_wait_time = 10
input_size = 128
capture = cv2.VideoCapture(0)
# video_size = (int(capture.get(cv2.CAP_PROP_FRAME_WIDTH)),
# int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT)))
# print "Video width, height: " + str(video_size)
model = train.build_model()
model.load('checkpoints/road_model1-72')
def process_frame(frame):
pr = model.predict(frame[np.newaxis, :, :, np.newaxis])
return pr[0][0]
while capture.isOpened():
success, frame = capture.read()
if success:
time_now = time()
if time_now >= time_next:
time_next = time_now + time_delay
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
