Как я могу, с TFLearn, взаимодействовать с метриками обучения (текущая точность проверки, точность обучения и т. Д.? - PullRequest
Новая
       20

Как я могу, с TFLearn, взаимодействовать с метриками обучения (текущая точность проверки, точность обучения и т. Д.?

0 голосов
/ 04 июля 2018

Это это пример из документации TFLearn. В нем показано, как объединить TFLearn и Tensorflow, используя тренажер TFLearn с обычным графиком Tensorflow. Однако текущие расчеты точности обучения, испытаний и проверки недоступны. 

import tensorflow as tf
import tflearn
    ...   
# User defined placeholders
with tf.Graph().as_default():
    # Placeholders for data and labels
    X = tf.placeholder(shape=(None, 784), dtype=tf.float32)
    Y = tf.placeholder(shape=(None, 10), dtype=tf.float32)

    net = tf.reshape(X, [-1, 28, 28, 1])

    # Using TFLearn wrappers for network building
    net = tflearn.conv_2d(net, 32, 3, activation='relu')
    .
    .
    .
    net = tflearn.fully_connected(net, 10, activation='linear')

    loss = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits_v2(
            logits=net, 
            labels=Y))
    optimizer = tf.train.AdamOptimizer(learning_rate=0.01).minimize(loss)

    # Initializing the variables
    ...
    # Launch the graph
    with tf.Session() as sess:
        sess.run(init)
    ...
        for epoch in range(2):  # 2 epochs
    ...
            for i in range(total_batch):
                batch_xs, batch_ys = mnist_data.train.next_batch(batch_size)
                sess.run(optimizer, feed_dict={X: batch_xs, Y: batch_ys})

Как мне получить доступ к расчетной точности обучения и проверки на каждом шаге во вложенном цикле FOR?

ОБНОВЛЕНИЕ ДЛЯ ЯСНОСТИ:

Решение может быть следующим: Используя метод fit_batch класса Trainer , я считаю, что я рассчитываю точность обучения и проверки во время вложенного цикла.

Этот код вычисляет погрешность хода при обучении модели ? Есть ли лучший способ сделать это с TFLearn?

Я понимаю, что тензорная доска использует эти значения. Могу ли я получить значения из журналов событий? 

def accuracy(predictions, labels):
return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))
                / predictions.shape[0])
...    
network = input_data(shape=[None, image_size, image_size, num_channels],
                     data_preprocessing=feature_normalization,
                     data_augmentation=None,
                     name='input_d')
.
.
.
network = regression(network, optimizer='SGD',
                    loss='categorical_crossentropy',
                    learning_rate=0.05, name='targets')

model_dnn_tr = tflearn.DNN(network, tensorboard_verbose=0)
...
with tf.Session(graph=graph) as session:
...
    for step in range(num_steps):
    ...
        batch_data = train_dataset[offset:(offset + batch_size), :, :, :]
        batch_labels = train_labels[offset:(offset + batch_size), :]

        loss = model_dnn_tr.fit_batch({'input_d' : batch_data}, {'targets': 
            batch_labels})

        if (step % 50 == 0):
            trainAccr = accuracy(model_dnn_tr.predict({'input_d' : 
                batch_data}), batch_labels)

            validAccr = accuracy(model_dnn_tr.predict({'input_d' : 
                valid_dataset}), valid_labels)

testAccr = accuracy(model_dnn_tr.predict({'input_d' : test_dataset}), 
    test_labels)

1 Ответ

0 голосов
/ 12 июля 2018

ОБНОВЛЕНИЕ с правильным ответом

Могу ли я получить значения из журналов событий?

Tensorboard действительно имеет возможность загружать наборы данных о точности, но использование его во время обучения проблематично.

Этот код рассчитывает погрешность хода при обучении модели?

Одним словом. Да.

Метод fit_batch работает так, как можно было ожидать; как и первоначальное решение , которое я разместил ниже.

Однако ни не является предписанным методом.

Есть ли лучший способ сделать это в TFLearn?

Да!

Чтобы отслеживать и взаимодействовать с метриками обучения, должна быть реализована функция Обратный звонок обучения . 

from tflearn import callbacks as cb

class BiasVarianceStrategyCallback(cb.Callback):
    def __init__(self, train_acc_thresh,run_id,rel_err=.1):
        """ Note: We are free to define our init function however we please. """
        def errThrshld(Tran_accuracy=train_acc_thresh,relative_err=rel_err):
            Tran_err = round(1-Tran_accuracy,2)
            Test_err = ...
            Vald_err = ...
            Diff_err = ...
            return {'Tr':Tran_err,'Vl':Vald_err,'Ts':Test_err,'Df':Diff_err}
        return

    def update_acc_df(self,training_state,state):
        ...
        return
    def on_epoch_begin(self, training_state):
        """ """
        ...
        variance_found = ...
        if trn_acc_stall or vld_acc_stall:
            print("accuracy increase stalled. training epoch:"...
            if trn_lss_mvNup or vld_lss_mvNup:
                print("loss began increase training:"...
                raise StopIteration
                return
            if variance_found or bias_found:
                print("bias:",bias_found,"variance:",variance_found)
                raise StopIteration
                return
        return
    def on_batch_end(self, training_state, snapshot=False):
        self.update_acc_df(training_state,"batch")
        return
    def on_epoch_end(self, training_state):
        self.update_acc_df(training_state,"epoch")
        return
    def on_train_end(self, training_state):
        self.update_acc_df(training_state,"train")
        self.df = self.df.iloc[0:0]
        return

Исходное решение

Самое удовлетворительное решение, которое я нашел до сих пор:

  • Использует объект набора данных и итераторы для подачи данных.

  • Не сильно отличается от метода fit_batch в OP. 

    def accuracy(predictions, labels):
    return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))
                / predictions.shape[0])   
...

graph = tf.Graph()

with graph.as_default():
...

    # create a placeholder to dynamically switch between
    # validation and training batch sizes
    batch_size_x = tf.placeholder(tf.int64)

    data_placeholder =  tf.placeholder(tf.float32, 
        shape=(None, image_size, image_size, num_channels))

    labels_placeholder = tf.placeholder(tf.float32, shape=(None, num_labels))

    # create dataset: one for training and one for test etc
    dataset = tf.data.Dataset.from_tensor_slices((data_placeholder,labels_placeholder)).batch(batch_size_x).repeat()


    # create a iterator
    iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
    # get the tensor that will contain data
    feature, label = iterator.get_next()

    # create the initialisation operations
    init_op = iterator.make_initializer(dataset)   

    valid_data_x = tf.constant(valid_data)
    test_data_x = tf.constant(test_data)

    # Model.

    network = input_data(shape=[None, image_size, image_size, num_channels],
                        placeholder=data_placeholder,
                        data_preprocessing=feature_normalization,
                        data_augmentation=None,
                        name='input_d')
    .
    .
    .
    logits = fully_connected(network,...

    # Training computation.
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=labels_placeholder,logits=logits))
    # Optimizer.
    optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

    prediction = tf.nn.softmax(logits) 
...
with tf.Session(graph=graph) as session:
    tf.global_variables_initializer().run()
    # initialise iterator with train data
    feed_dict =  {data_placeholder: train_data,
              labels_placeholder: train_data_labels,
              batch_size_x: batch_size}
   session.run(init_op, feed_dict = feed_dict)

   for step in range(num_steps):

       batch_data,batch_labels = session.run( [feature, label], feed_dict = 
        feed_dict )

        feed_dict2 = {data_placeholder: batch_data, labels_placeholder: batch_labels}
        _, l, predictions = session.run([optimizer, loss, prediction],
                                   feed_dict=feed_dict2)
        if (step % 50 == 0):

            trainAccrMb = accuracy(predictions, batch_labels)

            feed_dict = {data_placeholder: valid_data_x.eval(), labels_placeholder: valid_data_labels }
            valid_prediction = session.run(prediction,
                                        feed_dict=feed_dict)
            validAccr= accuracy(valid_prediction, valid_data_labels)

feed_dict = {data_placeholder: test_data_x.eval(), labels_placeholder: 
    test_data_labels }#, batch_size_x: len(valid_data)}

test_prediction = session.run(prediction,
                                feed_dict=feed_dict)

testAccr = accuracy(test_prediction, test_data_labels)
...