我使用带有Tensorflow的CNN方法并获得了合适的结果（如acc的95％） 接下来，我对keras使用了相同的模型结构。我得到了不同的结果。它显示出可怕的累积力，而且历时并没有变好。
我更改了lr，pooling_size，过滤器等，但是效果并不理想。 我对mnist使用了keras模型。此模型在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]
准确性：0.1923077
费用：19.377403：100％|██████████████████████████| 8/8 [02:28 <00:00，17.93s / it]
准确度：0.78846157
费用：0.977960：100％|███████████████████████████| 8/8 [02:29 <00:00，18.21s / it]
准确度：0.3653846
费用：1.106399：100％|███████████████████████████| 8/8 [02:30 <00:00，18.09s / it]
准确性：0.63461536
费用：0.896358：100％|███████████████████████████| 8/8 [02:28 <00:00，18.02s / it]
准确度：0.84615386
费用：0.622414：100％|███████████████████████████| 8/8 [02:33 <00:00，18.56s / it]
准确度：0.88461536
费用：0.521675：100％|███████████████████████████| 8/8 [02:34 <00:00，18.57s / it]
准确度：0.8269231
费用：0.421264：100％|███████████████████████████| 8/8 [02:22 <00:00，17.09s / it]
准确性：0.9423077
费用：0.314349：100％|███████████████████████████| 8/8 [02:20 <00:00，16.99s / it]
准确性：0.9423077
费用：0.240451：100％|███████████████████████████| 8/8 [02:25 <00:00，17.43s / it]
准确性：0.9423077
学习结束！
这是Keras：
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 [==============================]-64s 128ms / step-损失：8.2847-acc： 0.4860
第2/20集
500/500 [==============================]-60s 120ms / step-损失：8.1880-acc： 0.4920
第3/20版
128/500 [======> ................................]-ETA：45s-损失：8.4368-acc：0.4766
..它永远不会比这种损失和损失更好...