def train_and_eval(train_steps, log_dir, training_set, validation_set, testing_set, ):
sparse_columns = [
layers.sparse_column_with_keys(attribute, training_set[attribute].unique()) for attribute in FEATURE_ATTRIBUTES
]
embedding_columns = [
layers.embedding_column(column, dimension=8) for column in sparse_columns
]
m = learn.DNNClassifier(
hidden_units=[10, 50, ],
feature_columns=embedding_columns,
model_dir=log_dir,
config=learn.RunConfig(save_checkpoints_secs=1, ),
)
validation_metrics = {
"accuracy": learn.MetricSpec(metric_fn=metrics.streaming_accuracy, prediction_key="classes"),
"precision": learn.MetricSpec(metric_fn=metrics.streaming_precision, prediction_key="classes"),
"recall": learn.MetricSpec(metric_fn=metrics.streaming_recall, prediction_key="classes"),
}
monitors = [
learn.monitors.ValidationMonitor(
input_fn=lambda: input_fn(validation_set),
every_n_steps=1000,
metrics=validation_metrics,
early_stopping_rounds=1,
),
]
m.fit(
input_fn=lambda: input_fn(training_set),
steps=train_steps,
monitors=monitors,
)
results = m.evaluate(input_fn=lambda: input_fn(testing_set), steps=1)
for key in sorted(results):
print("%s: %s" % (key, results[key]))
def get_spike_classifier(config):
spike_classifier = learn.Estimator(model_fn=simple_model_fn,
model_dir=config['model_name'],
config=learn.RunConfig(
save_checkpoints_secs=60,
log_device_placement=True,
keep_checkpoint_every_n_hours=1,
keep_checkpoint_max=int(1e6)),
params=config)
return spike_classifier
def fit(self, X, y=None):
config = learn.RunConfig(num_cores=get_n_jobs(self.n_jobs),
tf_random_seed=self.random_state)
self.model = learn.Estimator(model_fn=self._model_spec(),
config=config)
steps_per_iter = _steps_per_iter(X, self.batch_size)
n_steps = int(steps_per_iter * self.n_iter)
self.model.fit(X, y=y, steps=n_steps, batch_size=self.batch_size)
def main(argv=None):
hparams = HParams(batch_size=128, hidden_units=[256], learning_rate=.001)
output_dir = 'test'
config = learn.RunConfig(save_checkpoints_secs=600,
model_dir=output_dir,
gpu_memory_fraction=1)
learn_runner.run(experiment_fn=_experiment_fn,
run_config=config,
hparams=hparams)
def main(unused_argv):
hparams = mds_hparams.create_hparams()
#loading the train and validation data
model_fn = mds_model.create_model_fn(hparams)
#load model
sess_cfg = tf.ConfigProto(device_count={'GPU': 0})
run_cfg = learn.RunConfig(session_config=sess_cfg,
save_checkpoints_steps=FLAGS.checkpoints_steps,
keep_checkpoint_max=FLAGS.keep_checkpoint_max,
keep_checkpoint_every_n_hours=10000)
estimator = learn.Estimator(model_fn=model_fn,
model_dir=MODEL_DIR,
config=run_cfg)
# set up logging for predictions
# log the values in the 'Softmax' tensor with label 'probabilities'
tensors_to_log = {"probabilities": 'softmax_tensor'}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log,
every_n_iter=100)
input_fn_train = mds_inputs.create_input_fn(mode=learn.ModeKeys.TRAIN,
input_files=[TRAIN_FILE],
batch_size=hparams.batch_size,
num_epochs=FLAGS.num_epochs)
input_fn_eval = mds_inputs.create_input_fn(
mode=learn.ModeKeys.EVAL,
input_files=[VALIDATION_FILE],
batch_size=hparams.eval_batch_size,
num_epochs=1)
# set up eval metrics
eval_metrics = mds_metrics.create_evaluation_metrics()
eval_monitor = learn.monitors.ValidationMonitor(
input_fn=input_fn_eval,
every_n_steps=FLAGS.eval_every,
metrics=eval_metrics,
eval_steps=None,
early_stopping_metric='loss',
early_stopping_metric_minimize=True,
early_stopping_rounds=None)
#early_stopping_rounds = 3)
# train and evaluate
estimator.fit(input_fn=input_fn_train,
steps=None,
max_steps=hparams.max_steps,
monitors=[eval_monitor, logging_hook])
def _get_config():
"""Get configuration object for `Estimator` object.
For open-soucing, `EstimatorConfig` has been replaced with `RunConfig`.
Depends on `flags.FLAGS`, and should not be used outside of this main script.
Returns:
`EstimatorConfig` object.
"""
config = learn.RunConfig(
model_dir=FLAGS.restore_dir if FLAGS.infer else FLAGS.output_dir,
keep_checkpoint_max=0, # Keep all checkpoints.
save_checkpoints_steps=FLAGS.save_checkpoints_steps)
return config
def predict_conv_network(nn_id, predict_data):
try:
# check network is ready to train
utils.tfmsa_logger("[1]check pre steps ready")
utils.check_requested_nn(nn_id)
# get network base info
utils.tfmsa_logger("[2]get network base info")
net_info = netconf.get_network_config(nn_id)
# get network format info
utils.tfmsa_logger("[3]get network format info")
conf_info = netconf.load_conf(nn_id)
learnrate = conf_info.data.learnrate
label_set = json.loads(net_info['datasets'])
conf_info.n_class = len(label_set)
# define classifier
utils.tfmsa_logger("[4]define classifier")
classifier = learn.Estimator(
model_fn=ConvCommonManager(conf_info).struct_cnn_layer,
model_dir=netconf.nn_model_manager.get_model_save_path(nn_id),
config=learn.RunConfig(save_checkpoints_secs=1))
# start train
#TODO : need to find way to predict without fit
utils.tfmsa_logger("[5]fit dummy")
train_x = np.array([
ConvCommonManager(conf_info).create_dummy_matrix(
len(predict_data[0]))
], np.float32)
train_y = np.array(
netcommon.convert_to_index(json.loads(net_info['datasets'])),
np.int32)
classifier.fit(train_x, train_y, steps=int(1))
# predict result
utils.tfmsa_logger("[6]predict result")
y_predicted = [
label_set[int(p['class'])]
for p in classifier.predict(x=np.array(predict_data, np.float32),
batch_size=1,
as_iterable=True)
]
return y_predicted
except Exception as e:
print("Error Message : {0}".format(e))
raise Exception(e)
def contrib_learn_classifier_test():
"""Test tf.contrib.learn.DNN_classifier."""
language_column = layers.sparse_column_with_hash_bucket(
"language", hash_bucket_size=20)
feature_columns = [
layers.embedding_column(language_column, dimension=3),
layers.real_valued_column("age", dtype=tf.int64)
]
classifier = learn.DNNClassifier(
n_classes=3,
feature_columns=feature_columns,
hidden_units=[100, 100],
config=learn.RunConfig(tf_random_seed=1,
model_dir="../model_saver/estimators/"
"DNN_classifier_01"),
# optimizer=optimizer_exp_decay
)
classifier.fit(input_fn=_input_fn, steps=10000)
print("variables_names:\n", str(classifier.get_variable_names()))
# scores = classifier.evaluate(input_fn=_input_fn,
# steps=100)
# print("scores:\n", str(scores))
scores = classifier.evaluate(
input_fn=_input_fn,
steps=100,
metrics={
'my_accuracy':
MetricSpec(metric_fn=metrics.streaming_accuracy,
prediction_key="classes"),
'my_precision':
MetricSpec(metric_fn=metrics.streaming_precision,
prediction_key="classes"),
'my_recall':
MetricSpec(metric_fn=metrics.streaming_recall,
prediction_key="classes"),
'my_metric':
MetricSpec(metric_fn=my_metric_op, prediction_key="classes")
})
print("scores:\n", str(scores))
predictions = classifier.predict(input_fn=_input_fn,
outputs=["classes", "probabilities"])
print("predictions")
for prediction in predictions:
print(prediction)
def _experiment_fn(output_dir):
runconfig = learn.RunConfig(gpu_memory_fraction=0.6, )
estimator = learn.Estimator(model_fn=cnn_maker.make_model(
args.learning_rate),
model_dir=output_dir,
config=runconfig)
return learn.Experiment(
estimator,
train_input_fn=train_input_fn,
eval_input_fn=eval_input_fn,
train_steps=args.num_epochs,
eval_metrics=cnn_maker.METRICS, # AGREGAR METRICAS
continuous_eval_throttle_secs=args.min_eval_seconds,
min_eval_frequency=args.min_train_eval_rate,
)
def train_and_eval(model_dir, training_set, testing_set, ):
sparse_columns = [
layers.sparse_column_with_keys(
attribute['name'], pandas.read_csv(attribute['path'], sep='\t')['id'].apply(str),
) for attribute in FEATURE_ATTRIBUTES
]
embedding_columns = [layers.embedding_column(column, dimension=3) for column in sparse_columns]
model = learn.DNNRegressor(
hidden_units=[3, ],
feature_columns=embedding_columns,
model_dir=model_dir,
config=learn.RunConfig(save_checkpoints_secs=100, ),
)
model.fit(input_fn=lambda: input_fn(training_set), steps=20000, )
results = model.evaluate(input_fn=lambda: input_fn(testing_set), steps=1)
for key in sorted(results):
print('%s: %s' % (key, results[key]))
def main(argv=None):
local_device_protos = device_lib.list_local_devices()
gpus = [x.name for x in local_device_protos if x.device_type == 'GPU']
num_gpus = len(gpus)
if num_gpus > 0:
logging.info("Using the following GPUs to train: " + str(gpus))
num_towers = num_gpus
device_string = '/gpu:%d'
else:
logging.info("No GPUs found. Training on CPU.")
num_towers = 1
device_string = '/cpu:%d'
hparams = HParams(
batch_size=FLAGS.batch_size,
learning_rate_decay=FLAGS.learning_rate_decay,
learning_rate_decay_examples=FLAGS.learning_rate_decay_examples,
optimizer=FLAGS.optimizer,
label_loss=FLAGS.label_loss,
model=FLAGS.model,
base_learning_rate=FLAGS.base_learning_rate,
reader=get_reader(),
num_towers=num_towers,
device_string=device_string,
num_readers=FLAGS.num_readers,
num_epochs=FLAGS.num_epochs,
train_data_pattern=FLAGS.train_data_pattern,
eval_data_pattern=FLAGS.eval_data_pattern,
num_gpus=num_gpus,
regularization_penalty=FLAGS.regularization_penalty,
clip_gradient_norm=FLAGS.clip_gradient_norm)
config = learn.RunConfig(save_checkpoints_secs=10,
save_summary_steps=1000,
model_dir=FLAGS.train_dir)
learn_runner.run(experiment_fn=_experiment_fn,
run_config=config,
hparams=hparams,
schedule='train_and_evaluate')
if __name__ == "__main__":
model_params = dict(num_class=len(CLASS_MAP),
num_char=len(CHARS_MAP),
emb_size=128,
rnn_units=256,
input_keep_prob=0.85,
output_keep_prob=0.85,
learning_rate=10e-4,
grad_clip=1.0,
k=2)
rnn_model = learn.Estimator(model_fn=rnn_segment,
params=model_params,
model_dir="model/_rnn_model",
config=learn.RunConfig(
save_checkpoints_secs=30,
keep_checkpoint_max=2))
train_input_fn = data_provider("data/_tf_records/train", batch_size=128)
test_input_fn = data_provider("data/_tf_records/test", batch_size=512)
validation_monitor = monitors.ValidationMonitor(input_fn=test_input_fn,
eval_steps=10,
every_n_steps=500,
name='validation')
# rnn_model.fit(input_fn=train_input_fn, steps=1, monitors=[validation_monitor])
rnn_model.evaluate(input_fn=test_input_fn, steps=10)
text = """นางกุหลาบขายกุหลาบจำหน่ายไม้ดอกไม้ประดับ"""
tudkum(text, rnn_model, model_params['k'])
correctPred = tf.equal(tf.argmax(logits, 1), labels)
accuracy = tf.reduce_mean(tf.cast(correctPred, tf.float64))
tf.summary.scalar('Accuracy', accuracy)
merged = tf.summary.merge_all()
if mode == tf.contrib.learn.ModeKeys.TRAIN or mode == tf.contrib.learn.ModeKeys.EVAL:
loss = tf.losses.sparse_softmax_cross_entropy(labels, logits)
train_op = tf.contrib.layers.optimize_loss(
loss,
tf.contrib.framework.get_global_step(),
optimizer='Adam',
learning_rate=0.01)
else:
loss = None
train_op = None
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
output_dir = '/Users/clementmanger/Desktop/tensorboard/CNN'
#Estimator instance
cnn = tf.estimator.Estimator(model_fn=cnn_model,
config=tflearn.RunConfig(model_dir=output_dir))
cnn.train(input_fn=train_input_fn, steps=5000)
cnn.evaluate(input_fn=eval_input_fn, steps=5)
def main(unused_argv):
params = resnet_params.from_file(FLAGS.param_file)
params = resnet_params.override(params, FLAGS.param_overrides)
params['batch_size'] = FLAGS.target_batch_size
resnet_params.log_hparams_to_model_dir(params, FLAGS.model_dir)
print('Model params: {}'.format(params))
if params['use_async_checkpointing']:
save_checkpoints_steps = None
else:
save_checkpoints_steps = FLAGS.pre_train_steps + FLAGS.finetune_steps + FLAGS.ctrl_steps
save_checkpoints_steps = max(1000, params['iterations_per_loop'])
run_config_args = {
'model_dir': FLAGS.model_dir,
'save_checkpoints_steps': save_checkpoints_steps,
'log_step_count_steps': FLAGS.log_step_count_steps,
'keep_checkpoint_max': 100,
}
run_config_args['master'] = FLAGS.master
config = contrib_learn.RunConfig(**run_config_args)
resnet_classifier = tf.estimator.Estimator(get_model_fn(config),
config=config)
use_bfloat16 = params['precision'] == 'bfloat16'
def _merge_datasets(train_batch):
feature, label = train_batch
features = {
'feature': feature,
}
labels = {
'label': label,
}
return (features, labels)
def make_input_dataset(params):
"""Returns input dataset."""
finetune_dataset = data_input.ImageNetInput(
dataset_name=FLAGS.target_dataset,
num_classes=data_input.num_classes_map[FLAGS.target_dataset],
task_id=1,
is_training=True,
data_dir=FLAGS.data_dir,
dataset_split=FLAGS.dataset_split,
transpose_input=params['transpose_input'],
cache=False,
image_size=params['image_size'],
num_parallel_calls=params['num_parallel_calls'],
use_bfloat16=use_bfloat16)
finetune_data = finetune_dataset.input_fn(params)
dataset = tf.data.Dataset.zip((finetune_data, ))
dataset = dataset.map(_merge_datasets)
dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
return dataset
# pylint: disable=protected-access
current_step = estimator._load_global_step_from_checkpoint_dir(
FLAGS.model_dir)
train_steps = FLAGS.train_steps
while current_step < train_steps:
next_checkpoint = train_steps
resnet_classifier.train(input_fn=make_input_dataset,
max_steps=next_checkpoint)
current_step = next_checkpoint
def train_kmeans(patch_file_pattern,
num_clusters,
batch_size,
train_steps,
min_eval_frequency=None):
"""Runs TensorFlow K-Means over TFRecords.
Args:
patch_file_pattern: Pattern that matches TFRecord file(s) holding Examples
with image patches.
num_clusters: Number of output clusters.
batch_size: Size of a k-means minibatch.
train_steps: Number of steps for k-means training.
min_eval_frequency: The minimum number of steps between evaluations. Of
course, evaluation does not occur if no new snapshot is available, hence,
this is the minimum. If 0, the evaluation will only happen after
training. If None, defaults to 1. To avoid checking for new checkpoints
too frequent, the interval is further limited to be at least
check_interval_secs between checks. See
third_party/tensorflow/contrib/learn/python/learn/experiment.py for
details.
Returns:
A NumPy array of shape (num_clusters, patch_height * patch_width). The
cluster centers.
"""
def input_fn():
"""The tf.learn input_fn.
Returns:
features, a float32 tensor of shape
(batch_size, patch_height * patch_width).
None for labels (not applicable to k-means).
"""
examples = contrib_learn.read_batch_examples(
patch_file_pattern,
batch_size,
tf.TFRecordReader,
queue_capacity=batch_size * 2)
features = tf.parse_example(
examples, {
'features':
tf.FixedLenFeature(FLAGS.patch_height * FLAGS.patch_width,
tf.float32)
})['features']
return features, None # no labels
def experiment_fn(run_config, unused_hparams):
"""The tf.learn experiment_fn.
Args:
run_config: The run config to be passed to the KMeansClustering.
unused_hparams: Hyperparameters; not applicable.
Returns:
A tf.contrib.learn.Experiment.
"""
kmeans = contrib_learn.KMeansClustering(num_clusters=num_clusters,
config=run_config)
return contrib_learn.Experiment(estimator=kmeans,
train_steps=train_steps,
train_input_fn=input_fn,
eval_steps=1,
eval_input_fn=input_fn,
min_eval_frequency=min_eval_frequency)
output_dir = tempfile.mkdtemp(prefix='staffline_patches_kmeans')
try:
learn_runner.run(
experiment_fn,
run_config=contrib_learn.RunConfig(model_dir=output_dir))
num_features = FLAGS.patch_height * FLAGS.patch_width
clusters_t = tf.Variable(
tf.zeros((num_clusters, num_features)), # Dummy init op
name='clusters')
with tf.Session() as sess:
tf.train.Saver(var_list=[clusters_t]).restore(
sess, os.path.join(output_dir, 'model.ckpt-%d' % train_steps))
return clusters_t.eval()
finally:
shutil.rmtree(output_dir)
def predict_loop():
timer = FPSTimer()
pause=True
return_was_down=False
if flags.multi_gpu:
model_fn = cnn_model_fn_multigpu
else:
model_fn = cnn_model_fn
config = learn.RunConfig(gpu_memory_fraction=0.4)
gta_driver = FastPredict(learn.Estimator(model_fn=model_fn, model_dir="/tmp/gta_driver_model", config=config))
sct = mss.mss()
mon = {'top': 0, 'left': 0, 'width': 800, 'height': 600}
speed=0
print('Ready')
while True:
if (win32api.GetAsyncKeyState(0x08)&0x8001 > 0):
break
if (win32api.GetAsyncKeyState(0x0D)&0x8001 > 0):
if (return_was_down == False):
if (pause == False):
pause = True
j.data.wAxisX = int(vjoy_max * 0.5)
j.data.wAxisY = int(vjoy_max * 0)
j.data.wAxisZ = int(vjoy_max * 0)
j.update()
print('Paused')
else:
pause = False
print('Resumed')
return_was_down = True
else:
return_was_down = False
if (pause):
time.sleep(0.01)
continue
sct_img = sct.grab(mon)
img = Image.frombytes('RGB', sct_img.size, sct_img.rgb)
img = img.resize((640, 360), PIL.Image.BICUBIC)
img = img.crop(box=(0, 200, 640, 360))
img = np.array(img)
img = img.astype(np.float32, copy=False)
img = np.divide(img, 255)
img = np.reshape(img, (640*160*3))
img = (img - np.mean(img)) / max(np.std(img), 1.0/np.sqrt(img.size))
try:
file = open("speed.txt", "r")
speed = float(file.read())
file.close()
except (ValueError):
pass
features = np.concatenate((np.array([speed], dtype=np.float32), img))
predictions = gta_driver.predict(features)
j.data.wAxisX = int(vjoy_max * min(max(predictions["predictions"][0], 0), 1))
j.data.wAxisY = int(vjoy_max * min(max(predictions["predictions"][1], 0), 1))
j.data.wAxisZ = int(vjoy_max * min(max(predictions["predictions"][2], 0), 1))
j.update()
os.system('cls')
print("Steering Angle: %.2f" % min(max(predictions["predictions"][0], 0), 1))
print("Throttle: %.2f" % min(max(predictions["predictions"][1], 0), 1))
print("Brake: %.2f" % min(max(predictions["predictions"][2], 0), 1))
def run_version(i, dropout, use_gru, fc_layers_sizes, cell_units, cell_proj,
cell_count):
parameters = \
{
"vocabulary_size" : 10000,
"max_inputs_len" : Tone_utils.MAXLEN,
"embedding_size" : 128,
"nb_classes" : Tone_utils.NB_CLASSES,
"use_gru" : use_gru,
"lstm_units" : cell_units,
"lstm_projection" : cell_proj,
"lstm_cell_count" : cell_count,
"fc_layers_size" : fc_layers_sizes,
"dropout" : dropout,
"learning_rate" : 1e-4,
"optimizer" : "Adam"
}
database_path = r"C:\tmp\imdb"
def tone_input_fn_train():
return Tone_utils.input_fn(
os.path.join(database_path, "train.tfrecords"), 32)
def tone_input_fn_valid():
return Tone_utils.input_fn(
os.path.join(database_path, "valid.tfrecords"), 32)
def tone_input_fn_test():
return Tone_utils.input_fn(
os.path.join(database_path, "test.tfrecords"), 32)
run_config = learn.RunConfig(gpu_memory_fraction=0.8,
save_checkpoints_secs=60)
version_path = r"C:\tmp\tone_classifier\version=%d dropout=%.2f fc_layers=%r cells lstm=%d units=%d proj=%d count=%d" % (
i, dropout, fc_layers_sizes, use_gru, cell_units, cell_proj,
cell_count)
tone_classifier = learn.Estimator(model_fn=embed_lestm_model_fn,
model_dir=version_path,
params=parameters,
config=run_config)
tf.logging.set_verbosity(tf.logging.INFO)
#### TRAIN ####
tone_classifier.fit(input_fn=tone_input_fn_train, steps=10000)
#### VALIDATION ####
eval_results = tone_classifier.evaluate(input_fn=tone_input_fn_valid,
steps=100)
print("Validation set accuracy :", eval_results["accuracy"])
#### TEST ####
eval_results = tone_classifier.evaluate(input_fn=tone_input_fn_test,
steps=100)
print("Test set accuracy :", eval_results["accuracy"])
def make_estimator(hparams, label_values, output_dir):
"""Creates an Estimator.
Args:
hparams: HParams specfying the configuration of the estimator.
label_values: List of strings that specify the possible values of the label.
output_dir: Directory to store the model checkpoints and metrics.
Returns:
An Estimator.
"""
seq_features = []
seq_features_sizes = []
for k, bucket_size in zip(
hparams.sequence_features + hparams.time_crossed_features,
hparams.sequence_bucket_sizes + hparams.time_concat_bucket_sizes):
if 'n/a' in k:
continue
for max_age in hparams.time_windows[1:]:
seq_features.append(
tf.feature_column.categorical_column_with_hash_bucket(
SEQUENCE_KEY_PREFIX + k.replace(':', '_') + '-til-' +
str(max_age), bucket_size))
seq_features_sizes.append(bucket_size)
categorical_context_features = [
tf.feature_column.categorical_column_with_hash_bucket(
CONTEXT_KEY_PREFIX + k, bucket_size) for k, bucket_size in
zip(hparams.categorical_context_features, hparams.context_bucket_sizes)
]
discretized_context_features = []
if hparams.include_age:
discretized_context_features.append(
tf.feature_column.bucketized_column(
tf.feature_column.numeric_column(CONTEXT_KEY_PREFIX + AGE_KEY),
boundaries=hparams.age_boundaries))
if hparams.optimizer == 'Ftrl':
optimizer = tf.train.FtrlOptimizer(
learning_rate=hparams.learning_rate,
l1_regularization_strength=hparams.l1_regularization_strength,
l2_regularization_strength=hparams.l2_regularization_strength)
elif hparams.optimizer == 'Adam':
optimizer = tf.train.AdamOptimizer(learning_rate=hparams.learning_rate,
beta1=0.9,
beta2=0.999,
epsilon=1e-8)
else:
raise ValueError('Invalid Optimizer %s needs to be Ftrl or Adam' %
hparams.optimizer)
run_config = contrib_learn.RunConfig(save_checkpoints_secs=180)
if hparams.model_type == 'linear':
estimator = tf.estimator.LinearClassifier(
feature_columns=seq_features + categorical_context_features +
discretized_context_features,
n_classes=len(label_values),
label_vocabulary=label_values,
optimizer=optimizer,
model_dir=output_dir,
config=run_config,
loss_reduction=tf.losses.Reduction.SUM_OVER_BATCH_SIZE)
elif hparams.model_type == 'dnn':
# Heuristically choose an embedding dimension dependent on the number of
# of tokens of a feature.
embed_seq_features = [
tf.feature_column.embedding_column(fc,
dimension=int(
min(6 * pow(size, 0.25),
size)))
for fc, size in zip(seq_features, seq_features_sizes)
]
embed_context_features = [
tf.feature_column.embedding_column(fc,
dimension=int(
min(6 * pow(size, 0.25),
size))) for fc, size in
zip(categorical_context_features, hparams.context_bucket_sizes)
]
embed_age = []
if hparams.include_age:
embed_age.append(
tf.feature_column.embedding_column(
discretized_context_features[0], 4))
estimator = tf.estimator.DNNClassifier(
feature_columns=embed_seq_features + embed_context_features +
embed_age,
n_classes=len(label_values),
label_vocabulary=label_values,
optimizer=optimizer,
hidden_units=hparams.dnn_hidden_units,
dropout=hparams.dnn_dropout,
model_dir=output_dir,
config=run_config,
loss_reduction=tf.losses.Reduction.SUM_OVER_BATCH_SIZE)
else:
raise ValueError('Invalid model_type %s needs to be linear or dnn' %
hparams.model_type)
return contrib_estimator.add_metrics(estimator, make_metrics(label_values))
EPOCHS = 500
BATCH_SIZE = 100
hidden_layers = [16, 16, 16, 16, 16]
dropout = 0.0
MODEL_PATH = './DNNRegressors/'
for hl in hidden_layers:
MODEL_PATH += '%s_' % hl
MODEL_PATH += 'D0%s' % (int(dropout * 10))
logging.info('Saving to %s' % MODEL_PATH)
# Validation and Test Configuration
validation_metrics = {"MSE": tf.contrib.metrics.streaming_mean_squared_error}
test_config = skflow.RunConfig(save_checkpoints_steps=100,
save_checkpoints_secs=None)
# Building the Network
regressor = skflow.DNNRegressor(feature_columns=feature_columns,
label_dimension=1,
hidden_units=hidden_layers,
dropout=dropout,
config=test_config)
# Train it
logging.info('Train the DNN Regressor...\n')
MSEs = [] # for plotting
STEPS = [] # for plotting
for epoch in range(EPOCHS + 1):
X_train, y_train = X_train.astype(np.float32).copy(), y_train.astype(
np.float32).copy()
X_test, y_test = X_test.astype(np.float32).copy(), y_test.astype(
np.float32).copy()
X, y = X.astype(np.float32).copy(), y.astype(np.float32).copy()
model = skflow.TensorFlowEstimator(
model_fn=lstm_model,
n_classes=0, # n_classes = 0 for regression
verbose=0,
batch_size=batch_size,
steps=steps,
optimizer=tf.train.ProximalAdagradOptimizer(
learning_rate=learning_rate, l1_regularization_strength=0.001),
config=skflow.RunConfig(save_checkpoints_secs=1))
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
# TensorBoard Summary Writer
summary_writer = tf.train.SummaryWriter(log_dir, sess.graph)
model.fit(X_train, y_train, logdir=log_dir)
print("done in %0.3fs." % (time.time() - t1))
#______________________________________________________________________#
# RESULTS #
#______________________________________________________________________#
def main(unused_argv):
parameters = \
{
"max_timesteps" : 181,
"mfcc_features_count" : 20,
"labels_class_count" : 5,
"conv1_features_count" : 64, # 256
"conv1_kernel_size1" : 9, # 9
"conv1_kernel_size2" : 9, # 9
"max_pooling_size" : 3, # 3
"conv2_features_count" : 64, # 256
"conv2_kernel_size1" : 4, # 4
"conv2_kernel_size2" : 3, # 3
"dimension_reduction_size" : 64, # 256
"lstm_units" : 128, # 832
"lstm_projection" : 128, # 512
"lstm_cell_count" : 4, # 2
"fully_connected_sizes" : [128, 64], # 1024
"learning_rate" : 1e-3,
"optimizer" : "Adam" #tf.train.MomentumOptimizer(learning_rate = 1e-3, momentum = 0.5)
}
run_config = learn.RunConfig(gpu_memory_fraction=0.8,
save_checkpoints_secs=60)
cldnn_classifier = learn.Estimator(model_fn=cldnn_model_fn,
model_dir=r"C:\tmp\berlin_lstm\25_MFCC",
params=parameters,
config=run_config)
#tensors_to_log = {"probabilities": "softmax_tensor"}
#logging_hook = tf.train.LoggingTensorHook(
# tensors = tensors_to_log,
# every_n_iter = 50)
validation_monitor = learn.monitors.ValidationMonitor(
input_fn=lambda: berlin_input_fn(BERLIN_VALID_DATASET, 100),
eval_steps=1,
every_n_steps=50)
tf.logging.set_verbosity(tf.logging.INFO)
cldnn_classifier.fit(input_fn=berlin_input_fn_train_dataset,
steps=15000,
monitors=[validation_monitor])
eval_results = cldnn_classifier.evaluate(
input_fn=lambda: berlin_input_fn(BERLIN_VALID_DATASET, 100), steps=1)
print("############################")
print("############################")
print("######### #############")
print("######### %s #############" % (eval_results["accuracy"]))
print("######### #############")
print("############################")
print("############################")
dropout1 = tf.layers.dropout(dense3, rate=0.5)
dense4 = tf.layers.dense(dropout1, 32, activation=tf.nn.relu, name='fc4')
logits = tf.layers.dense(dense4, 2, activation=None, name='out')
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(
loss, tf.contrib.framework.get_global_step())
return tf.argmax(logits, 1), loss, train_op
classifier = learn.Estimator(model_fn=ANN,
model_dir="./output",
config=learn.RunConfig(save_checkpoints_secs=10))
validation_monitor = learn.monitors.ValidationMonitor(
x=X_val,
y=y_val,
metrics={'accuracy': MetricSpec(tfmetrics.streaming_accuracy)},
every_n_steps=500)
classifier.fit(x=X_train,
y=y_train,
batch_size=16,
steps=10000,
monitors=[validation_monitor])
#score = classifier.evaluate(x=X_test, y=y_test,metrics={'accuracy': MetricSpec(tfmetrics.streaming_accuracy)})
#print('Accuracy: {0:f}'.format(score['accuracy']))
