Обучение TensorFlow - сопоставление результатов с простым однослойным оценщиком - PullRequest
Новая
       6

Обучение TensorFlow - сопоставление результатов с простым однослойным оценщиком

0 голосов
/ 27 сентября 2018

Я новичок в TensorFlow, но опыт работы в аналитике.Я пытаюсь воспроизвести в TensorFlow производительность, которую я получаю, используя унаследованный инструктор Neural Network, состоящий просто из одного скрытого слоя, обученного с использованием back-prop с обновлением импульса и целевой функции среднеквадратичной ошибки.

К сожалению, все мои попытки пока не увенчались успехом, с производимыми моделями TensorFlow, которые варьируются от примерно «только» на 10-15% ниже, чем мой домашний тренер при использовании консервированного tf.estimator.DNNClassifier, до намного, намного хуже, когда япопробуй сам построить сеть.

Может ли кто-нибудь определить ошибки, которые я допускаю при вызове инструмента в приведенном ниже коде?Используя ввод командной строки, я переключаюсь между «canned_dnn» и моей «пользовательской» настройкой 

def get_classifier( model_name, cur_model_dir, feature_columns ):
    if model_name == 'canned_dnn':
        return tf.estimator.DNNClassifier( feature_columns=feature_columns,
                                           model_dir=cur_model_dir,
                                           hidden_units=[18],
                                           activation_fn=tf.nn.relu )
    elif model_name == 'custom':
        return tf.estimator.Estimator( model_fn=my_model,
                                       model_dir=cur_model_dir,
                                       params={
                                           'feature_columns': feature_columns,
                                           'n_classes': 2
                                       })
    else:
        raise RuntimeError()

def my_model(features, labels, mode, params):

    # input layer                                                                                                                                                                                                                                                           
    net = tf.feature_column.input_layer( features, params['feature_columns'] )

    # hidden layer 1                                                                                                                                                                                                                                                        
    net = tf.layers.dense(net, units=18, activation=tf.nn.relu, use_bias=True, bias_initializer=tf.zeros_initializer(), name='LEARN_1')

    # output layer computes logits                                                                                                                                                                                                                                          
    logits = tf.layers.dense(net, params['n_classes'], activation=tf.nn.sigmoid, name='OUTPUT')

    # compute predictions                                                                                                                                                                                                                                                   
    predicted_classes = tf.argmax(logits, 1)
    if mode == tf.estimator.ModeKeys.PREDICT:
        predictions = {
            'class_ids': predicted_classes[:, tf.newaxis],
            'probabilities': tf.nn.softmax(logits),
            'logits': logits,
        }
        return tf.estimator.EstimatorSpec(mode, predictions=predictions)

    # mean squared error                                                                                                                                                                                                                                                    
    predicted_classes = tf.argmax(logits, 1)
    loss = tf.losses.mean_squared_error(labels=tf.one_hot(labels, 2), predictions=logits)

    # metrics                                                                                                                                                                                                                                                               
    # loss report                                                                                                                                                                                                                                                           
    tf.summary.scalar('loss', loss )

    # accuracy                                                                                                                                                                                                                                                              
    accuracy = tf.metrics.accuracy(labels=labels,
                                   predictions=predicted_classes,
                                   name='acc_op')

    metrics = {'accuracy': accuracy}
    tf.summary.scalar('accuracy', accuracy[1])

    # EVALUATION MODE                                                                                                                                                                                                                                                       
    if mode == tf.estimator.ModeKeys.EVAL:
        return tf.estimator.EstimatorSpec(
            mode, loss=loss, eval_metric_ops=metrics)

    # TRAINING MODE                                                                                                                                                                                                                                                         
    assert mode == tf.estimator.ModeKeys.TRAIN
    with tf.name_scope( 'OPTIMIZE' ):
        optimizer=tf.train.MomentumOptimizer(learning_rate=.02,momentum=.5)
        train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())
        return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
...