2 万字全面测评深度学习框架 PaddlePaddle、TensorFlow 和 Keras | 程序员硬核评测

import numpy as np  
print(np.__version__)  
1.15.4 

import matplotlib  
print(matplotlib.__version__)  
2.2.3 

import paddle 
print(paddle.__version__)  
1.4.0

import numpy as np 
print(np.__version__) 
1.15.4 
 
import matplotlib 
print(matplotlib.__version__) 
2.2.3 
 
import tensorflow as tf 
print(tf.__version__) 
1.13.1

import matplotlib 
print(matplotlib.__version__) 
2.2.3 
 
import numpy 
print(numpy.__version__) 
1.15.4 

import tensorflow 
print(tensorflow.__version__) 
1.13.1 
 
import keras 
print(keras.__version__) 
2.2.4

import paddle 
train = paddle.dataset.mnist.train() 
test = paddle.dataset.mnist.test()

train() 

输出
<generator object reader_creator.<locals>.reader at 0x7f4d70c77e60>

train_imgs = [img for img in train()] 
test_imgs = [img for img in test()] 
print("train_length={}, test_length={}".format(len(train_imgs), len(test_imgs))) 

输出
train_length=60000, test_length=10000

from tensorflow.examples.tutorials.mnist import input_data 
 
mnist = input_data.read_data_sets("data/data65/", one_hot=True)

x_train, y_train = mnist.train.images, mnist.train.labels 
x_valid, y_valid = mnist.validation.images, mnist.validation.labels 
x_test, y_test = mnist.test.images, mnist.test.labels 
 
print("训练集图像大小：{}, 标签大小：{}".format(x_train.shape, y_train.shape)) 
print("验证集图像大小：{}，标签大小：{}".format(x_valid.shape, y_valid.shape)) 
print("测试集图像大小：{}，标签大小：{}".format(x_test.shape, y_test.shape))

训练集图像大小：(55000, 784), 标签大小：(55000, 10) 
验证集图像大小：(5000, 784)，标签大小：(5000, 10) 
测试集图像大小：(10000, 784)，标签大小：(10000, 10)

import keras 
from keras.datasets import  mnist 
 
(X_train, y_train), (X_test, y_test) = mnist.load_data()

print("X_train.shape={}, y_train.shape={}".format(X_train.shape, y_train.shape)) 
print("X_test.shape={}, y_test.shape={}".format(X_test.shape, y_test.shape))

X_train.shape=(60000, 28, 28), y_train.shape=(60000,) 
X_test.shape=(10000, 28, 28), y_test.shape=(10000,)

import random 
 
# 随机从数组中选择5张图像 
random_5_imgs = random.sample(train_imgs, 5) 
 
# PaddlePaddle读取出来的数据是由一个个元组作为数组元素 
# 每个元组的第一位为图像的向量，第二位是该向量对应的标签 
vector = random_5_imgs[0][0] 
label = random_5_imgs[0][1] 
print("vector.shape={}, label={}".format(vector.shape, label)) 
 
vectors = [] 
labels = [] 
for vector, label in random_5_imgs: 
    # 将每张图像向量转换成图像矩阵 
    vectors.append(vector.reshape((28,28))) 
    labels.append(label) 
 
print("第一张图像的.shape是{}".format(vectors[0].shape))

vector.shape=(784,), label=6 
第一张图像的.shape是(28, 28)

import matplotlib.pyplot as plt  
%matplotlib inline  
import numpy as np  
  
# 创建一个10x5大小的绘图对象 
fig = plt.figure(figsize=(10, 5))  
# 遍历5次，因为我们只随机选择了5张图像， 
# 所以这里显示的图像取决于每次随机的图像而变化 
# 每次的图像显示的肯定不一样 
for i in range(5):  
    ax = fig.add_subplot(1, 5, i+1, xticks=[], yticks=[])  
    ax.imshow(np.reshape(vectors[i:i+1], (28, 28)), cmap='gray')  
print("图像对应的标签是{}。".format(labels))

import matplotlib.pyplot as plt 
%matplotlib inline 
import numpy as np 
 
fig = plt.figure(figsize=(10, 10)) 
for i in range(5): 
    ax = fig.add_subplot(1, 5, i+1, xticks=[], yticks=[]) 
    ax.imshow(np.reshape(x_train[i+10:i+11], (28, 28)), cmap='gray')

import matplotlib.pyplot as plt 
%matplotlib inline 
import numpy as np 
 
fig = plt.figure(figsize=(10, 10)) 
for i in range(5): 
    ax = fig.add_subplot(1, 5, i+1) 
    ax.imshow(np.reshape(X_train[i:i+1], (28, 28)), cmap='gray')

import paddle.fluid as fluid 
import numpy as np 
 
# 表示0到9的共10个数字，就是10个类别
num_classes = 10 
 
# 我们使用CPU来训练模型 
use_cuda = False 
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() 
 
# 输入的原始图像数据，大小为28*28*1 
X = fluid.layers.data(name="img", shape=[1, 28, 28], dtype=np.float32) 
# 输入的原始图像数据的标签 
y = fluid.layers.data(name="label", shape=[1], dtype=np.int64) 
 
# 创建输出层，以softmax为激活函数的全连接层，输出层的大小必须为数字的个数10 
# fc表示全连接层（fully connected layer） 
predict = fluid.layers.fc(input=X, size=num_classes, act="softmax") 
 
# 使用类交叉熵函数计算predict和y之间的损失函数 
cost = fluid.layers.cross_entropy(input=predict, label=y) 
# 计算平均损失 
avg_loss = fluid.layers.mean(cost) 
# 计算分类准确率 
acc = fluid.layers.accuracy(input=predict, label=y) 
 
# 告知网络传入的数据分为两部分，第一部分是img值X，第二部分是label值y 
feeder = fluid.DataFeeder(feed_list=[X, y], place=place) 
# 选择Adam优化器，使损失最小化 
optimizer = fluid.optimizer.Adam(learning_rate=0.001).minimize(avg_loss)

# 超参数准备 
img_size = 28 * 28 
num_classes = 10 
learning_rate = 0.1 
 
# 创建模型 
# x表示输入，创建输入占位符，该占位符会在训练时，会对每次迭代的数据进行填充上 
x = tf.placeholder(tf.float32, [None, img_size]) 
 
# W表示weight，创建权重，初始化时都是为0，它的大小是(图像的向量大小，图像的总类别) 
W = tf.Variable(tf.zeros([img_size, num_classes])) 
 
# b表示bias，创建偏移项 
b = tf.Variable(tf.zeros([num_classes])) 
 
# y表示计算输出结果，softmax表示激活函数是多类别分类的输出 
# 感知器的计算公式就是：(x * W) + b 
y = tf.nn.softmax(tf.matmul(x, W) + b) 
 
# 定义输出预测占位符y_ 
y_ = tf.placeholder(tf.float32, [None, 10]) 
 
# 通过激活函数softmax的交叉熵来定义损失函数 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)) 
# 定义梯度下降优化器 
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) 
 
# 比较正确的预测结果 
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) 
# 计算预测准确率 
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

valid_len = int(X_test.shape[0] / 2) 
 
X_valid = X_test[:valid_len] 
y_valid = y_test[:valid_len] 
 
X_test = X_test[valid_len:] 
y_test = y_test[valid_len:] 
 
print("X_train.shape={}, y_train.shape={}".format(X_train.shape, y_train.shape)) 
print("X_valid.shape={}, y_valid.shape={}".format(X_valid.shape, y_valid.shape)) 
print("X_test.shape={}, y_test.shape={}".format(X_test.shape, y_test.shape))

X_train.shape=(60000, 28, 28), y_train.shape=(60000,) 
X_valid.shape=(5000, 28, 28), y_valid.shape=(5000,) 
X_test.shape=(5000, 28, 28), y_test.shape=(5000,)

import numpy as np 
 
img_size = 28 * 28 
num_classes = 10 
 
# 将训练集、验证集和测试集数据进行图像向量转换 
X_train = X_train.reshape(X_train.shape[0], img_size) 
X_valid = X_valid.reshape(X_valid.shape[0], img_size) 
X_test = X_test.reshape(X_test.shape[0], img_size) 
 
# 将训练集、验证集和测试集数据都转换成float32类型 
X_train = X_train.astype(np.float32) 
X_valid = X_valid.astype(np.float32) 
X_test = X_test.astype(np.float32) 
 
# 将训练集、验证集和测试集数据都转换成0到1之间的数值，就是归一化处理 
X_train /= 255 
X_valid /= 255 
X_test /= 255 
 
# 通过to_categorical()函数将训练集标签、验证集标签和测试集标签独热编码（one-hot encoding） 
y_train = keras.utils.to_categorical(y_train, num_classes) 
y_valid = keras.utils.to_categorical(y_valid, num_classes) 
y_test = keras.utils.to_categorical(y_test, num_classes)

from keras import Sequential 
from keras.layers import Dense, Dropout 
 
# 创建Sequential模型 
model = Sequential() 
 
# 创建输入层，有512个深度，必须要传的参数是input_shape，它表示输入的图像的大小 
model.add(Dense(512, activation='relu', input_shape=(img_size,))) 
model.add(Dropout(0.2)) 
 
# 创建一个隐藏层，也有512个深度 
model.add(Dense(512, activation='relu')) 
model.add(Dropout(0.2)) 
 
# 添加输出层，因为有10个类别的概率输出，所以使用softmax 
model.add(Dense(num_classes, activation='softmax')) 
 
# 模型架构预览 
model.summary()

Layer (type)                 Output Shape              Param #    
================================================================= 
dense_1 (Dense)              (None, 512)               401920     
_________________________________________________________________ 
dropout_1 (Dropout)          (None, 512)               0          
_________________________________________________________________ 
dense_2 (Dense)              (None, 512)               262656     
_________________________________________________________________ 
dropout_2 (Dropout)          (None, 512)               0          
_________________________________________________________________ 
dense_3 (Dense)              (None, 10)                5130       
================================================================= 
Total params: 669,706 
Trainable params: 669,706 
Non-trainable params: 0 
_________________________________________________________________

# 创建执行器 
executor = fluid.Executor(place) 
executor.run(fluid.default_startup_program()) 
 
# 设置 main_program 和 test_program 
main_program = fluid.default_main_program() 
test_program = fluid.default_main_program().clone(for_test=True)

def test_loss_acc(test_program, test_reader, test_feeder): 
    """ 
    在训练模型时，计算测试集的损失值和精确度 
    """ 
    loss_arr = [] 
    accuracy_arr = [] 
    # 开始迭代测试loss和acc 
    for test_data in test_reader(): 
        # 在Paddle中推理计算loss和acc 
        _loss, _acc = executor.run(test_program,  
                                   feed=test_feeder.feed(test_data),  
                                   fetch_list=[avg_loss, acc]) 
        loss_arr.append(float(_loss)) 
        accuracy_arr.append(float(_acc)) 
    # 获得测试数据集上的准确率和损失值的均值 
    loss_mean = np.array(loss_arr).mean() 
    accuracy_mean = np.array(accuracy_arr).mean() 
    return loss_mean, accuracy_mean

BATCH_SIZE = 64 

train_reader = paddle.batch(paddle.reader.shuffle(train, buf_size=500), batch_size=BATCH_SIZE) 

test_reader = paddle.batch(paddle.reader.shuffle(test, buf_size=500), batch_size=BATCH_SIZE) 
 
train_reader_length = len([1 for _ in train_reader()]) 
test_reader_length = len([1 for _ in test_reader()]) 
print("train_reader分了{}个batch，test_reader分了{}个batch。".format(train_reader_length, test_reader_length))

train_reader分了938个batch，test_reader分了157个batch。

epochs = 5 
saved_model_filename = "mnist.inference.model"  
result_arr = []      
step = 0  
# 开始迭代训练模型  
for epoch_id in range(epochs):  
    # 遍历训练集数据  
    for step_i, data in enumerate(train_reader()):  
          
        # 训练模型  
        metrics = executor.run(main_program,   
                               feed=feeder.feed(data),   
                               fetch_list=[avg_loss, acc])  
          
        # 每训练100次打印一次日志  
        if step % 100 == 0:  
            loss_train, accuracy_train = metrics[0][0], metrics[1][0] 
            print("Train Epoch {}, step_i {}, loss {}, acc {}".format(epoch_id,  
                                                                 step,  
                                                                 metrics[0][0],  
                                                                 metrics[1][0]))  
            # 评估测试集的分类效果  
            loss_val, accuracy_val = test_loss_acc(test_program, test_reader, feeder)  
            print("Valid Epoch {}, step_i {}，loss {}，acc {}".format(epoch_id,   
                                                                 step,   
                                                                 loss_val,  
                                                                 accuracy_val))  
        step += 1  
          
        result_arr.append((epoch_id, loss_val, accuracy_val, loss_train, accuracy_train))  
          
        # 保存训练好的模型参数用于预测  
        fluid.io.save_inference_model(saved_model_filename,  
                                      ["img"],   
                                      [predict],   
                                      executor,  
                                      model_filename=None,  
                                      params_filename=None)

Train Epoch 0, step_i 0, loss 3.662783145904541, acc 0.0625 
Valid Epoch 0, step_i 0，loss 0.9381991980751608，acc 0.7200437898089171 
Train Epoch 0, step_i 100, loss 0.4590408504009247, acc 0.890625 
......
Train Epoch 4, step_i 4500, loss 0.350452721118927, acc 0.90625 
Valid Epoch 4, step_i 4500，loss 0.19813986520051577，acc 0.9416799363057324 
Train Epoch 4, step_i 4600, loss 0.1873813271522522, acc 0.9375 
Valid Epoch 4, step_i 4600，loss 0.19667905686529957，acc 0.9430732484076433

best_predict = sorted(result_arr, key=lambda ele:float(ele[1]))[0] 
print("Valid Loss {}, Acc {:.5f}%.".format(best_predict[1], float(best_predict[2])*100)) 
print("Train Loss {}, Acc {:.5f}%.".format(best_predict[3], float(best_predict[4])*100))

Valid Loss 0.19667905686529957, Acc 94.30732%. 
Train Loss 0.1873813271522522, Acc 93.75000%.

import matplotlib.pyplot as plt 
%matplotlib inline 
 
 # 将训练时记录的loss和acc的数组的每一列都取出来
result_np = np.array(result_arr) 
# 索引为1的就是验证集loss
loss_val = result_np[:,1] 
# 索引为2的就是验证集的acc
accuracy_val = result_np[:,2] 
# 索引为3的就是训练集loss
loss_train = result_np[:,3] 
# 索引为4的就是训练集acc
accuracy_train = result_np[:,4] 

# 绘制训练集和验证集的损失值  
plt.plot(loss_train)  
plt.plot(loss_val)  
plt.title('Model Loss')  
plt.ylabel('Loss')  
plt.xlabel('Epoch')  
plt.legend(['train', 'test'], loc='upper left')  
plt.show()  
 
# 绘制训练集和验证集的精确度  
plt.plot(accuracy_val)  
plt.plot(accuracy_train)  
plt.title('Model Accuracy')  
plt.ylabel('Accuracy')  
plt.xlabel('Epoch')  
plt.legend(['train', 'test'], loc='upper left')  
plt.show()

import math 
 
epochs = 100 
batch_size = 128 
iteration = 0 
# 定义训练时的检查点 
saver = tf.train.Saver() 
 
valid_feed_dict = { x: x_valid, y_: y_valid  } 
test_feed_dict = { x: x_test, y_: y_test } 
history_train = [] 
history_valid = [] 
 
# 创建一个TensorFlow的会话 
with tf.Session() as sess: 
   
    # 初始化全局变量 
    sess.run(tf.global_variables_initializer()) 
         
    # 根据每批次训练128个样本，计算出一共需要迭代多少次 
    batch_count = int(math.ceil(mnist.train.labels.shape[0] / 128.0)) 
     
    # 开始迭代训练样本 
    for e in range(epochs): 
         
        # 每个样本都需要在TensorFlow的会话里进行运算，训练 
        for batch_i in range(batch_count): 
           
            # 样本的索引，间隔是128个 
            batch_start = batch_i * batch_size 
            # 取出图像样本 
            batch_x = mnist.train.images[batch_start:batch_start+batch_size] 
            # 取出图像对应的标签 
            batch_y = mnist.train.labels[batch_start:batch_start+batch_size] 
            # 训练模型 
            loss, acc, _ = sess.run([cost, accuracy, optimizer], feed_dict={x: batch_x, y_: batch_y}) 
             
            # 每100个批次时输出一次训练损失等日志信息 
            if batch_i % 100 == 0: 
                print("Epoch: {}/{}".format(e+1, epochs),  
                      "Iteration: {}".format(iteration),  
                      "Train loss: {:.5f}".format(loss), 
                      "Train acc: {:.5f}".format(acc)) 
                history_train.append((iteration, loss, acc)) 
                 
            iteration += 1 
 
            # 每128个样本时，验证一下训练的效果如何，并输出日志信息 
            if iteration % batch_size == 0: 
                valid_loss, valid_acc = sess.run([cost, accuracy], feed_dict=valid_feed_dict) 
                print("Epoch: {}/{}".format(e, epochs), 
                      "Iteration: {}".format(iteration), 
                      "Valid Loss: {:.5f}".format(valid_loss), 
                      "Valid Acc: {:.5f}".format(valid_acc)) 
                history_valid.append((iteration, valid_loss, valid_acc)) 
     
    # 保存训练模型的检查点 
    saver.save(sess, "checkpoints/mnist_mlp_tf.ckpt")

Epoch: 1/100 Iteration: 0 Train loss: 2.30259 Train acc: 0.11719 
Epoch: 1/100 Iteration: 100 Train loss: 2.08399 Train acc: 0.50781 
Epoch: 0/100 Iteration: 128 Valid Loss: 1.97898 Valid Acc: 0.63220
......
Epoch: 100/100 Iteration: 42870 Train loss: 1.50794 Train acc: 0.96875 
Epoch: 99/100 Iteration: 42880 Valid Loss: 1.54402 Valid Acc: 0.92800 
Epoch: 100/100 Iteration: 42970 Train loss: 1.57890 Train acc: 0.89062

import matplotlib.pyplot as plt 
%matplotlib inline 
import numpy as np 
 
# 绘制训练集和验证集的损失值   
plt.plot(np.array(history_train)[:,1])   
plt.plot(np.array(history_valid)[:,1])   
plt.title('Model Loss')   
plt.ylabel('Loss')   
plt.xlabel('Epoch')   
plt.legend(['train', 'test'], loc='upper left')   
plt.show()   
  
# 绘制训练集和验证集的精确度   
plt.plot(np.array(history_train)[:,2])   
plt.plot(np.array(history_valid)[:,2])    
plt.title('Model Accuracy')   
plt.ylabel('Accuracy')   
plt.xlabel('Epoch')   
plt.legend(['train', 'test'], loc='upper left')   
plt.show()

from keras.optimizers import RMSprop 
model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy'])

epochs = 20 
batch_size = 128 
 
history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1, validation_data=(X_valid, y_valid))

Train on 60000 samples, validate on 5000 samples 
Epoch 1/20 
60000/60000 [==============================] - 9s 150us/step - loss: 0.2438 - acc: 0.9242 - val_loss: 0.1313 - val_acc: 0.9592 
Epoch 2/20 
60000/60000 [==============================] - 9s 146us/step - loss: 0.1012 - acc: 0.9691 - val_loss: 0.1032 - val_acc: 0.9692 
Epoch 3/20 
......
60000/60000 [==============================] - 9s 146us/step - loss: 0.0190 - acc: 0.9948 - val_loss: 0.1506 - val_acc: 0.9756 
Epoch 19/20 
60000/60000 [==============================] - 9s 145us/step - loss: 0.0174 - acc: 0.9953 - val_loss: 0.1456 - val_acc: 0.9776 
Epoch 20/20 
60000/60000 [==============================] - 9s 152us/step - loss: 0.0182 - acc: 0.9955 - val_loss: 0.1736 - val_acc: 0.9758

import matplotlib.pyplot as plt 
%matplotlib inline 
 
# 绘制训练集和验证集的精确度 
plt.plot(history.history['acc']) 
plt.plot(history.history['val_acc']) 
plt.title('Model Accuracy') 
plt.ylabel('Accuracy') 
plt.xlabel('Epoch') 
plt.legend(['train', 'test'], loc='upper left') 
plt.show() 
 
# 绘制训练集和验证集的损失值 
plt.plot(history.history['loss']) 
plt.plot(history.history['val_loss']) 
plt.title('Model Loss') 
plt.ylabel('Loss') 
plt.xlabel('Epoch') 
plt.legend(['train', 'test'], loc='upper left') 
plt.show()

import matplotlib.pyplot as plt  
import matplotlib.image as mpimg  
  
img_matrix = next(train())[0].reshape(28, 28)  
img_label = next(train())[1] 
 
imgplot = plt.imshow(img_matrix, cmap="gray")  
plt.show()  
print("这张图像的标签是{}。".format(img_label))

# 创建执行器 
test_executor = fluid.Executor(place) 
test_executor.run(fluid.default_startup_program()) 
 
inference_scope = fluid.core.Scope() 
with fluid.scope_guard(inference_scope): 
    # 加载模型 
    [inference_program, feed_target_names, fetch_targets] = \ 
    fluid.io.load_inference_model(saved_model_filename, test_executor, None, None) 
     
    # 运行推理图像 
    results = test_executor.run(inference_program,  
                                feed={feed_target_names[0]: img_matrix.reshape(1,1,28,28)},  
                                fetch_list=fetch_targets) 
    # 预测的标签 
    predicted_label = np.argmax(results[0][0]) 
    # 预测概率 
    predicted_prob = max(results[0][0]) 
    print("Accuracy = {}, Label = {}".format(predicted_prob, predicted_label))

Accuracy = 0.9278314113616943, Label = 5

import matplotlib.pyplot as plt  
import matplotlib.image as mpimg  
 
target_label_index = 21   
index_21_img = x_test[target_label_index].reshape(28, 28)  
imgplot = plt.imshow(index_21_img, cmap="gray")  
plt.show()

target_label_arr = y_test[target_label_index]  
target_label = np.argmax(target_label_arr)  
print("索引为21的图像是数字{}。".format(target_label))

索引为21的图像是数字6。

checkpoint_file = tf.train.latest_checkpoint("checkpoints") 
graph = tf.get_default_graph() 
 
with graph.as_default(): 
   sess = tf.Session() 
   with sess.as_default(): 
        saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file)) 
        saver.restore(sess,checkpoint_file) 
         
        # for op in graph.get_operations(): 
        #       print(op.name) 
 
        softmax_classifer = graph.get_operation_by_name("Softmax").outputs[0] 
          
        index_10_img_to_predict = x_test[target_label_index].reshape((1, 784))  
        predicted_result = sess.run([softmax_classifer], feed_dict={x: index_10_img_to_predict}) 
        print(predicted_result) 
        print("预测的数字是{}。".format(np.argmax(predicted_result)))

INFO:tensorflow:Restoring parameters from checkpoints/mnist_mlp_tf.ckpt 
[array([[1.6478752e-07, 1.8716774e-10, 1.4367420e-05, 7.6656121e-08, 
        7.3713923e-06, 2.4220503e-04, 9.9968493e-01, 6.0247163e-13, 
        5.0681083e-05, 1.7343659e-07]], dtype=float32)] 
预测的数字是6。

import matplotlib.pyplot as plt 
import matplotlib.image as mpimg 
 
index_10_img = X_test[10].reshape(28, 28) 
imgplot = plt.imshow(index_10_img, cmap="gray") 
plt.show()

target_label_arr = y_test[10] 
target_label = np.argmax(target_label_arr) 
print("索引为10的图像是数字{}。".format(target_label))

索引为10的图像是数字6。

index_10_img_to_predict = X_test[10].reshape((1, 784)) 
predictions = model.predict(index_10_img_to_predict) 
print("预测的结果是{}。".format(np.argmax(predictions[0])))

预测的结果是6。