Tenseflow и Keras имеют разные результаты для одного и того же источника CNN

Question

Я использовал метод CNN с тензорным потоком и получил соответствующий результат (например, 95% соотв.). Затем я использовал ту же структуру модели с кератами.Я получил другой результат.Он показывает ужасную точность и не улучшается в эпоху.

Я изменил lr, pooling_size, filters и т. Д., Но не стал лучше.Я использовал модель Keras для Mnist.эта модель хорошо работает в наборе данных mnist.

Это модель CNN с тензорным потоком:

import what i needed #(pseudo)

data_list = glob.glob('images dir') #(pseudo)
tf.set_random_seed(777)
random.shuffule(data_list)

# hyper parameters
learning_rate = 0.001
training_epochs = 10
batch_size = 64
batch_size_test = 1000

# dropout
keep_prob = tf.placeholder(tf.float32)

train_x, train_y, test_x, test_y = data_list #(pseudo)
#image data shape is [none, 256, 256, 3]
#result shape is [4, ]
#train set: 500, test set: 230 ... (i know the tiny resource, but getting more data is not available.)

#model
class Model:
    def __init__(self, sess, name):
        self.sess = sess
        self.name = name
        self._build_net()

    def _build_net(self):
        with tf.variable_scope(self.name):
            # dropout (keep_prob) rate  0.7~0.5 on training, but should be 1
            # for testing
            self.training = tf.placeholder(tf.bool)

            # input place holders
            self.X = tf.placeholder(tf.float32, [None, 256, 256, 3])

            # img 256x256x3 , Input Layer
            X_img = tf.reshape(self.X, [-1, 256, 256, 3])
            self.Y = tf.placeholder(tf.float32, [None, 4])

            # Convolutional Layer #1
            conv1 = tf.layers.conv2d(inputs=X_img, filters=32, kernel_size=[3, 3],
                                     padding="SAME", activation=tf.nn.relu)
            # Pooling Layer #1
            pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2],
                                            padding="SAME", strides=2)
            dropout1 = tf.layers.dropout(inputs=pool1,
                                         rate=0.3, training=self.training)
            #None*256*256*3 -> 256*256*32 -> 128*128*32

            # Convolutional Layer #2 and Pooling Layer #2
            conv2 = tf.layers.conv2d(inputs=dropout1, filters=64, kernel_size=[3, 3],
                                     padding="SAME", activation=tf.nn.relu)
            pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2],
                                            padding="SAME", strides=2)
            dropout2 = tf.layers.dropout(inputs=pool2,
                                         rate=0.3, training=self.training)
            #128*128*32 -> 128*128*64 -> 64*64*64

            # Convolutional Layer #2 and Pooling Layer #2
            conv3 = tf.layers.conv2d(inputs=dropout2, filters=128, kernel_size=[3, 3],
                                     padding="same", activation=tf.nn.relu)
            pool3 = tf.layers.max_pooling2d(inputs=conv3, pool_size=[2, 2],
                                            padding="same", strides=2)
            dropout3 = tf.layers.dropout(inputs=pool3,
                                         rate=0.3, training=self.training)
            #64*64*64 -> 64*64*128 -> 32*32*128

            # Dense Layer with Relu
            flat = tf.reshape(dropout3, [-1, 128 * 32 * 32])
            dense4 = tf.layers.dense(inputs=flat,
                                     units=625, activation=tf.nn.relu)
            dropout4 = tf.layers.dropout(inputs=dense4,
                                         rate=0.5, training=self.training)

            # Logits (no activation) Layer: L5 Final FC 625 inputs -> 4 outputs
            self.logits = tf.layers.dense(inputs=dropout4, units=4)

        # define cost/loss & optimizer
        self.cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(
            logits=self.logits, labels=self.Y))
        self.optimizer = tf.train.AdamOptimizer(
            learning_rate=learning_rate).minimize(self.cost)

        correct_prediction = tf.equal(
            tf.argmax(self.logits, 1), tf.argmax(self.Y, 1))
        self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    def predict(self, x_test, training=False):
        return self.sess.run(self.logits,
                             feed_dict={self.X: x_test, self.training: training})

    def get_accuracy(self, x_test, y_test, training=False):
        return self.sess.run(self.accuracy,
                             feed_dict={self.X: x_test,
                                        self.Y: y_test, self.training: training})

    def train(self, x_data, y_data, training=True):
        return self.sess.run([self.cost, self.optimizer], feed_dict={
            self.X: x_data, self.Y: y_data, self.training: training})

#-----------------session-----------------------------------------
sess = tf.Session()
m1 = Model(sess, "m1")

sess.run(tf.global_variables_initializer())
#-----------------------------------------------------------------
print('Learning Started!')

# train my model
for epoch in range(training_epochs):
    cost_result = 0
    total_batch = int(len(data_list)/batch_size)

    pbar = tqdm(range(0, len(data_list), batch_size))
    for i in pbar:
        train_x, train_y = get_next_data_set(i)
        c, _ = m1.train(train_x, train_y)
        cost_result += c /total_batch
        pbar.set_description("cost : %f" % cost_result)
    print('Accuracy:', m1.get_accuracy(train_x, train_y))

print('Learning Finished!')

, и результат: обучение началось!стоимость: 4465.586227: 100% | ████████████████████████ |8/8 [02:55 <00:00, 20.01s / it] </p>

Точность: 0,1923077

стоимость: 19,377403: 100% | ██████████████████████████ |8/8 [02:28 <00:00, 17,93 с / с] </p>

Точность: 0,78846157

стоимость: 0,977960: 100% | ███████████████████████████ |8/8 [02:29 <00:00, 18,21 / it] </p>

Точность: 0,3653846

стоимость: 1,106399: 100% | ███████████████████████████ |8/8 [02:30 <00:00, 18.09s / it] </p>

Точность: 0,63461536

Стоимость: 0,896358: 100% | ███████████████████████████ |8/8 [02:28 <00:00, 18.02s / it] </p>

Точность: 0,84615386

стоимость: 0,622414: 100% | ███████████████████████████ |8/8 [02:33 <00:00, 18,56 / it] </p>

Точность: 0,88461536

стоимость: 0,521675: 100% | ███████████████████████████ |8/8 [02:34 <00:00, 18,57 / it] </p>

Точность: 0,8269231

стоимость: 0,421264: 100% | ███████████████████████████ |8/8 [02:22 <00:00, 17.09s / it] </p>

Точность: 0,9423077

стоимость: 0,314349: 100% | ███████████████████████████ |8/8 [02:20 <00:00, 16.99s / it] </p>

Точность: 0,9423077

стоимость: 0,240451: 100% | ███████████████████████████ |8/8 [02:25 <00:00, 17,43s / it] </p>

Точность: 0,9423077

Обучение завершено!

Это Керас:

import what i needed #(pseudo)

#model
model = keras.models.Sequential()
model.add(keras.layers.Conv2D(filters = 32, 
                              kernel_size=(3,3), 
                              padding='same', 
                              activation='relu', 
                              input_shape=(256, 256, 3)))
model.add(keras.layers.MaxPooling2D(pool_size=(3, 3),
                                   strides=3,
                                   padding='same'))
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Conv2D(filters=64,
                              kernel_size=(3,3), 
                              padding='same', 
                              activation='relu'))
model.add(keras.layers.MaxPooling2D(pool_size=(3, 3),
                                   strides=3,
                                   padding='same'))
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Conv2D(filters=128, 
                              kernel_size=(3,3), 
                              padding='same', 
                              activation='relu'))
model.add(keras.layers.MaxPooling2D((3, 3),
                                   strides=3,
                                   padding='same'))
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(625, activation='relu'))
model.add(keras.layers.Dropout(0.8))
model.add(keras.layers.Dense(4, activation='softmax'))

#data set
data_list = glob.glob('images dir') #(pseudo)
tf.set_random_seed(777)
random.shuffule(data_list)

train_x, train_y, test_x, test_y = data_list #(pseudo)
#image data shape is [none, 256, 256, 3]
#result shape is [4, ]
#train set: 500, test set: 230 ... (i know the tiny resource, but getting more data is not available.)

model.compile(optimizer=keras.optimizers.Adam(lr=0.001),
             loss='categorical_crossentropy',
             metrics=['accuracy'])

history = model.fit(train_x,
                   train_y,
                   batch_size=64,
                   epochs=20)

результат: Эпоха 1/20

500/500 [=============================] - 64 с 128 мс / шаг - потеря: 8,2847 - в соотв. 0,4860

Эпоха 2/20

500/500 [==============================] - 60 с 120 мс / шаг - потеря: 8,1880 - согласно: 0,4920

Эпоха 3/20

128/500 [======> .......................] - ETA: 45 с - потери: 8,4368 - в соотв. 0,4766

..это никогда не будет лучше, чем эта потеря и соотв ... 1065 *