首页 文章

使用TFLearn计算培训和验证准确性

提问于
浏览 次
-2

This是TFLearn文档中的一个示例 . 它展示了如何结合TFLearn和Tensorflow，使用TFLearn训练器和常规Tensorflow图 . 但是，省略了训练，测试和验证精度计算 .

from __future__ import print_function

import tensorflow as tf
import tflearn

# --------------------------------------
# High-Level API: Using TFLearn wrappers
# --------------------------------------

# Using MNIST Dataset
import tflearn.datasets.mnist as mnist
mnist_data = mnist.read_data_sets(one_hot=True)

# 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.max_pool_2d(net, 2)
    net = tflearn.local_response_normalization(net)
    net = tflearn.dropout(net, 0.8)
    net = tflearn.conv_2d(net, 64, 3, activation='relu')
    net = tflearn.max_pool_2d(net, 2)
    net = tflearn.local_response_normalization(net)
    net = tflearn.dropout(net, 0.8)
    net = tflearn.fully_connected(net, 128, activation='tanh')
    net = tflearn.dropout(net, 0.8)
    net = tflearn.fully_connected(net, 256, activation='tanh')
    net = tflearn.dropout(net, 0.8)
    net = tflearn.fully_connected(net, 10, activation='linear')

    # Defining other ops using Tensorflow
    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
    init = tf.global_variables_initializer()

    # Launch the graph
    with tf.Session() as sess:
        sess.run(init)

        batch_size = 128
        for epoch in range(2):  # 2 epochs
            avg_cost = 0.
            total_batch = int(mnist_data.train.num_examples / batch_size)
            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})
                cost = sess.run(loss, feed_dict={X: batch_xs, Y: batch_ys})
                avg_cost += cost / total_batch
                if i % 20 == 0:
                    print("Epoch:", '%03d' % (epoch + 1), "Step:", '%03d' % i,
                          "Loss:", str(cost))`

最后一行是计算成本的地方 . 如果我想同时计算训练和验证准确度，那么代码应该是什么？

EDIT: 我拼凑了一段代码，我相信在循环过程中计算出训练和验证的准确性 .

我的解决方案是否符合我的想法： calculate the running accuracies as the model trains.

在TFLearn中有更好的方法吗？我注意到张量板非常广泛 . 可以从事件日志中检索这些数据吗？

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

tf_train_dataset = tf.placeholder(
    tf.float32, shape=(batch_size, image_size, image_size, num_channels))

data = reshape(tf_train_dataset,[-1, image_size, image_size, num_channels])

network = input_data(shape=[None, image_size, image_size, num_channels],
                        #placeholder=data,
                        data_preprocessing=feature_normalization,
                        data_augmentation=None,
                        name='input_d')

network = conv_2d(network,
            nb_filter=num_channels,
            filter_size=patch_size,
            strides=[1, 2, 2, 1],
            padding='SAME',
            activation='relu',
            bias=True,
            weights_init=weight_init_trn,
            bias_init=weight_init_zro,
            restore=True,
            regularizer=None)

network = conv_2d(network,
            nb_filter=depth,
            filter_size=patch_size,
            strides=[1, 2, 2, 1],
            padding='SAME',
            activation='relu',
            bias=True,
            weights_init=weight_init_trn,
            bias_init=tf.constant(1.0, shape=[depth]),
            restore=True,
            regularizer=None)

network = fully_connected(network,
                            n_units=num_hidden,
                            activation='relu',
                            bias=True,
                            weights_init=weight_init_trn,
                            bias_init=tf.constant(1.0, shape=[num_hidden]),
                            regularizer=None,
                            restore=True
                            )

network = fully_connected(network,
                            n_units=num_labels,
                            activation=None,
                            bias=True,
                            weights_init=weight_init_trn,
                            bias_init=tf.constant(1.0, shape=[num_labels]),
                            regularizer=None,
                            restore=True,
                            name='fullc'
                            )
network = activation(network,'softmax')

network = regression(network, optimizer='SGD',
                    loss='categorical_crossentropy',
                    learning_rate=0.05, name='targets')

model_dnn_tr = tflearn.DNN(network, tensorboard_verbose=0)

num_steps = 1001
with tf.Session(graph=graph) as session:

    tf.global_variables_initializer().run()
    print('Initialized')

    for step in range(num_steps):
        offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
        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)

            print("Minibatch accuracy: %.1f%%" % trainAccr)
            print("Validation accuracy: %.1f%%" % validAccr)

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

print("testAccr time:", round(time()-t0,3),"s")

print("Test accuracy: %.1f%%" % testAccr)
tensorflow tflearn

1 回答

  • 0

    到目前为止我找到的最令人满意的解决方案：

    • 使用数据集对象和迭代器来提供数据 .
    def accuracy(predictions, labels):
    return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))
                / predictions.shape[0])

image_size = 28
num_labels = 10
num_channels = 1 # grayscale

batch_size = 16
patch_size = 5
depth = 16
num_hidden = 64

graph = tf.Graph()

with graph.as_default():

    data_prep = DataPreprocessing()
    data_prep.add_featurewise_stdnorm()
    data_prep.add_featurewise_zero_center()
    img_prep = ImagePreprocessing()
    img_prep.add_featurewise_zero_center()
    img_prep.add_featurewise_stdnorm()

    feature_normalization = None
    weight_init_trn = initializations.truncated_normal(seed=None, dtype=tf.float32, stddev=0.1)
    weight_init_zro = initializations.zeros(seed=None, dtype=tf.float32)
    weight_init_cns = tf.constant(1.0)

    # Input data.
    # create a placeholder to dynamically switch between 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 of the correct shape and type
    iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
    # get the tensor that will contain your 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')

    network = conv_2d(network,
            nb_filter=num_channels,
            filter_size=patch_size,
            strides=[1, 2, 2, 1],
            padding='SAME',
            activation='relu',
            bias=True,
            weights_init=weight_init_trn,
            bias_init=weight_init_zro,
            restore=True,
            regularizer=None)

    network = conv_2d(network,
        nb_filter=depth,
        filter_size=patch_size,
        strides=[1, 2, 2, 1],
        padding='SAME',
        activation='relu',
        bias=True,
        weights_init=weight_init_trn,
        bias_init=tf.constant(1.0, shape=[depth]),
        restore=True,
        regularizer=None)


    network = fully_connected(network,
                            n_units=num_hidden,
                            activation='relu',
                            bias=True,
                            weights_init=weight_init_trn,
                            bias_init=tf.constant(1.0, shape=[num_hidden]),
                            regularizer=None,
                            restore=True
                            )
    logits = fully_connected(network,
                            n_units=num_labels,
                            activation=None,
                            bias=True,
                            weights_init=weight_init_trn,
                            bias_init=tf.constant(1.0, shape=[num_labels]),
                            regularizer=None,
                            restore=True,
                            name='fullc2'
                            )

    # 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)

num_steps = 1001
with tf.Session(graph=graph) as session:
    tf.global_variables_initializer().run()
    print('Initialized')
    # initialise iterator with train data
    print('Training...')
    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 )

       t0 = time()
        feed_dict2 = {data_placeholder: batch_data, labels_placeholder: batch_labels}
        _, l, predictions = session.run([optimizer, loss, prediction],
                                   feed_dict=feed_dict2)
        print("fit time:", round(time()-t0,3),"s")
        if (step % 50 == 0):

            t0 = time()
            trainAccrMb = accuracy(predictions, batch_labels)
            print("trainAccr time:", round(time()-t0,3),"s")

            t0 = time()
            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)
            print("validAccr time:", round(time()-t0,3),"s")


            print("Minibatch loss at step %d: %f" % (step, l))
            print("Minibatch accuracy: %.1f%%" % trainAccrMb)
            print("Validation accuracy: %.1f%%" %  validAccr)
    t0 = time()

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)
print("testAccr time:", round(time()-t0,3),"s")
print("Test accuracy: %.1f%%" % testAccr)
    回复于

相关问题