keras与pytorch搭建神经网络

参考：刘志瑛《Tensorflow+Pytorch深度学习从算法到实战》

网络搭建的过程： 整体网络训练的过程：搭建框架——编译——训练——评估——预测/使用

使用keras搭建基本步骤核心代码实例

import keras
from keras.layers import Conv2D,MaxPooling2D,Flatten,Dense,Dropout
from keras.models import Sequential

# 网络模型构造方法1，过程化构造网络模型
model = Sequential()
model.add(
    Conv2D(32, kernel_size=(3, 3), activation='relu',
           input_shape=(28, 28, 1)))  # 32核卷积
model.add(MaxPooling2D(pool_size=(2, 2)))  # 2*2池化
model.add(Conv2D(64, (3, 3), activation='relu'))  # 64核卷积
model.add(MaxPooling2D(pool_size=(2, 2)))  # 2*2池化
model.add(Flatten())  # 连接层，卷积和全连接网络的中介
model.add(Dense(128, activation='relu'))  # 全连接层
model.add(Dropout(0.5))  # Dropout层
model.add(Dense(10, activation='softmax'))

# 网络模型构造方法2，函数式方法构造网络模型，
# 常用于网络结构中并联,复用的部分
# input_img = Input(shape=(256,256,3)) # 并不是真正的执行代码，只是表示输入的图像
# tower_1 = Conv2D(64,(1,1),padding='same',activation='relu')(input_img)
# tower_2 = Conv2D(64,(1,1),padding='same',activation='relu')(tower_1)

# 编译
model.compile( loss=keras.losses.categorical_crossentropy,
    optimizer=keras.optimizers.Adadelta(),
    metrics=['accuracy'])

# 训练
model.fit(
    X_train,  # 训练使用的输入和标签数据
    y_train,
    batch_size=128,  # 每次训练数据个数
    epochs=10,   # 整体训练10次
    verbose=1,  #verbose: 0, 1 或 2。日志显示模式。 0 = 安静模式, 1 = 进度条, 2 = 每轮一行
    validation_data=(X_test, y_test)) #用来评估损失，以及在每轮结束时的任何模型度量指标

# 评估
score = model.evaluate(X_test, y_test, verbose=0)
print('损失数:', score[0])
print('准确率:', score[1])

# 预测
classes = model.predict(x_test,batch_size=128)

使用torch搭建基本步骤核心代码实例

import numpy as np
import torch as t

# 超参数
num_epochs = 30  # 训练轮数
learning_rate = 1e-3  # 学习率
batch_size = 100  # 批量大小

####### 训练部分

# 创建网络框架
class FirstCnnNet(t.nn.Module):  # CNN网络
    def __init__(self, num_classes):  # 初始化只需要输出这一个参数
        super(FirstCnnNet, self).__init__()  # 固定格式
        self.conv1 = t.nn.Sequential(
            t.nn.Conv2d(1, 16, kernel_size=5, stride=2, padding=2),
            t.nn.BatchNorm2d(16),
            t.nn.ReLU())  # 输入深度1，输出深度16。从1,28,28压缩为16,14,14
        self.conv2 = t.nn.Sequential(
            t.nn.Conv2d(16, 32, kernel_size=5, stride=2, padding=2),
            t.nn.BatchNorm2d(32), t.nn.ReLU(),
            t.nn.MaxPool2d(kernel_size=2,
                           stride=1))  # 输入深度16，输出深度32。16,14,14压缩到32,6,6
        self.dense1 = t.nn.Sequential(
            t.nn.Linear(6 * 6 * 32, 128), t.nn.ReLU(),
            t.nn.Dropout(p=0.25))  # 第1个全连接层，输入6*6*32，输出128
        self.dense2 = t.nn.Linear(128, num_classes)  # 第2个全连接层，输入128，输出10类

    def forward(self, x):  # 传入计算值的函数，真正的计算在这里
        x = self.conv1(x)  # 16,14,14
        x = self.conv2(x)  # 32,6,6
        x = x.view(x.size(0), -1)
        x = self.dense1(x)  # 32*6*6 -> 128
        x = self.dense2(x)  # 128 -> 10
        return x
 # 输入28*28，隐藏层128，输出10类，创建定义一个实例框架，执行__init__()
model = FirstCnnNet(10)  # 后面的model(),都是执行的 forward函数
optimizer = t.optim.Adam(model.parameters(), lr=learning_rate)  # 优化器仍然选随机梯度下降

X_train_size = len(X_train)

for epoch in range(num_epochs):
    print('Epoch:', epoch)  # 打印轮次：

    X = t.autograd.Variable(t.from_numpy(X_train))
    y = t.autograd.Variable(t.from_numpy(y_train))

    i = 0
    while i < X_train_size:
        X0 = X[i:i + batch_size]  #取一个新批次的数据
        X0 = X0.view(-1, 1, 28, 28)
        y0 = y[i:i + batch_size]
        i += batch_size

        # 正向传播
        out = model(X0)  # 用神经网络计算10类输出结果
        loss = t.nn.CrossEntropyLoss()(out, y0)  # 计算神经网络结果与实际标签结果的差值

        # 反向梯度下降
        optimizer.zero_grad()  # 清空梯度
        loss.backward()  # 根据误差函数求导
        optimizer.step()  # 进行一轮梯度下降计算

    print(loss.item())

############## 验证部分

model.eval()  ## 将模型设为验证模式

X_val = t.autograd.Variable(t.from_numpy(X_test))
y_val = t.autograd.Variable(t.from_numpy(y_test))

X_val = X_val.view(-1, 1, 28, 28)  # 整形成CNN需要的输入

out_val = model(X_val)  ## 用训练好的模型计算结果
loss_val = t.nn.CrossEntropyLoss()(out_val, y_val)

print(loss_val.item())

_, pred = t.max(out_val, 1)  # 求出最大的元素的位置
num_correct = (pred == y_val).sum()  # 将预测值与标注值进行对比

print(num_correct.data.numpy() / len(y_test))  # 显示正确率