【机器学习实战】Keras人工神经网络简介

使用Keras实现MLP

加载数据集

import tensorflow as tf
from tensorflow import keras
from keras.datasets import fashion_mnist

(X_train_full, y_train_full), (X_test, y_test) = fashion_mnist.load_data()
X_valid, X_train = X_train_full[:5000]/255.0, X_train_full[5000:]/255.0 
y_valid, y_train = y_train_full[:5000], y_train_full[5000:] 

import numpy as np
import matplotlib as plt

X_trial = X_test[0:1]
X_trial = X_trial.sum(axis=0)
plt.subplot(1, 3, 1)
plt.imshow(X_trial, cmap='binary')
X_trial = X_test[1:2]
X_trial = X_trial.sum(axis=0)
plt.subplot(1, 3, 2)
plt.imshow(X_trial, cmap='binary')
X_trial = X_test[2:3]
X_trial = X_trial.sum(axis=0)
plt.subplot(1, 3, 3)
plt.imshow(X_trial, cmap='binary')
plt.show()

使用顺序API构建图像分类器
创建模型：

model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28]))
model.add(keras.layers.Dense(300, activation="relu"))
model.add(keras.layers.Dense(100, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))

或者：

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    keras.layers.Dense(300, activation='relu'),
    keras.layers.Dense(100, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

model.summary()
'''
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
flatten (Flatten)            (None, 784)               0         
_________________________________________________________________
dense (Dense)                (None, 300)               235500    
_________________________________________________________________
dense_1 (Dense)              (None, 100)               30100     
_________________________________________________________________
dense_2 (Dense)              (None, 10)                1010      
=================================================================
Total params: 266,610
Trainable params: 266,610
Non-trainable params: 0
_________________________________________________________________
'''
hidden1 = model.layers[1]
weights, bias = hidden1.get_weights()
weights
'''
array([[-0.06033064,  0.06430207,  0.04652306, ..., -0.04379936,
        -0.00667603, -0.00047912],
       [ 0.03643452, -0.04087247,  0.0719182 , ...,  0.0159453 ,
        -0.05017457, -0.03215472],
       [ 0.02160611,  0.03250387,  0.02693458, ..., -0.00446611,
        -0.02709223, -0.07062951],
       ...,
       [-0.00403008, -0.0090923 ,  0.03168578, ..., -0.05016059,
         0.00506989, -0.01153358],
       [ 0.01159029,  0.04252301,  0.05938339, ...,  0.01655462,
        -0.07017911,  0.01364357],
       [-0.02558086,  0.06982946,  0.02555563, ...,  0.008428  ,
        -0.06992331,  0.06821181]], dtype=float32)
'''

编译模型
创建模型后，必须调用compile()方法来指定损失函数和要使用的优化器。 也可以选择指定在训练和评估期间要计算的其他指标

model.compile(loss="sparse_categorical_crossentropy",
             optimizer="sgd", metrics=["accuracy"])

训练和评估模型

history = model.fit(X_train, y_train, epochs=30, validation_data=(X_valid, y_valid))
# ......

学习曲线

import pandas as pd
import matplotlib.pyplot as plt

pd.DataFrame(history.history).plot(figsize=(8, 5))
plt.grid(True)
plt.show()

model.evaluate(X_test, y_test)
'''
313/313 [==============================] - 0s 975us/step - loss: 72.5345 - accuracy: 0.8385
[72.53448486328125, 0.8385000228881836]
'''

进行预测

X_new = X_test[:3]
y_proba = model.predict(X_new)
y_proba.round(2)
'''
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)
'''
import numpy as np
y_pred=model.predict(X_new)
y_pred=np.argmax(y_pred,axis=-1)
y_pred
'''
array([9, 2, 1], dtype=int64)
'''

使用顺序API构建回归MLP

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
housing = fetch_california_housing()

X_train_full, X_test, y_train_full, y_test = train_test_split(housing.data, housing.target)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_full, y_train_full)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

model = keras.models.Sequential([
    keras.layers.Dense(30, activation="relu", input_shape=X_train.shape[1:]),
    keras.layers.Dense(1)
])
model.compile(loss="mean_squared_error", optimizer="sgd")
history = model.fit(X_train, y_train, epochs=20, validation_data=(X_valid, y_valid))
X_new = X_test[:3]
y_pred = model.predict(X_new)

y_pred
'''
array([[1.3531975],
       [0.3792649],
       [0.8870545]], dtype=float32)
'''

使用函数式API构建复杂模型

input_ = keras.layers.Input(shape=X_train.shape[1:])
hidden1 = keras.layers.Dense(30, activation="relu")(input_)
hidden2 = keras.layers.Dense(30, activation="relu")(hidden1)
concat = keras.layers.Concatenate()([input_, hidden2])
output = keras.layers.Dense(1)(concat)
model = keras.Model(inputs=[input_], outputs=[output])

使用子类API构建动态模型

class WideAndDeepModel(keras.Model):
    def __init__(self, units=30, activation="relu", **kwargs):
        super().__init__(**kwargs)
        self.hidden1 = keras.layers.Dense(units, activation=activation)
        self.hidden2 = keras.layers.Dense(units, activation=activation)
        self.main_output = keras.layers.Dense(1)
        self.aux_output = keras.layers.Dense(1)
        
    def call(self, inputs):
        input_A, input_B = inputs
        hidden1 = self.hidden1(input_B)
        hidden2 = self.hidden2(hidden1)
        concat = keras.layers.concatenate([input_A, concat])
        main_output = self.main_output(concat)
        aux_output = self.aux_output(hidden2)
        return main_output, aux_output
    
model = WideAndDeepModel()