最初に登場条個人のブログ
記事のディレクトリ
入門
記事では、ロジスティックス回帰、マルチ分類アルゴリズムと勾配ソフトマックスの概念に言及し、実際には、自然の深さの研究につながることができます。
ウィキ参照定義の：
深さ（深学習）を学習することは、データ抽象化レベルのためのアルゴリズムを非線形変換複数からなる1つ以上のプロセス層を含む複合構造体を使用しようとする試みであり、機械学習の分岐です。
1958年には早くも、一度、モデルパーセプトロン最も単純な線形であるモデルパーセプトロンを、提案したが、大きなセンセーションを巻き起こし、さえ作られたマシンは、人々が言う置き換えることができますが、後で質問された、それは線形ようですパーセプトロンの明白な限界。
（また、ニューラルネットワークとしても知られている）、多層パーセプトロンを提案し、その後、1980年代に、前パーセプトロンによれば、モデル、今日のニューラルネットワークの深さが大きく異なりません。1986年は、バックプロパゲーションの概念を提案したが、通常は3より大きい、隠された層は効果がありませんし、ニューラルネットワークは、勾配が消滅の問題を学びます。
その後、2006年には、ニューラルネットワーク上記のアルゴリズムモデルに、変更の名前パーセプトロン多層の前にいくつかの改善（RBMの初期化）を、作られた - 操作がDL始めたときディープラーニングは再び2009年に提唱さアップ発射し、背後にあるいくつかの進展が様々な分野で画期的なアプリケーションとなっていることを、GPUを使用。
だから、深い学習は新しいが、古いを少し変更したモデル名には何もありません。
完全に接続されているニューラルネットワークの前に
以下に示すフィードフォワードニューラルネットワーク全体の接続例、SIGMOD活性化機能は、重みとバイアスを知っているこの完全に接続されたニューラル・ネットワークを介して前述したケースの関数であり、入力ベクトルは常に変化されます最後に、ベクトルの出力。
一般的に、完全に接続するフィードフォワードネットワークアーキテクチャは、前の層の各入力は、次の層内のすべての神経素子に接続されて、以下に示します：
入力層と出力層はベクトルであるが、必ずしも同じ寸法で隠れ層が位置学習深い深され、一般的に多層です。
ニューラルネットワークの本質は、運用行列演算であり、これはGPUがニューラルネットワークの嘘を加速させることができる理由です。
例
手書き数字の認識は、例として以前に使用されているに、Mnistトレーニングデータセットを使用して、2つのpytorchのkeras完全接続フィードフォワードネットワークモデルを構築するために使用しました。
（TensorFlowバックエンドを使用する。）第kerasコードは次の通りであります：
#!/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])
これは10のエポックのために訓練された二フロント完全に接続ニューラルネットワークである次のように、精度率です。
次のようにGPU、CPUランアップ遅すぎる、97.7パーセントの正解率、ニューラルネットワーク構造なし：
pytorchは、次のようにそのコードは、簡単なので、何の使用をkerasません。
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')
精度は次のよう：
全体の時間では、遅くTFよりも、再インストールするか、または遅くするソースからコンパイル。。
