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