Para practicar los números escritos a mano de la red neuronal antes totalmente conectada

El artículo apareció por primera vez en el blog personal

introducción

El artículo menciona la regresión logística, el concepto de algoritmo multi-clasificación y softmax gradiente, de hecho, puede dar lugar a un estudio de profundidad natural.

definición de referencia de WiKi:

El aprendizaje de profundidad (aprendizaje profundo) es una rama de aprendizaje de máquina, es un intento de utilizar una estructura compleja que comprende una o más capas proceso compuesto de múltiple no lineal transformar algoritmo para el nivel de abstracción de datos.

Ya en 1958, propuso un modelo de perceptrón, que es la más lineal perceptrón simple modelo, en el momento causó una gran sensación, incluso hizo máquina puede sustituir a las personas dicen, pero más tarde fue puesta en duda, parece lineal evidentes limitaciones del perceptrón.

Luego, en la década de 1980, de acuerdo con perceptrón anterior propuesto perceptrón multicapa (también conocida como red neuronal), el modelo y la profundidad de la red neural de hoy no es significativamente diferente. 1986 propuesto el concepto de propagación hacia atrás, pero capa típicamente mayor que tres oculto no tiene ningún efecto, y la red neural aprender un problema con los desaparece de gradiente.

Más tarde, en 2006, en el modelo anterior algoritmo de red neuronal, hecho algunas mejoras (GBR) de inicialización, antes de que el perceptrón multicapa nombres cambiados - Deep Learning nuevamente presentada en 2009, cuando comenzó la operación DL uso de la GPU, detrás de que algunos avances han sido aplicaciones innovadoras en diversos campos, para arrancar.

Así, el aprendizaje profundo no es nada nuevo, pero para un poco modificados nombres de los modelos de la antigüedad.

Antes de redes neuronales totalmente conectados

Un ejemplo feedforward neural de toda la red de conexión se muestra a continuación, que la función de activación SIGMOD es una función del caso anteriormente mencionado a través de este redes neuronales totalmente conectadas, que son conscientes de que el peso y el sesgo, el vector de entrada estará constantemente cambiando Por último, la salida de un vector.

Generalmente, Completamente arquitectura de conexión Feedforward red que se muestra a continuación, cada entrada de la capa anterior están conectados a todo el elemento neural en la capa siguiente:

La capa de capa de entrada y de salida es un vector, pero no necesariamente la misma dimensión, en el que la capa oculta son generalmente de múltiples capas, que es un profundo profundo aprendizaje situado.

La esencia de la red neuronal es operaciones con matrices operativas, y esta es la razón por la GPU puede acelerar redes neuronales mentiras.

Ejemplos

En reconocimiento de los números escritos a mano se han utilizado anteriormente como un ejemplo, se utilizaron para la construcción de dos Keras pytorch y modelos de red de alimentación directa totalmente de conexión, utilizando los datos de entrenamiento Mnist.

Primeros Keras (usando TensorFlow back-end). El código es el siguiente:

#!/usr/local/bin/python3.6

import numpy as np
import os
import matplotlib.pyplot as plt
import keras
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.utils import np_utils
from keras import backend as K

# 多核 CPU 使用设置
K.set_session(K.tf.Session(config=K.tf.ConfigProto(device_count={"CPU": 8},
                inter_op_parallelism_threads=8,
                intra_op_parallelism_threads=8,
                log_device_placement=True)))

# tensorboard 可视化        
tbCallBack = keras.callbacks.TensorBoard(log_dir='./Graph',
                                         histogram_freq=1,
                                         write_graph=True,
                                         write_images=True)

# 加载数据集
def load_data(file_path):
    f = np.load(file_path)
    x_train, y_train = f['x_train'], f['y_train']
    x_test, y_test = f['x_test'], f['y_test']
    f.close()
    return (x_train, y_train), (x_test, y_test)


# 初始化数据
(X_train, y_train), (X_test, y_test) = load_data('./mnist.npz')

X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

nb_classes = 10
# 将 label 数据转化为 one-hot，因为模型训练 loss 参数为 categorical_crossentropy
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)

# 初始化一个 model
model = Sequential()
# 添加第一层，输入是784维，第一层节点为 500，激活函数为 relu
model.add(Dense(500, input_shape=(784,)))
model.add(Activation('relu'))
# model.add(Dropout(0.2))
# 添加第二层，节点为 500，激活函数为 relu
model.add(Dense(500))
model.add(Activation('relu'))
# model.add(Dropout(0.2))
# 添加输出层，输出 10 维，激活函数为 softmax
model.add(Dense(10))
model.add(Activation('softmax'))

# 配置模型训练参数，loss 使用多类的对数损失函数，optimizer 优化器使用 adam，模型性能评估使用 accuracy
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# 开始训练，batch_size为100， 10 个 epoch，callbacks调用 tensorboard
model.fit(X_train, Y_train,
          batch_size=100, epochs=10,
          validation_data=(X_test, Y_test),
          callbacks=[tbCallBack]
          )

score = model.evaluate(X_test, Y_test, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])

Esta es una red neural totalmente conectado en dos frentes, entrenado durante 10 épocas, la tasa de precisión es el siguiente:

Sin la GPU, CPU-correr hasta demasiado lento, la tasa de precisión de 97,7%, lo que neural estructura de red como sigue:

pytorch Keras sin uso, de manera simple, su código es el siguiente:

import os
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms

# 多核 cpu 设置
os.environ["OMP_NUM_THREADS"] = "8"
os.environ["MKL_NUM_THREADS"] = "8"

# 设置使用 CPU
device = torch.device('cpu')

# 参数配置
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 10
batch_size = 100
learning_rate = 0.001
# 1 MNIST dataset 加载图像数据
train_dataset = torchvision.datasets.MNIST(root='.',
                                           train=True,
                                           transform=transforms.ToTensor(),
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='.',
                                          train=False,
                                          transform=transforms.ToTensor())

# 2 Data loader pytorch的数据加载方式，tensorflow是没有的
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)


# 3 Fully connected neural network with one hidden layer 定义网络
class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out


model = NeuralNet(input_size, hidden_size, num_classes).to(device)

# 4 Loss and optimizer 定义损失和优化函数
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),
                             lr=learning_rate)

# 5 Train the model 训练模型
total_step = len(train_loader)
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  # batch size的大小
        # Move tensors to the configured device
        images = images.reshape(-1, 28*28).to(device)
        labels = labels.to(device)

        # Forward pass 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # Backward and optimize 后向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))

# Test the model 预测
# In test phase, we don't need to compute gradients (for memory efficiency)
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.reshape(-1, 28*28).to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the network on the 10000 test images: {} %'
            .format(100 * correct / total))

# Save the model checkpoint
torch.save(model.state_dict(), 'model.ckpt')

La exactitud de la siguiente manera:

En todo el tiempo, más lento que el del TF, de nuevo compilado desde el código fuente para instalar o lento. .