为什么同样的问题用Tensorflow和keras实现结果不一样？

Question

cifar-10分类问题，同样的模型结构以及损失函数还有学习率参数等超参数，分别用TensorFlow和keras实现。
20个epochs后在测试集上进行预测，准确率总是差好几个百分点，不知道问题出在哪里？代码如下：
这个是TF的代码：

import tensorflow as tf
import numpy as np
import pickle as pk

tf.reset_default_graph()

batch_size = 64
test_size = 10000
img_size = 32
num_classes = 10
training_epochs = 10
test_size=200

###############################################################################
def unpickle(filename):
    '''解压数据'''
    with open(filename, 'rb') as f:
        d = pk.load(f, encoding='latin1')
        return d


def onehot(labels):
    '''one-hot 编码'''
    n_sample = len(labels)
    n_class = max(labels) + 1
    onehot_labels = np.zeros((n_sample, n_class))
    onehot_labels[np.arange(n_sample), labels] = 1
    return onehot_labels


# 训练数据集
data1 = unpickle('data_batch_1')
data2 = unpickle('data_batch_2')
data3 = unpickle('data_batch_3')
data4 = unpickle('data_batch_4')
data5 = unpickle('data_batch_5')
X_train = np.concatenate((data1['data'], data2['data'], data3['data'], data4['data'], data5['data']), axis=0)/255.0
y_train = np.concatenate((data1['labels'], data2['labels'], data3['labels'], data4['labels'], data5['labels']), axis=0)
y_train = onehot(y_train)
# 测试数据集
test = unpickle('test_batch')
X_test = test['data']/255.0
y_test = onehot(test['labels'])
del test,data1,data2,data3,data4,data5
###############################################################################


w =  tf.Variable(tf.random_normal([5, 5, 3, 32], stddev=0.01))    
w_c= tf.Variable(tf.random_normal([32* 16* 16, 512], stddev=0.1))
w_o =tf.Variable(tf.random_normal([512, num_classes], stddev=0.1))

def init_bias(shape):
     return  tf.Variable(tf.constant(0.0, shape=shape))
b=init_bias([32])
b_c=init_bias([512])
b_o=init_bias([10])

def model(X, w, w_c,w_o, p_keep_conv, p_keep_hidden,b,b_c,b_o):

    conv1 = tf.nn.conv2d(X, w,strides=[1, 1, 1, 1],padding='SAME')#32x32x32
    conv1=tf.nn.bias_add(conv1,b)
    conv1 = tf.nn.relu(conv1)
    conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1],padding='SAME')#16x16x32
    conv1 = tf.nn.dropout(conv1, p_keep_conv)

    FC_layer = tf.reshape(conv1, [-1, 32 * 16 * 16])    

    out_layer=tf.matmul(FC_layer, w_c)+b_c
    out_layer=tf.nn.relu(out_layer)
    out_layer = tf.nn.dropout(out_layer, p_keep_hidden)

    result = tf.matmul(out_layer, w_o)+b_o

    return result

trX, trY, teX, teY = X_train,y_train,X_test,y_test

trX = trX.reshape(-1, img_size, img_size, 3) 
teX = teX.reshape(-1, img_size, img_size, 3)  

X = tf.placeholder("float", [None, img_size, img_size, 3])
Y = tf.placeholder("float", [None, num_classes])
p_keep_conv = tf.placeholder("float")
p_keep_hidden = tf.placeholder("float")

py_x = model(X, w, w_c,w_o, p_keep_conv, p_keep_hidden,b,b_c,b_o)

Y_ = tf.nn.softmax_cross_entropy_with_logits_v2(logits=py_x, labels=Y)
cost = tf.reduce_mean(Y_)
optimizer  = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
predict_op = tf.argmax(py_x, 1)

with tf.Session() as sess:

    tf.global_variables_initializer().run()
    for i in range(training_epochs):
        training_batch = zip(range(0, len(trX),batch_size),range(batch_size, len(trX)+1,batch_size))

        perm=np.arange(len(trX))
        np.random.shuffle(perm)
        trX=trX[perm]
        trY=trY[perm]

        for start, end in training_batch:
            sess.run(optimizer, feed_dict={X: trX[start:end],Y: trY[start:end],p_keep_conv:0.75,p_keep_hidden: 0.5})

        test_batch = zip(range(0, len(teX),test_size),range(test_size, len(teX)+1,test_size))

        accuracyResult=0
        for start, end in test_batch:
            accuracyResult=accuracyResult+sum(np.argmax(teY[start:end], axis=1) ==sess.run(predict_op, feed_dict={X: teX[start:end],Y: teY[start:end],p_keep_conv: 1,p_keep_hidden: 1}))
        print(i, accuracyResult/10000)

这个是keras代码：

from keras import initializers
from keras.datasets import cifar10
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.optimizers import SGD, Adam, RMSprop
#import matplotlib.pyplot as plt

# CIFAR_10 is a set of 60K images 32x32 pixels on 3 channels
IMG_CHANNELS = 3
IMG_ROWS = 32
IMG_COLS = 32
#constant
BATCH_SIZE = 64
NB_EPOCH = 10
NB_CLASSES = 10
VERBOSE = 1
VALIDATION_SPLIT = 0
OPTIM = RMSprop()
#load dataset
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
#print('X_train shape:', X_train.shape)
#print(X_train.shape[0], 'train samples')
#print(X_test.shape[0], 'test samples')

# convert to categorical
Y_train = np_utils.to_categorical(y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(y_test, NB_CLASSES)
# float and normalization
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

# network
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',input_shape=(IMG_ROWS, IMG_COLS, IMG_CHANNELS),kernel_initializer=initializers.random_normal(stddev=0.01),bias_initializer=initializers.Zeros()))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))              #0<参数<1才会有用
model.add(Flatten())
model.add(Dense(512,kernel_initializer=initializers.random_normal(stddev=0.1),bias_initializer=initializers.Zeros()))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(NB_CLASSES,kernel_initializer=initializers.random_normal(stddev=0.1),bias_initializer=initializers.Zeros()))
model.add(Activation('softmax'))
model.summary()

# train
model.compile(loss='categorical_crossentropy', optimizer=OPTIM,metrics=['accuracy'])
model.fit(X_train, Y_train, batch_size=BATCH_SIZE,epochs=NB_EPOCH, validation_split=VALIDATION_SPLIT,verbose=VERBOSE)
score = model.evaluate(X_test, Y_test,batch_size=200, verbose=VERBOSE)
print("Test score:", score[0])
print('Test accuracy:', score[1])