Чем отличается производительность нейронной сети в TensorFlow и Keras?

Question

Я новичок в машинном обучении (ML) и пытаюсь реализовать алгоритм для понимания базового синтаксиса каркасов ML и т. Д. Сейчас я работаю над базой данных MNIST из набора рукописных цифр.

Я реализовал только один слой (я имею в виду: входной слой имеет 784 входа, скрытый слой имеет 512 узлов, выходной слой имеет 10 выходов) Нейронная сеть, использующая структуру TensorFlow, без предварительной обработки данных, 128 пакетов, 10 эпох, оптимизатор ADAM. И алгоритм достиг приблизительно 0,95 точности на наборе поездов.

После этого я попытался реализовать точно такую ​​же архитектуру в Keras. Тем не менее, точность (состав поезда) составляет около 0,3. Я пытался найти много различных реализаций, основанных на Интернете, но я до сих пор не могу найти, в чем проблема. Я считаю, что это что-то глупое (как всегда): - /

Я предполагаю, что та же архитектура в Keras должна давать те же результаты, что и реализация в TensorFlow, я прав?

Моя реализация Keras:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from keras.layers import Input, Dense
from keras.models import Model
from keras.utils.np_utils import to_categorical

df_train = pd.read_csv('datasets/MNIST_train.csv', delimiter=',', header=0)
Y_train, X_train = np.split(df_train.values, [1], axis=1)

m, n_x = X_train.shape
n_y = len(np.unique(Y_train))
n_layer1 = 512
batch_size = 128
num_epochs = 10

Y_train = to_categorical(Y_train)

X_input = Input(shape=(n_x,), name='input')
X = Dense(n_layer1, activation='relu', name='hidden')(X_input)
X = Dense(n_y, activation='softmax', name='output')(X)

model = Model(inputs=X_input, outputs=X, name='Neural Network')

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

model.fit(X_train, Y_train, epochs=num_epochs, batch_size=batch_size)

Моя реализация TensorFlow:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf

def one_hot(a, num_classes):
  return np.eye(num_classes)[a.reshape(-1)]

def get_minibatches(batch_size, m, X, Y):
    output_batches = []

    for index in range(0, m, batch_size):
        index_end = index + batch_size
        batch = [X[index:index_end], Y[index:index_end]]
        output_batches.append(batch)

    return output_batches

def dense_layer(input, channels_in, channels_out, activation=None):
   initializer = tf.contrib.layers.xavier_initializer()
   w = tf.Variable(initializer([channels_in, channels_out]), name="w")
   b = tf.Variable(tf.zeros([1, channels_out]), name="b")

   if (activation == 'relu'):
       a = tf.nn.relu(tf.matmul(input, w) + b)
       return a
   else:
       z = tf.matmul(input, w) + b
       return z

df_train = pd.read_csv('datasets/MNIST_train.csv', delimiter=',', header=0)
Y_train, X_train = np.split(df_train.values, [1], axis=1)

m, n_x = X_train.shape
n_y = len(np.unique(Y_train))
n_layer1 = 512
batch_size = 128
num_epochs = 10

Y_train = one_hot(Y_train, n_y)

X = tf.placeholder(tf.float32, [None, n_x], name="X")
Y = tf.placeholder(tf.float32, [None, n_y], name="Y")

hidden = dense_layer(X, n_x, n_layer1, 'relu')
output = dense_layer(hidden, n_layer1, n_y)

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=output, labels=Y))

optimizer = tf.train.AdamOptimizer().minimize(loss)

predict = tf.argmax(output, 1)
correct_prediction = tf.equal(predict, tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

minibatches = get_minibatches(batch_size, m, X_train, Y_train)

with tf.Session() as sess:        
    sess.run(tf.global_variables_initializer())

    current_cost = sess.run(loss, feed_dict={X: X_train, Y: Y_train})
    train_accuracy = sess.run(accuracy, feed_dict={X: X_train, Y: Y_train})
    print('Epoch: {:<4} - Loss: {:<8.3} Train Accuracy: {:<5.3} '.format(0, current_cost, train_accuracy))

    for epoch in range(num_epochs):            
        for minibatch in minibatches:
            minibatch_X, minibatch_Y = minibatch

            sess.run(optimizer, feed_dict={ X: minibatch_X, Y: minibatch_Y })

        current_cost = sess.run(loss, feed_dict={X: X_train, Y: Y_train})
        train_accuracy = sess.run(accuracy, feed_dict={X: X_train, Y: Y_train})
        print('Epoch: {:<4} - Loss: {:<8.3} Train Accuracy: {:<5.3} '.format(epoch + 1, current_cost, train_accuracy))

Не могли бы вы помочь мне и посоветовать, что я делаю не так? Спасибо Petr

Answer 1

Я понял это. По крайней мере, частично. Я стандартизировал ввод ((x - xmean) / xstd), и реализация Keras была запущена, чтобы возвращать результаты, аналогичные реализации TensorFlow…