使用Keras构建分类问题的MLP神经网络——用于糖尿病预测

        大家好，我是带我去滑雪！

         Keras 是一个用于构建和训练深度学习模型的高级 API，它基于 Python编写，并能够运行于 TensorFlow, CNTK, 或者 Theano 等深度学习框架之上。Keras简化了深度神经网络的构建流程，让用户能够更加简单、快速地搭建一个完整的深度学习模型，同时具有足够的灵活性。 Keras不仅提供了很多常用的深度学习网络结构的实现，如卷积神经网络、循环神经网络、自编码器，还提供了许多有用的工具集，如优化器、损失函数等，这些都能够帮助用户快速构建深度学习模型，并进行模型训练、评估和优化。相比于深度学习中的pytorch框架，Keras更加容易让人理解。目前Keras 官方并没有支持在 PyTorch 框架上运行，但是可以使用相应的转换工具进行转换。 其中，最著名的工具是 TensorFlow 1.x 版本中的 tf.keras 来构建模型，使用 TensorFlow 的模型格式，然后再使用 TensorFlow 将其转换为 PyTorch 模型格式。但是由于两个框架的不同，转换并不能保证 100% 的准确性。因此，在转换模型之前，应该仔细检查和测试模型的性能和结果。

目录

1、认识Keras深度学习模型

2、Keras预建神经网络类型

3、使用Keras构建分类问题的MLP神经网络——用于糖尿病预测

（1）导入数据集与相关模块

（2）拆分数据集

（3）定义神经网络模型

（4）编译模型和训练模型

（5）评估模型

4、优化调整神经网络

（1）对特征变量进行标准化

（2）在输出层使用softmax激活函数

（3）在神经层使用权重初始器

（4）在编译模型中使用adam优化器

（5）减少神经网络的参数量

5、使用测试集与验证集

（1）将数据集分割成训练和测试数据集

（2）在训练模型时使用验证集

 6、神经网络模型预测

7、存储与载入神经网络模型

（1）分开存储模型结构与权重

 （2）同时存储模型结构与权重

（3）载入神经网络模型结构与权重

1、认识Keras深度学习模型

       模型是Keras函数库的核心数据结构，Keras目前支持两种模型，其中一种是Sequential模型（一种线性堆栈结构），当创建Sequential对象后，可以使用add（）函数增加新的神经网络层，神经层是单一输出和输入，每一层都连接着下一层，但不允许跨层连接。另外一种是Functional API，如果需要构建复杂的多输入和多输出，或者共享神经层的深度学习模型，就需要Functional API创建模型。

2、Keras预建神经网络类型

       Keras中的Sequential模型好比一个容器，可以容纳多种神经层类型，常用的神经网络类型有：

• 多层感知器 (MLP)：是一个全连接的神经网络，每个神经元都与前一层的所有神经元相连。在 Keras 中，MLP 可以通过 Dense 层来构建

• 循环神经网络 (RNN)：是一种在时间序列上工作的神经网络，按照时间顺序依次处理序列中的数据。在 Keras 中，RNN 可以通过 SimpleRNN、LSTM 和 GRU 等层来构建。

• 卷积神经网络 (CNN)：是一种最常见的深度学习模型，可以用于图像分类、物体检测等计算机视觉任务。在 Keras 中，CNN 可以通过 Conv2D 和 MaxPooling2D 等层来构建。

3、使用Keras构建分类问题的MLP神经网络——用于糖尿病预测

        所用数据集的响应变量为 5年内是否得有糖尿病（Outcome），其中1表示有，0表示没有。特征变量有怀孕次数（Pregnancies）、两小时内口服葡萄糖检测血液中的血糖浓度（BloodPressure）、血压（SkinThickness）、三头肌皮肤厚度（SkinThickness）、血清胰岛素（Insulin）、身体指数（BMI）、家族成员患糖尿病史（DiabetesPedigreeFunction）、年龄（Age）共计8个指标，均为数值型变量。

（1）导入数据集与相关模块

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential#导入Sequential模型
from tensorflow.keras.layers import Dense#导入Dense全连接层
df = pd.read_csv(r'E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
df

输出结果：

	Pregnancies	Glucose	BloodPressure	SkinThickness	Insulin	BMI	DiabetesPedigreeFunction	Age	Outcome
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1
...	...	...	...	...	...	...	...	...	...
763	10	101	76	48	180	32.9	0.171	63	0
764	2	122	70	27	0	36.8	0.340	27	0
765	5	121	72	23	112	26.2	0.245	30	0
766	1	126	60	0	0	30.1	0.349	47	1
767	1	93	70	31	0	30.4	0.315	23	0

768 rows × 9 columns

（2）拆分数据集

np.random.seed(8)  # 指定随机数种子 
dataset = df.values
np.random.shuffle(dataset)  # 使用随机数打乱数据  
 X = dataset[:, 0:8]#将数据分割成特征数据集和标签数据 
Y = dataset[:, 8]

（3）定义神经网络模型

       规划的神经网络模型中有4层，其中输入层有8种特征数据，两个隐藏层分别有10个和8个神经元，输出层为1个神经元。

# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))#隐藏层设置
model.add(Dense(8, activation="relu"))#隐藏层设置
model.add(Dense(1, activation="sigmoid"))#输出层设置
model.summary()  # 显示模型摘要

输出结果：

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_3 (Dense)             (None, 10)                90        
                                                                 
 dense_4 (Dense)             (None, 8)                 88        
                                                                 
 dense_5 (Dense)             (None, 1)                 9         
                                                                 
=================================================================
Total params: 187
Trainable params: 187
Non-trainable params: 0

（4）编译模型和训练模型

        在编译模型中损失函数使用二元分类的binary_crossentropy，优化器使用随机梯度下降法，使用准确度作为评估指标。在训练模型中训练周期设置为150次，批次尺寸设置为10。

# 编译模型  
model.compile(loss="binary_crossentropy", optimizer="sgd",
              metrics=["accuracy"])
#训练模型
model.fit(X, Y, epochs=150, batch_size=10)

输出结果：

Epoch 144/150
77/77 [==============================] - 0s 1ms/step - loss: 0.5850 - accuracy: 0.6849
Epoch 145/150
77/77 [==============================] - 0s 1ms/step - loss: 0.6000 - accuracy: 0.6628
Epoch 146/150
77/77 [==============================] - 0s 2ms/step - loss: 0.5897 - accuracy: 0.6940
Epoch 147/150
77/77 [==============================] - 0s 2ms/step - loss: 0.5956 - accuracy: 0.6823
Epoch 148/150
77/77 [==============================] - 0s 1ms/step - loss: 0.5891 - accuracy: 0.6953
Epoch 149/150
77/77 [==============================] - 0s 1ms/step - loss: 0.5910 - accuracy: 0.7018
Epoch 150/150
77/77 [==============================] - 0s 1ms/step - loss: 0.5920 - accuracy: 0.7031
24/24 [==============================] - 0s 1ms/step - loss: 0.5986 - accuracy: 0.7135

（5）评估模型

# 评估模型
loss, accuracy = model.evaluate(X, Y)
print("准确度 = {:.2f}".format(accuracy))

输出结果：

准确度 = 0.71

        模型的准确度达到0.71。

4、优化调整神经网络

       上面我们构建的神经网络深度学习模型过于粗糙，能够改进的地方很多，下面进行逐步调整，看看是否会提升模型的准确度。

（1）对特征变量进行标准化

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential#导入Sequential模型
from tensorflow.keras.layers import Dense#导入Dense全连接层
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')

np.random.seed(8)  # 指定随机数种子 
 
dataset = df.values
np.random.shuffle(dataset)  # 使用随机数打乱数据 
X = dataset[:, 0:8]#将数据分割成特征数据集和标签数据 
Y = dataset[:, 8]
# 特征标准化  
X -= X.mean(axis=0)
X /= X.std(axis=0)
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))#隐藏层设置
model.add(Dense(8, activation="relu"))#隐藏层设置
model.add(Dense(1, activation="sigmoid"))#输出层设置
model.summary()  # 显示模型摘要

# 编译模型  
model.compile(loss="binary_crossentropy", optimizer="sgd",
              metrics=["accuracy"])
#训练模型
model.fit(X, Y, epochs=150, batch_size=10)
# 评估模型
loss, accuracy = model.evaluate(X, Y)
print("准确度 = {:.2f}".format(accuracy))

输出结果：

77/77 [==============================] - 0s 1ms/step - loss: 0.4055 - accuracy: 0.8177
Epoch 144/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4046 - accuracy: 0.8099
Epoch 145/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4044 - accuracy: 0.8151
Epoch 146/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4044 - accuracy: 0.8177
Epoch 147/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4042 - accuracy: 0.8190
Epoch 148/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4036 - accuracy: 0.8125
Epoch 149/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4030 - accuracy: 0.8151
Epoch 150/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4027 - accuracy: 0.8203
24/24 [==============================] - 0s 1ms/step - loss: 0.3996 - accuracy: 0.8190
准确度 = 0.82

         可以看到，模型的准确度提升了一些。

（2）在输出层使用softmax激活函数

        在前面构建的神经网络模型中，输出层的神经元只有一个，所以选择了Sigmoid激活函数，现在将激活函数替换为 softmax激活函数，将输出层的神经元改为2个，将响应变量进行One-hot编码。

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset)  
X = dataset[:, 0:8]
Y = dataset[:, 8]
#  特征标准化  
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))
model.add(Dense(8, activation="relu"))
model.add(Dense(2, activation="softmax"))
# model.summary()   
model.compile(loss="binary_crossentropy", optimizer="sgd", 
              metrics=["accuracy"])
# 训练模型
model.fit(X, Y, epochs=150, batch_size=10, verbose=1)
#评估模型
loss, accuracy = model.evaluate(X, Y, verbose=1)
print("准确度 = {:.2f}".format(accuracy))

输出结果：

77/77 [==============================] - 0s 1ms/step - loss: 0.4144 - accuracy: 0.8112
Epoch 145/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4142 - accuracy: 0.8086
Epoch 146/150
77/77 [==============================] - 0s 2ms/step - loss: 0.4139 - accuracy: 0.8060
Epoch 147/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4138 - accuracy: 0.8099
Epoch 148/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4133 - accuracy: 0.8047
Epoch 149/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4133 - accuracy: 0.8008
Epoch 150/150
77/77 [==============================] - 0s 1ms/step - loss: 0.4132 - accuracy: 0.8060
24/24 [==============================] - 0s 1ms/step - loss: 0.4101 - accuracy: 0.8099
准确度 = 0.81

        模型的准确率没有变化。

（3）在神经层使用权重初始器

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,),
                kernel_initializer="random_uniform", 
                bias_initializer="ones",
                activation="relu"))
model.add(Dense(8, kernel_initializer="random_uniform",
                bias_initializer="ones",
                activation="relu"))
model.add(Dense(2, kernel_initializer="random_uniform",
                bias_initializer="ones",
                activation="softmax"))
#编译模型
model.compile(loss="binary_crossentropy", optimizer="sgd", 
              metrics=["accuracy"])
# 训练模型
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
#  评估模型
loss, accuracy = model.evaluate(X, Y, verbose=0)
print("准确度 = {:.2f}".format(accuracy))

输出结果：

准确度 = 0.78

        在神经层使用权重初始器，对模型的准确率的提升不明显。

（4）在编译模型中使用adam优化器

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,),
                kernel_initializer="random_uniform", 
                bias_initializer="ones",
                activation="relu"))
model.add(Dense(8, kernel_initializer="random_uniform",
                bias_initializer="ones",
                activation="relu"))
model.add(Dense(2, kernel_initializer="random_uniform",
                bias_initializer="ones",
                activation="softmax"))
#编译模型
model.compile(loss="binary_crossentropy", optimizer="adam",
              metrics=["accuracy"])
# 训练模型
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
#  评估模型
loss, accuracy = model.evaluate(X, Y, verbose=0)
print("准确度 = {:.2f}".format(accuracy))

输出结果：

准确度 = 0.79

（5）减少神经网络的参数量

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))
model.add(Dense(6, activation="relu"))
model.add(Dense(2, activation="softmax"))
#编译模型
model.compile(loss="binary_crossentropy", optimizer="adam",
              metrics=["accuracy"])
# 训练模型
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
#  评估模型
loss, accuracy = model.evaluate(X, Y, verbose=0)
print("准确度 = {:.2f}".format(accuracy))

输出结果：

准确度 = 0.82

       模型的准确率提升到0.82。

5、使用测试集与验证集

（1）将数据集分割成训练和测试数据集

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 分割训练和测试数据集
X_train, Y_train = X[:690], Y[:690]     # 训练数据前690条
X_test, Y_test = X[690:], Y[690:]       #测试数据后78条
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))
model.add(Dense(6, activation="relu"))
model.add(Dense(2, activation="softmax"))
# model.summary()  
# 编译模型
model.compile(loss="binary_crossentropy", optimizer="adam", 
              metrics=["accuracy"])
# 训练模型
model.fit(X_train, Y_train, epochs=150, batch_size=10, verbose=0)
# 评估模型
loss, accuracy = model.evaluate(X_train, Y_train, verbose=1)
print("训练数据集的准确度 = {:.2f}".format(accuracy))
loss, accuracy = model.evaluate(X_test, Y_test, verbose=1)
print("测试数据集的准确度 = {:.2f}".format(accuracy))

输出结果：

22/22 [==============================] - 0s 1ms/step - loss: 0.3768 - accuracy: 0.8275
训练数据集的准确度 = 0.83
3/3 [==============================] - 0s 3ms/step - loss: 0.6360 - accuracy: 0.7692
测试数据集的准确度 = 0.77

       构建的神经网络模型在训练集上的准确率达到0.83，在测试集上的准确率为0.77，所估计的模型可能会有过度拟合的现象，可能训练周期过多，为了找出最佳的训练周期，下面在训练集模型中使用验证集。

（2）在训练模型时使用验证集

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 分割训练和测试数据集
X_train, Y_train = X[:690], Y[:690]     # 训练数据前690条
X_test, Y_test = X[690:], Y[690:]       #测试数据后78条
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))
model.add(Dense(6, activation="relu"))
model.add(Dense(2, activation="softmax"))
# model.summary()  
# 编译模型
model.compile(loss="binary_crossentropy", optimizer="adam", 
              metrics=["accuracy"])
# 训练模型
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), 
          epochs=150, batch_size=10)
# 评估模型
loss, accuracy = model.evaluate(X_train, Y_train, verbose=1)
print("训练数据集的准确度 = {:.2f}".format(accuracy))
loss, accuracy = model.evaluate(X_test, Y_test, verbose=1)
print("测试数据集的准确度 = {:.2f}".format(accuracy))

输出结果：

Epoch 147/150
69/69 [==============================] - 0s 2ms/step - loss: 0.3591 - accuracy: 0.8478 - val_loss: 0.6565 - val_accuracy: 0.6795
Epoch 148/150
69/69 [==============================] - 0s 2ms/step - loss: 0.3587 - accuracy: 0.8435 - val_loss: 0.6629 - val_accuracy: 0.6795
Epoch 149/150
69/69 [==============================] - 0s 2ms/step - loss: 0.3573 - accuracy: 0.8493 - val_loss: 0.6555 - val_accuracy: 0.6795
Epoch 150/150
69/69 [==============================] - 0s 2ms/step - loss: 0.3584 - accuracy: 0.8406 - val_loss: 0.6616 - val_accuracy: 0.6667
22/22 [==============================] - 0s 1ms/step - loss: 0.3534 - accuracy: 0.8464
训练数据集的准确度 = 0.85
3/3 [==============================] - 0s 3ms/step - loss: 0.6616 - accuracy: 0.6667
测试数据集的准确度 = 0.67

      为了找出神经网络最佳的训练周期，下面绘制出训练和验证损失的趋势图：

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 分割训练和测试数据集
X_train, Y_train = X[:690], Y[:690]     # 训练数据前690条
X_test, Y_test = X[690:], Y[690:]       #测试数据后78条
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))
model.add(Dense(6, activation="relu"))
model.add(Dense(2, activation="softmax"))
# model.summary()  
# 编译模型
model.compile(loss="binary_crossentropy", optimizer="adam", 
              metrics=["accuracy"])
# 训练模型
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), 
          epochs=150, batch_size=10)
# 评估模型
loss, accuracy = model.evaluate(X_train, Y_train, verbose=0)
print("训练数据集的准确度 = {:.2f}".format(accuracy))
loss, accuracy = model.evaluate(X_test, Y_test, verbose=0)
print("测试数据集的准确度 = {:.2f}".format(accuracy))
#显示训练和验证损失的图表  
import matplotlib.pyplot as plt

loss = history.history["loss"]
epochs = range(1, len(loss)+1)
val_loss = history.history["val_loss"]
plt.plot(epochs, loss, "bo", label="Training Loss")
plt.plot(epochs, val_loss, "r", label="Validation Loss")
plt.title("Training and Validation Loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend()
plt.savefig("squares1.png",
            bbox_inches ="tight",
            pad_inches = 1,
            transparent = True,
            facecolor ="w",
            edgecolor ='w',
            dpi=300,
            orientation ='landscape')

输出结果：

# 显示训练和验证准确度
acc = history.history["accuracy"]
epochs = range(1, len(acc)+1)
val_acc = history.history["val_accuracy"]
plt.plot(epochs, acc, "b-", label="Training Acc")
plt.plot(epochs, val_acc, "r--", label="Validation Acc")
plt.title("Training and Validation Accuracy")
plt.xlabel("Epochs")
plt.ylabel("Accuracy")
plt.legend()
plt.savefig("squares2.png",
            bbox_inches ="tight",
            pad_inches = 1,
            transparent = True,
            facecolor ="w",
            edgecolor ='w',
            dpi=300,
            orientation ='landscape')

输出结果：

        通过上图可以发现，模型在训练集的准确率逐渐上升，但在验证集上约在10次训练周期之后，准确率基本持平。下面将训练周期改为10，绘制训练与验证损失趋势图。

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset) 
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
# One-hot编码
Y = to_categorical(Y)
# 分割训练和测试数据集
X_train, Y_train = X[:690], Y[:690]     # 训练数据前690条
X_test, Y_test = X[690:], Y[690:]       #测试数据后78条
# 定义模型
model = Sequential()
model.add(Dense(10, input_shape=(8,), activation="relu"))
model.add(Dense(6, activation="relu"))
model.add(Dense(2, activation="softmax"))
# model.summary()  
# 编译模型
model.compile(loss="binary_crossentropy", optimizer="adam", 
              metrics=["accuracy"])
# 训练模型
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), 
          epochs=10, batch_size=10)
# 评估模型
loss, accuracy = model.evaluate(X_train, Y_train, verbose=0)
print("训练数据集的准确度 = {:.2f}".format(accuracy))
loss, accuracy = model.evaluate(X_test, Y_test, verbose=0)
print("测试数据集的准确度 = {:.2f}".format(accuracy))
#显示训练和验证损失的图表  
import matplotlib.pyplot as plt

loss = history.history["loss"]
epochs = range(1, len(loss)+1)
val_loss = history.history["val_loss"]
plt.plot(epochs, loss, "bo", label="Training Loss")
plt.plot(epochs, val_loss, "r", label="Validation Loss")
plt.title("Training and Validation Loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend()
plt.savefig("squares1.png",
            bbox_inches ="tight",
            pad_inches = 1,
            transparent = True,
            facecolor ="w",
            edgecolor ='w',
            dpi=300,
            orientation ='landscape')

输出结果：

69/69 [==============================] - 0s 2ms/step - loss: 0.4843 - accuracy: 0.7696 - val_loss: 0.5074 - val_accuracy: 0.7564
Epoch 8/10
69/69 [==============================] - 0s 2ms/step - loss: 0.4751 - accuracy: 0.7681 - val_loss: 0.5034 - val_accuracy: 0.7564
Epoch 9/10
69/69 [==============================] - 0s 2ms/step - loss: 0.4685 - accuracy: 0.7725 - val_loss: 0.5014 - val_accuracy: 0.7692
Epoch 10/10
69/69 [==============================] - 0s 2ms/step - loss: 0.4636 - accuracy: 0.7725 - val_loss: 0.4993 - val_accuracy: 0.7692
训练数据集的准确度 = 0.78
测试数据集的准确度 = 0.77

 6、神经网络模型预测

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

np.random.seed(10)  
# 载入糖尿病数据集
df = pd.read_csv('E:\工作\硕士\博客\博客31-使用Keras构建分类问题的MLP神经网络——用于糖尿病预测\diabetes.csv')
dataset = df.values
np.random.shuffle(dataset)  # 用乱数打乱数据
# 分割成特征数据和标签数据
X = dataset[:, 0:8]
Y = dataset[:, 8]
# 特征标准化
X -= X.mean(axis=0)
X /= X.std(axis=0)
#分割训练和测试数据集
X_train, Y_train = X[:690], Y[:690]     # 训练数据前690条
X_test, Y_test = X[690:], Y[690:]       #  测试数据后78条
#定义模型
model = Sequential()
model.add(Dense(8, input_shape=(8,), activation="relu"))
model.add(Dense(8, activation="relu"))
model.add(Dense(1, activation="sigmoid"))
#  编译模型
model.compile(loss="binary_crossentropy", optimizer="adam", 
              metrics=["accuracy"])
# 训练模型
model.fit(X_train, Y_train, epochs=10, batch_size=10, verbose=0)
# 评估模型
loss, accuracy = model.evaluate(X_train, Y_train, verbose=0)
print("训练数据集的准确度 = {:.2f}".format(accuracy))
loss, accuracy = model.evaluate(X_test, Y_test, verbose=0)
print("测试数据集的准确度 = {:.2f}".format(accuracy))
# 测试数据集的预测值
Y_pred = model.predict(X_test, batch_size=10, verbose=0)
print(Y_pred[0])

输出结果：

训练数据集的准确度 = 0.78
测试数据集的准确度 = 0.77
[0.02079517]

7、存储与载入神经网络模型

        在完成神经网络训练后，可以进行存储神经网络的模型和权重，后面能够直接载入神经网络模型与权重进行预测。

（1）分开存储模型结构与权重

#储存模型结构  
json_str = model.to_json()
with open("Ch5_5_1Model.config", "w") as text_file:
    text_file.write(json_str)
#储存模型权重  
model.save_weights("Ch5_5_1Model.weight")

 （2）同时存储模型结构与权重

# 存储模型结构和权重
model.save("Ch5_5_1a.h5")

（3）载入神经网络模型结构与权重

# 载入模型结构
from tensorflow.keras.models import load_model

model = Sequential()
model = load_model("Ch5_5_1a.h5")
#  编译模型
model.compile(loss="binary_crossentropy", optimizer="adam", 
              metrics=["accuracy"])

更多优质内容持续发布中，请移步主页查看。

若有问题可邮箱联系：1736732074@qq.com 

博主的WeChat:TCB1736732074

   点赞+关注,下次不迷路！文章来源地址https://www.toymoban.com/news/detail-450012.html

到了这里，关于使用Keras构建分类问题的MLP神经网络——用于糖尿病预测的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！