def evaluate(hparams, ckpt):
if hparams.model_architecture == "rnn-model": model_creator = model.RNN
else: raise ValueError("Unknown model architecture. Only simple_rnn is supported so far.")
if hparams.val_target_path:
eval_model = model_helper.create_eval_model(model_creator, hparams, tf.contrib.learn.ModeKeys.EVAL)
eval_sess = tf.Session(config=utils.get_config_proto(), graph=eval_model.graph)
with eval_model.graph.as_default():
loaded_eval_model = model_helper.load_model(eval_model.model, eval_sess, "evaluation", ckpt)
iterator_feed_dict={
eval_model.input_file_placeholder: hparams.eval_input_path,
eval_model.output_file_placeholder: hparams.eval_target_path
}
eval_loss = eval(loaded_eval_model, eval_sess, eval_model.iterator, iterator_feed_dict)
print("Eval loss: %.3f"%eval_loss)
print("Starting predictions:")
prediction_model = model_helper.create_infer_model(model_creator, hparams, tf.contrib.learn.ModeKeys.INFER)
prediction_sess = tf.Session(config=utils.get_config_proto(), graph=prediction_model.graph)
with prediction_model.graph.as_default():
loaded_prediction_model = model_helper.load_model(prediction_model.model, prediction_sess, "prediction", ckpt)
iterator_feed_dict = {
prediction_model.input_file_placeholder: hparams.val_input_path,
}
predictions=predict(loaded_prediction_model, prediction_sess, prediction_model.iterator, iterator_feed_dict)
np.savetxt(os.path.join(hparams.eval_output_folder, "classes.txt"), predictions["classes"])
np.savetxt(os.path.join(hparams.eval_output_folder, "probabilities.txt"), predictions["probabilities"])
def infer(ckpt, inference_input_file, inference_output_file, hparams):
"""
Perform translation.
"""
model_creator = gnmt_model.GNMTModel
infer_model = model_helper.create_infer_model(model_creator, hparams)
# Read data
infer_data = utils.load_data(inference_input_file)
config_proto = tf.ConfigProto()
config_proto.gpu_options.allow_growth = True
with tf.Session(
graph=infer_model.graph, config=config_proto) as sess:
loaded_infer_model = model_helper.load_model(
infer_model.model, ckpt, sess, "infer")
sess.run(
infer_model.iterator.initializer,
feed_dict={
infer_model.src_placeholder: infer_data,
infer_model.batch_size_placeholder: hparams.infer_batch_size
})
# Decode
utils.log("Start decoding")
loaded_infer_model.decode_and_evaluate(
"infer",
sess,
inference_output_file,
ref_file=None,
beam_width=hparams.beam_width,
tgt_eos=hparams.eos,
num_translations_per_input=hparams.num_translations_per_input)
def start_sess_and_load_model(infer_model, ckpt_path):
"""Start session and load model."""
sess = tf.Session(graph=infer_model.graph, config=utils.get_config_proto())
with infer_model.graph.as_default():
loaded_infer_model = model_helper.load_model(infer_model.model,
ckpt_path, sess, "infer")
return sess, loaded_infer_model
def evaluate(hparams, ckpt):
if hparams.model_architecture == "simple_rnn":
model_creator = model.RNN
else:
raise ValueError("Unknown model architecture. Only simple_rnn is supported so far.")
print("Starting evaluation and predictions:")
# create eval graph.
eval_model = model_helper.create_eval_model(model_creator, hparams, tf.contrib.learn.ModeKeys.EVAL)
eval_sess = tf.Session(config=utils.get_config_proto(), graph=eval_model.graph)
with eval_model.graph.as_default():
# load pretrained model.
loaded_eval_model = model_helper.load_model(eval_model.model, eval_sess, "evaluation", ckpt)
iterator_feed_dict = {
eval_model.input_file_placeholder: hparams.eval_input_path,
eval_model.output_file_placeholder: hparams.eval_target_path
}
eval_loss, eval_accuracy, predictions = eval_and_precit(loaded_eval_model, eval_sess, eval_model.iterator,
iterator_feed_dict)
print("Eval loss: %.3f, Eval accuracy: %.3f" % (eval_loss, eval_accuracy))
# only models with CRF include trans. params.
transition_params = eval_sess.run(loaded_eval_model.transition_params)
if transition_params is not None:
print("Saving transition parameters:")
np.savetxt(os.path.join(hparams.eval_output_folder, "transition_params.txt"), transition_params)
print("Saving predictions:")
cPickle.dump(predictions,
open(os.path.join(hparams.eval_output_folder,
hparams.predictions_filename.split(".")[0] + ".pickle"),
"wb"))
def determine_acceptance(input_dict):
global model
'''
Take input form from stdin and print binary decision to stdout.
'''
# Parse input
# input_dict = parse_input(argv[1:])
for key in input_dict.keys():
try:
input_dict[key] = int(input_dict[key])
except:
input_dict[key] = True if input_dict[key] == u'on' else False
# Preprocess
preprocessed_data = md.predict(input_dict)
# Load model and predict
if model == None:
model = mh.load_model()
dec_val = model.predict(preprocessed_data)[0]
print("DECISION VALUE: " + str(dec_val))
decision = dec_val >= 0.5
# Output to stdout
return decision
def single_worker_inference(infer_model,
ckpt,
inference_input_file,
inference_output_file,
hparams):
"""Inference with a single worker."""
output_infer = inference_output_file
# Read data
infer_data = load_data(inference_input_file, hparams)
with tf.Session(config=utils.get_config_proto(), graph=infer_model.graph) as sess:
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt, sess, "infer")
sess.run(infer_model.iterator.initializer,
feed_dict={
infer_model.src_placeholder: infer_data,
infer_model.batch_size_placeholder: hparams.infer_batch_size
})
# Decode
utils.print_out("# Start decoding")
_decode_and_evaluate("infer",
loaded_infer_model,
sess,
output_infer,
ref_file=None,
subword_option=None,
beam_width=hparams.beam_width,
tgt_eos=hparams.eos,
num_translations_per_input=hparams.num_translations_per_input)
def single_worker_inference( #emb_matrix,
infer_model, ckpt, inference_input_file, inference_output_file,
hparams, model_creator):
"""Inference with a single worker."""
output_infer = inference_output_file
# Read data
infer_data = load_data(inference_input_file, hparams)
#saver = tf.train.Saver()
with tf.Session(graph=infer_model.graph,
config=utils.get_config_proto()) as sess:
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt,
sess, "infer")
sess.run(infer_model.iterator.initializer,
feed_dict={
infer_model.src_placeholder: infer_data,
infer_model.batch_size_placeholder:
hparams.infer_batch_size
})
#sess.run(model_creator._build_decoder.eval())
# Decode
#saver = tf.train.Saver()
#emb=sess.run(emb_matrix)
#fw=open('/home/yuzw/pun/nmt/inference/embedding_ds','w+')
#fw.write('\n'.join(
# [' '.join([str(u) for u in e]) for e in emb]))
#print("emb=sess.run(emb_matrix)",emb)
#save_path = saver.save(sess, "/home/yuzw/pun/nmt/inference/emb.npz")
#print("Model saved in path: %s" % save_path)
utils.print_out("# Start decoding single_worker_inference")
if hparams.inference_indices:
_decode_inference_indices(
loaded_infer_model,
sess,
output_infer=output_infer,
output_infer_summary_prefix=output_infer,
inference_indices=hparams.inference_indices,
tgt_eos=hparams.eos,
subword_option=hparams.subword_option)
else:
nmt_utils.decode_and_evaluate(
"infer",
loaded_infer_model,
sess,
output_infer,
ref_file=None,
metrics=hparams.metrics,
subword_option=hparams.subword_option,
beam_width=hparams.beam_width,
tgt_eos=hparams.eos,
num_translations_per_input=hparams.num_translations_per_input)
def single_worker_inference(infer_model, infer_sess, eval_model, eval_sess,
ckpt, summary_writer, global_step, hparams):
"""the actual function for inference."""
# load datasets
infer_src_data = load_data(hparams.infer_src_data)
infer_tar_data = load_data(hparams.infer_tar_data)
infer_kb = load_data(hparams.infer_kb)
# load model and session
start_time = time.time()
with infer_model.graph.as_default():
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt,
infer_sess, "infer")
infer_sess.run(
infer_model.infer_iterator.initializer,
feed_dict={
infer_model.data_src_placeholder: infer_src_data,
infer_model.kb_placeholder: infer_kb,
infer_model.batch_size_placeholder: hparams.infer_batch_size
})
infer_handle = infer_sess.run(infer_model.infer_iterator.string_handle())
# Decode
utils.print_out("# Start decoding")
evaluation_scores = dialogue_utils.decode_and_evaluate(
"infer",
loaded_infer_model,
infer_handle,
infer_sess,
hparams.inference_output_file,
ref_file=hparams.infer_tar_data,
metrics=hparams.metrics,
hparams=hparams,
infer_src_data=infer_src_data)
# summary writer
for key in evaluation_scores:
# utils.add_summary(summary_writer,)
utils.add_summary(summary_writer, global_step, key,
evaluation_scores[key])
# sample some dialogue and decode them for qualitative examination
_sample_decode(loaded_infer_model, global_step, infer_handle, infer_sess,
hparams, infer_model.infer_iterator, infer_src_data,
infer_tar_data, infer_kb, infer_model.data_src_placeholder,
infer_model.kb_placeholder,
infer_model.batch_size_placeholder)
# run eval model to get perplexity
eval_handle = eval_sess.run(eval_model.eval_iterator.string_handle())
dev_ppl, _ = run_internal_eval(eval_model, eval_handle, eval_sess,
hparams.out_dir, hparams, summary_writer)
utils.add_summary(summary_writer, global_step, "dev_ppl", dev_ppl)
total_inference_time = time.time() - start_time
utils.add_summary(summary_writer, global_step, "infer_time",
total_inference_time)
def start_sess_and_load_model(infer_model, ckpt_path, hparams):
"""Start session and load model."""
print("num_intra_threads = %d, num_inter_threads = %d \n" %
(hparams.num_intra_threads, hparams.num_inter_threads))
sess = tf.Session(graph=infer_model.graph,
config=utils.get_config_proto(
num_intra_threads=hparams.num_intra_threads,
num_inter_threads=hparams.num_inter_threads))
with infer_model.graph.as_default():
loaded_infer_model = model_helper.load_model(infer_model.model,
ckpt_path, sess, "infer")
return sess, loaded_infer_model
def inference(infer_data):
with tf.Session(graph=infer_model.graph,
config=utils.get_config_proto()) as sess:
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt,
sess, "infer")
sess.run(infer_model.iterator.initializer,
feed_dict={
infer_model.src_placeholder: [infer_data],
infer_model.batch_size_placeholder:
hparams.infer_batch_size
})
translation = decode_inference_indices(loaded_infer_model, sess)
return translation
def main(argv):
try:
opts, args = getopt.getopt(argv, 'hm:d',
['help', 'file=', 'dataset=', 'mode='])
except getopt.GetoptError:
print('\nUSAGE:')
console.success('process_data.py --dataset <dataset_name>')
sys.exit(2)
for opt, arg in opts:
if opt in ('-h', '--help'):
print('\nUSAGE:')
print(
'process_data.py --dataset <dataset_name> --file <file_name> --mode <mode>'
)
sys.exit()
elif opt in ('-f', '--file'):
file_name = arg
elif opt in ('-m', '--mode'):
if arg in ['train', 'predict']:
mode = arg
else:
mode = None
elif opt in ('-d', '--dataset'):
dataset_name = arg
else:
print('Invalid options. Run with --help to see usage')
series = pd.read_csv(file_name,
sep=',',
header=0,
index_col=0,
squeeze=True)
data = series.values
model_file = 'models/' + dataset_name + '.json'
model_weights_file = 'models/' + dataset_name + '.h5'
if mode == 'train':
train(data, model_file, model_weights_file)
elif mode == 'predict':
model = model_helper.load_model(model_file, model_weights_file)
predict(data, model, 3)
else:
print('Invalid options. Run with --help to see usage')
def inference(infer_data):
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5,
allow_growth=True)
with tf.Session(graph=infer_model.graph,
config=tf.ConfigProto(gpu_options=gpu_options,
allow_soft_placement=True,
log_device_placement=True)) as sess:
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt,
sess, "infer")
sess.run(infer_model.iterator.initializer,
feed_dict={
infer_model.src_placeholder: [infer_data],
infer_model.batch_size_placeholder:
hparams.infer_batch_size
})
translation = decode_inference_indices(loaded_infer_model, sess)
return translation
def inference(ckpt, inference_output_folder, hparams):
output_infer = inference_output_folder
# Read data
mnist = input_data.read_data_sets("data/", one_hot=True)
if hparams.infer_source == "test":
infer_data = mnist.test.images
infer_labels = mnist.test.labels
elif hparams.infer_source == "validation":
infer_data = mnist.validation.images
infer_labels = mnist.validation.labels
elif hparams.infer_source == "train":
infer_data = mnist.train.images
infer_labels = mnist.train.labels
infer_sample_idxs = random.sample(range(infer_data.shape[0]),
hparams.infer_sample)
infer_sample = infer_data[infer_sample_idxs, :]
infer_sample_labels = infer_labels[infer_sample_idxs, :]
dataset, x_placeholder, batch_placeholder = model_helper.create_batched_dataset(
hparams.x_dim)
iterator = tf.contrib.data.Iterator.from_structure(
mnist.train.images.dtype, tf.TensorShape([None, hparams.x_dim]))
init_op = iterator.make_initializer(dataset)
next_x = iterator.get_next()
dropout = tf.placeholder(tf.float32, name='dropout')
model = vae_model.FullyConnectedVAE(hparams, next_x, dropout)
with tf.Session() as session:
model = model_helper.load_model(model, ckpt, session)
session.run(init_op,
feed_dict={
x_placeholder: infer_sample,
batch_placeholder: infer_sample.shape[0],
dropout: 0.0
})
# Decode
outputs, zs, xs = model.infer(session)
plot_images(outputs, xs, hparams, output_infer)
if zs.shape[1] == 2:
plot_zs(zs, infer_sample_labels, output_infer)
def single_worker_inference(infer_model, ckpt, inference_input_file,
inference_output_file, hparams):
"""Inference with a single worker."""
output_infer = inference_output_file
# Read data
infer_data = load_data(inference_input_file, hparams)
with tf.Session(graph=infer_model.graph,
config=utils.get_config_proto()) as sess:
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt,
sess, "infer")
sess.run(infer_model.iterator.initializer,
feed_dict={
infer_model.src_placeholder: infer_data,
infer_model.batch_size_placeholder:
hparams.infer_batch_size
})
# Decode
utils.print_out("# Start decoding")
if hparams.inference_indices:
_decode_inference_indices(
loaded_infer_model,
sess,
output_infer=output_infer,
output_infer_summary_prefix=output_infer,
inference_indices=hparams.inference_indices,
tgt_sos=hparams.sos,
tgt_eos=hparams.eos,
bpe_delimiter=hparams.bpe_delimiter)
else:
nmt_utils.decode_and_evaluate("infer",
loaded_infer_model,
sess,
output_infer,
ref_file=None,
metrics=hparams.metrics,
bpe_delimiter=hparams.bpe_delimiter,
beam_width=hparams.beam_width,
tgt_sos=hparams.sos,
tgt_eos=hparams.eos)
def _load_model(self, checkpoint_path, default_hparams_path,
model_hparams_path, source_vocab_path, target_vocab_path):
hparams = self._create_hparams(default_hparams_path,
model_hparams_path, source_vocab_path,
target_vocab_path)
model_creator = gnmt_model.GNMTModel
infer_model = model_helper.create_infer_model(model_creator,
hparams,
scope=None)
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=GPU_MEM_FRAC)
sess = tf.Session(graph=infer_model.graph,
config=tf.ConfigProto(gpu_options=gpu_options,
allow_soft_placement=True))
with infer_model.graph.as_default():
nmt_model = model_helper.load_model(infer_model.model,
checkpoint_path, sess, "infer")
return sess, nmt_model, infer_model, hparams
def train(data, model_file, model_weights_file):
parameter_file = 'training_config.json'
params = json.loads(open(parameter_file).read())
x_train, y_train, x_test, y_test, x_test_raw, y_test_raw, last_window_raw, last_window = data_helper.load_timeseries(
data, params)
model_file_path = Path(model_file)
if model_file_path.is_file():
print('Existing trained model found.')
model = model_helper.load_model(model_file, model_weights_file)
else:
print('Creating a new model.')
lstm_layer = [1, params['window_size'], params['hidden_unit'], 1]
model = model_helper.rnn_lstm(lstm_layer, params)
model.fit(x_train,
y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
validation_split=params['validation_split'],
verbose=1)
predicted = model_helper.predict_next_timestamp(model, x_test)
predicted_raw = []
for i in range(len(x_test_raw)):
predicted_raw.append((predicted[i] + 1) * x_test_raw[i][0])
# serialize model to JSON
model_json = model.to_json()
with open(model_file, 'w') as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights(model_weights_file)
print("Saved model to disk")
def multi_worker_inference(infer_model, ckpt, inference_input_file,
inference_output_file, hparams, num_workers, jobid):
"""Inference using multiple workers."""
assert num_workers > 1
final_output_infer = inference_output_file
output_infer = "%s_%d" % (inference_output_file, jobid)
output_infer_done = "%s_done_%d" % (inference_output_file, jobid)
# Read data
infer_data = load_data(inference_input_file, hparams)
# Split data to multiple workers
total_load = len(infer_data)
load_per_worker = int((total_load - 1) / num_workers) + 1
start_position = jobid * load_per_worker
end_position = min(start_position + load_per_worker, total_load)
infer_data = infer_data[start_position:end_position]
with tf.Session(graph=infer_model.graph,
config=utils.get_config_proto()) as sess:
loaded_infer_model = model_helper.load_model(infer_model.model, ckpt,
sess, "infer")
sess.run(infer_model.iterator.initializer,
{infer_model.src_placeholder: infer_data})
# Decode
utils.print_out("# Start decoding")
nmt_utils.decode_and_evaluate("infer",
loaded_infer_model,
sess,
output_infer,
ref_file=None,
metrics=hparams.metrics,
bpe_delimiter=hparams.bpe_delimiter,
beam_width=hparams.beam_width,
tgt_eos=hparams.eos)
# Change file name to indicate the file writing is completed.
tf.gfile.Rename(output_infer, output_infer_done, overwrite=True)
# Job 0 is responsible for the clean up.
if jobid != 0: return
# Now write all translations
with codecs.getwriter("utf-8")(tf.gfile.GFile(final_output_infer,
mode="wb")) as final_f:
for worker_id in range(num_workers):
worker_infer_done = "%s_done_%d" % (inference_output_file,
worker_id)
while not tf.gfile.Exists(worker_infer_done):
utils.print_out(" waitting job %d to complete." %
worker_id)
time.sleep(10)
with codecs.getreader("utf-8")(tf.gfile.GFile(
worker_infer_done, mode="rb")) as f:
for translation in f:
final_f.write("%s" % translation)
tf.gfile.Remove(worker_infer_done)
import sys from model_helper import load_model, save_weights, train_mnist epoch = 5 mini_batch = 200 model_file = sys.argv[1] weights_file = sys.argv[2] weights_dest_file = sys.argv[3] model = load_model(model_file, weights_file) model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy']) (x_train, y_train) = train_mnist() model.fit(x_train, y_train, nb_epoch = epoch, batch_size = mini_batch) save_weights(model.get_weights(), weights_dest_file)
from flask import request
from flask import jsonify
from datetime import datetime
import hashlib
import model_helper as mh
import cassandra_helper as ch
MODEL_FILE_PATH = r"./model_saved"
DATABASE_FILE_PATH = ""
OUTPUT_PATH =""
app = Flask(__name__)
model = mh.load_model(MODEL_FILE_PATH)
@app.route("/")
def index():
return render_template('index.html', title='Sumbit Page')
@app.route("/view_classifier")
def classifier():
comments = ['''Every once in a while a movie comes, that truly makes an impact. Joaquin's performance and scenography in all it's brilliance. Grotesque,
haunting and cringy. Hard to watch at times,... but so mesmerizing, you won't blink an eye watching it. Tragic, but with seriously funny moments.
Emotional rollercoaster - sometimes, with multiple emotions popping-up at the same time.
this is far from a typical action-riddled predictable super-hero movie - it's a proper psychological thriller/drama, with the single best character development I have ever seen.''']
input_tensor = mh.Text_to_Tensor_converter(comments)
predict_result = model.predict(input_tensor)
import KIPlayer
import HumanPlayer
import TicTacToe as ttt
import model_helper
import tensorflow as tf
import random
import config
continue_playing = True
print('loading AI...')
with tf.Session() as sessX:
x_tensor, pred_tensor = model_helper.load_model(sessX, 'tf-model/X')
with tf.Session() as sessO:
model_helper.load_model(sessO, 'tf-model/O')
while continue_playing:
game = ttt.TicTacToe(config.board_size, config.board_size, config.runlength)
# choose starter
if random.choice([True, False]):
fun_to_play_X = KIPlayer.next_move
fun_to_visualize_X = KIPlayer.visualize
fun_to_play_O = HumanPlayer.next_move
fun_to_visualize_O = None
print('X: Computer, O: You')
else:
fun_to_play_X = HumanPlayer.next_move
fun_to_visualize_X = None
fun_to_play_O = KIPlayer.next_move
fun_to_visualize_O = KIPlayer.visualize
print('X: You, O: Computer')
