keras神經網絡三個例子

keras構造神經網絡，很是之方便！之後就它了。本文給出了三個例子，都是普通的神經網絡

例1、離散輸出，單標籤、多分類

例2、圖像識別，單標籤、多分類。沒有用到卷積神經網絡（CNN）

例3、時序預測，單標籤、多分類。（LSTM）

說明

keras對於神經網絡給出的流程圖，很是容易理解。

圖片來源：https://www.jianshu.com/p/6c08f4ceab4c

【重點】訓練神經網絡圍繞如下對象:
  1. 層，用於合併成網絡(或模型)
  2. 輸入數據和相應的目標
  3. 損失函數,  定義了用於學習的反饋信號
  4. 優化器,  這決定了學習如何進行

 

例一

離散輸出，單標籤、多分類

本例來源：https://www.jianshu.com/p/f1332c58ca86

數據來源：https://blog.csdn.net/weixin_41090915/article/details/79521161

數據是本身構造的，分有三類，如圖

圖片來源：https://blog.csdn.net/weixin_41090915/article/details/79521161

 

import numpy as np
import pandas as pd

# =====================================================
# 準備數據
N = 100 # number of points per class 
D = 2 # dimensionality 
K = 3 # number of classes 
X = np.zeros((N * K, D)) # data matrix (each row = single example) 
y = np.zeros(N * K, dtype='uint8') # class labels 
for j in range(K): 
    ix = list(range(N*j, N*(j + 1))) 
    r = np.linspace(0.0, 1, N) # radius 
    t = np.linspace(j*4, (j+1)*4, N) + np.random.randn(N)*0.2 # theta 
    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)] 
    y[ix] = j # 打標籤

# 將y轉化爲one-hot編碼
#y = (np.arange(K) == y[:,None]).astype(int)
y = np.eye(K)[y]
# =====================================================


from keras import models
from keras import layers

# 使用Sequential類定義兩層模型
model = models.Sequential()
model.add(layers.Dense(10, activation='relu', input_shape=(2,)))
model.add(layers.Dense(3, activation='softmax'))

# 編譯。指定模型的優化器、損失函數、監控指標。
# 對於一個兩類分類問題，您將使用二元交叉熵（binary crossentropy）
# 對於一個多類分類問題使用分類交叉熵（categorical crossentropy）
# 對於迴歸問題使用均方差（meansquared error）
# 對於序列學習問題使用鏈接主義時間分類（connectionist temporal classification, CTC）
from keras import optimizers
model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])
'''
from keras import optimizers
from keras import losses
from keras import metrics
#from keras import optimizers, losses, metrics
model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss=losses.binary_crossentropy,
              metrics=[metrics.binary_accuracy])
'''

# 訓練網絡
model.fit(X, y, batch_size=50, epochs=1000)


# =====================================================
# 從新生成數據
X = np.zeros((N * K, D)) # data matrix (each row = single example) 
y = np.zeros(N * K, dtype='uint8') # class labels 
for j in range(K): 
    ix = list(range(N*j, N*(j + 1))) 
    r = np.linspace(0.0, 1, N) # radius 
    t = np.linspace(j*4, (j+1)*4, N) + np.random.randn(N)*0.2 # theta 
    X[ix] = np.c_[r*np.sin(t), r*np.cos(t)] 
    y[ix] = j # 打標籤

# 將y轉化爲one-hot編碼
#y = (np.arange(K) == y[:,None]).astype(int)
y = np.eye(K)[y]
# =====================================================

#檢查模型在測試集上的表現是否良好
test_loss, test_acc = model.evaluate(X, y)
print('test_acc:', test_acc)

 注意：就本例而言，若是標籤數據不進行one-hot編碼，則損失函數要更改成：loss='sparse_categorical_crossentropy',

 效果圖

例二

圖像識別，沒有用到卷積神經網絡（CNN）

本例來源：https://www.jianshu.com/p/ba51e470b736

手寫數字的識別，如圖

'''
試圖解決的問題是對灰度圖像進行分類的手寫數字(28×28個像素)到他們的10個分類(0到9)。
'''
# 導入數據
from keras.datasets import mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 瞭解數據狀況
#test_images.shape # (10000, 28, 28)
#test_labels # array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)

# 將輸入數組形狀由(60000,28,28)轉換爲(60000,28 * 28)
train_images = train_images.reshape((60000, 28 * 28))
test_images = test_images.reshape((10000, 28 * 28))

# 將[0,255]區間的整數轉換爲[0,1]之間的浮點數
train_images = train_images.astype('float32') / 255
test_images = test_images.astype('float32') / 255

# 對分類標籤y進行one-hot編碼
from keras.utils import to_categorical
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)


from keras import models
from keras import layers
network = models.Sequential()

#咱們的網絡由兩個密集層（Dense layers）組成，它們緊密鏈接(也稱爲徹底鏈接)神經層。
#第二個(也是最後一個)層是10路softmax層，這意味着它將返回一個包含10個機率分數的數組(總和爲1)，
#每一個分數都將是當前數字圖像屬於咱們的10個分類之一的機率。
network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))
network.add(layers.Dense(10, activation='softmax'))

#爲了使網絡爲訓練作好準備，咱們須要再選擇三樣東西，做爲編譯步驟的一部分:
#損失函數： 網絡如何可以測量它在訓練數據上的表現，如何可以引導本身走向正確的方向
#優化器：網絡根據所接收的數據及其損失函數進行自我更新的機制
#監控指標：這裏，咱們在訓練和測試期間只關心準確性(正確分類的圖像的一部分)
network.compile(optimizer='rmsprop',
                loss='categorical_crossentropy',
                metrics=['accuracy'])

#訓練這個網絡
network.fit(train_images, train_labels, epochs=5, batch_size=128)

#檢查模型在測試集上的表現是否良好
test_loss, test_acc = network.evaluate(test_images, test_labels)
print('test_acc:', test_acc)

 

效果圖

 

 例三

時間序列預測（LSTM）

本例來源：https://blog.csdn.net/zwqjoy/article/details/80493341

字母表的一個簡單的序列預測問題。
也就是說，根據字母表的字母，預測字母表的下一個字母。
['A', 'B', 'C'] -> D
['B', 'C', 'D'] -> E
['C', 'D', 'E'] -> F
['D', 'E', 'F'] -> G
['E', 'F', 'G'] -> H
['F', 'G', 'H'] -> I
['G', 'H', 'I'] -> J
['H', 'I', 'J'] -> K
['I', 'J', 'K'] -> L
['J', 'K', 'L'] -> M
['K', 'L', 'M'] -> N
['L', 'M', 'N'] -> O
['M', 'N', 'O'] -> P
['N', 'O', 'P'] -> Q
['O', 'P', 'Q'] -> R
['P', 'Q', 'R'] -> S
['Q', 'R', 'S'] -> T
['R', 'S', 'T'] -> U
['S', 'T', 'U'] -> V
['T', 'U', 'V'] -> W
['U', 'V', 'W'] -> X
['V', 'W', 'X'] -> Y
['W', 'X', 'Y'] -> Z

注意數據格式

X.shape: [samples, time_step, features]

y.shape: [samples, one_hot_encodes]

代碼：

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.utils import np_utils

'''
字母表的一個簡單的序列預測問題。
'''

np.random.seed(7)

# 原生數據
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

# 轉爲數字
data_len = 26
time_steps = 3
X = list(range(data_len))
y = X[time_steps:]

# 將數據轉化爲[樣本數, 時間步數, 特徵數]的形式
XX = [X[i:i+time_steps] for i in range(data_len-time_steps)] # [samples, time steps * features]
XXX = np.reshape(XX, (data_len - time_steps, time_steps, -1)) # [samples, time steps, features]


# 歸一化
# 數值範圍變爲0～1，這是LSTM網絡使用的s形激活函數（sigmoid）的範圍。
X = XXX / data_len
# one-hot編碼
#y = np_utils.to_categorical(dataY)
y = np.eye(data_len)[y]

# =================================
model = Sequential()
model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
model.add(Dense(y.shape[1], activation='softmax')) # 輸出各種的機率(softmax)
model.compile(loss='categorical_crossentropy',     # 單標籤，多分類(categorical_crossentropy)
              optimizer='adam', 
              metrics=['accuracy'])

model.fit(X, y, epochs=500, batch_size=1, verbose=2)

#檢查模型在測試集上的表現是否良好
test_loss, test_acc = model.evaluate(X, y)
print('test_acc:', test_acc)

 

效果圖