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

news2024/11/23 19:05:01

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

         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

输出结果：

 PregnanciesGlucoseBloodPressureSkinThicknessInsulinBMIDiabetesPedigreeFunctionAgeOutcome
061487235033.60.627501
11856629026.60.351310
28183640023.30.672321
318966239428.10.167210
40137403516843.12.288331
..............................
76310101764818032.90.171630
76421227027036.80.340270
7655121722311226.20.245300
7661126600030.10.349471
7671937031030.40.315230

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')

输出结果：

 

fd97627898494cbbb61f142f3a5a0cc9.png

# 显示训练和验证准确度
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')

输出结果：

1687681bead84c16a25dcc30d5bc0dd1.png

        通过上图可以发现，模型在训练集的准确率逐渐上升，但在验证集上约在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

f1e6bd974dfc46d0b126822cac056bcf.png

 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"])

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

   点赞+关注,下次不迷路！

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/553266.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

云计算基础——云计算主流解决方案

云计算基础——云计算主流解决方案

原数据：描述数据的数据，不可分割。 7.1 Google云计算技术 7.1.1 GCP Google 将这些技术组合在一起，运用这些从自身业务需求出发，逐步发展起来的一系列云计算技术和工具搭建起了其面向商业的云计算解决方案Google Cloud Platform (…
阅读更多...
【数据湖架构】Azure Data Lake数据湖指南

【数据湖架构】Azure Data Lake数据湖指南

数据湖漫游指南 文件大小和文件数文件格式分区方案使用查询加速我如何管理对我的数据的访问？我选择什么数据格式？如何管理我的数据湖成本？如何监控我的数据湖？ADLS Gen2 何时是您数据湖的正确选择？设计数据湖的关键考虑…
阅读更多...
Vue.observable的理解

Vue.observable的理解

一、Observable 是什么 Observable 翻译过来我们可以理解成可观察的 先来看其在Vue中的定义 Vue.observable，让一个对象变成响应式数据。Vue 内部会用它来处理 data 函数返回的对象 返回的对象可以直接用于渲染函数和计算属性内，并且会在发生变更时触发…
阅读更多...
PDF.js实现按需分片加载pdf文件-包含前后端开发源码和详细开发教程

PDF.js实现按需分片加载pdf文件-包含前后端开发源码和详细开发教程

PDF.js实现按需加载pdf文件 说明前言前端项目分片加载的效果前端项目结构前端核心代码项目运行与访问 后端项目项目结构核心代码实现注意事项 项目源码 说明 本文主要是介绍pdf.js的前后端项目的实现，包含可直接运行的源码。由于本人偏向于后端开发，因此…
阅读更多...
Redis设计逻辑及生产部署问题整理

Redis设计逻辑及生产部署问题整理

数据结构 redis数据结构包括：简单动态字符串SDS、链表、字典、跳跃表、整数组合、压缩列表。 SDS：在增加/减少字符串时不会频繁进行内存充分配，采用了空间预分配和惰性空间释放两种优化策略。 链表：链表节点使用void*保存节点值&a…
阅读更多...
Stable Diffusion Web-UI 安装指南

Stable Diffusion Web-UI 安装指南

Stable DIffusion 是 Stability.AI 开源的 text-to-image 模型，目前类似产品有 Midjourney 以及 OpenAI 的 DELL-2 ；从AI绘画效果上来说，Midjourney 目前公认是最好的；但从模型的可玩性和发展潜力来看，个人观点来看&am…
阅读更多...
【009】C++数据类型之转义字符和类型转换

【009】C++数据类型之转义字符和类型转换

C数据类型之转义字符和类型转换 引言一、转义字符1.1、概念1.2、八进制转义1.3、十六进制转义 二、类型转换2.1、自动类型转换原则2.2、强制类型转换 三、C新特性中类型转换的扩展3.1、隐式类型转换3.2、显式类型转换 总结 引言 💡 作者简介：专注于C/C高…
阅读更多...
Packet Tracer – 配置单臂路由器 VLAN 间路由

Packet Tracer – 配置单臂路由器 VLAN 间路由

Packet Tracer – 配置单臂路由器 VLAN 间路由 地址分配表 设备 接口 IPv4 地址 子网掩码 默认网关 R1 G0/0.10 172.17.10.1 255.255.255.0 不适用 G0/0.30 172.17.30.1 255.255.255.0 不适用 PC1 NIC 172.17.10.10 255.255.255.0 172.17.10.1 PC2 NIC 1…
阅读更多...
游乐园里，一边带小孩，一边写代码，分享一些有趣好玩儿的嵌入式软硬件资讯...

游乐园里，一边带小孩，一边写代码，分享一些有趣好玩儿的嵌入式软硬件资讯...

作者：晓宇，排版：晓宇 微信公众号：芯片之家（ID：chiphome-dy） 01 边带小孩边写代码 以前觉得，自己下班后都还有大把时间，下班了回到家还能再干个两三个小时，学…
阅读更多...
定义运营系统架构

定义运营系统架构

介绍 供应商提供的信息系统随着新功能和实施策略不断发展。可用选项的复杂性和多样性使许多公司难以充分讨论和比较可能满足或不满足其要求的替代方案。 供应商通常会推广由公司或个人工具箱中的产品或解决方案支持的架构。如果公司对其运营系统的架构没有清晰的愿景&#xf…
阅读更多...
第九章：C语言的简单结构体

第九章：C语言的简单结构体

作为一个人有什么关于人的属性呢？简单的梳理一下，人的属性有自己的名字，年龄，身高，体重...。当然关于人的属性还有很多，当我们C语言来描述一下人的属性，就需要定义多个变量，那我们这…
阅读更多...
21天学会C++：Day4----函数重载

21天学会C++：Day4----函数重载

CSDN的uu们，大家好。这里是C入门的第四讲。 座右铭：前路坎坷，披荆斩棘，扶摇直上。 博客主页： 姬如祎 收录专栏：C专题 目录 1. 知识引入 2. 函数重载的知识点 2. 为什么C语言不支持函数重载而C支持呢&…
阅读更多...
springboot贫困生勤工助学评定管理系统

springboot贫困生勤工助学评定管理系统

本系统尝试使用springboot在网上架构一个动态的贫困生管理系统，以使每一用户在家就能通过系统来进行贫困生管理。 Spring Boot 是 Spring 家族中的一个全新的框架，它用来简化Spring应用程序的创建和开发过程。也可以说 Spring Boot 能简化我们之前采用S…
阅读更多...
数据结构学习记录——图应用实例-拯救007（问题描述、解题思路、伪代码解读、C语言算法实现）

数据结构学习记录——图应用实例-拯救007（问题描述、解题思路、伪代码解读、C语言算法实现）

目录 问题描述 解题思路 伪代码 总体算法 DFS算法 伪代码解读 总体算法 DFS算法 具体实现（C语言） 问题描述 在老电影“007之生死关头”（Live and Let Die）中有一个情节，007被毒贩抓到一个鳄鱼池中心的小岛…
阅读更多...
Matlab - Plot in plot（图中画图）

Matlab - Plot in plot（图中画图）

Matlab - Plot in plot（图中画图） 这是在MATLAB中创建一个嵌入式图形的示例，可以在另一个图形中显示。 与MATLAB中的“axes”函数相关。 Coding % Create data t linspace(0,2*pi); t(1) eps; y sin(t);% Place axes at (0.1,0.1) with w…
阅读更多...
学系统集成项目管理工程师（中项）系列24a_信息系统集成专业技术知识（上）

学系统集成项目管理工程师（中项）系列24a_信息系统集成专业技术知识（上）

1. 信息系统的生命周期 1.1. 【19下选10】 1.2. 立项 1.2.1. 形成《需求规格说明书》并确定立项 1.2.1.1. 【21上选11】 1.3. 开发 1.3.1. 【22下选10】 1.3.2. 以立项阶段所做的需求分析为基础，进行总体规划。之后，通过系统分析、系统设计、系统…
阅读更多...
ChatGPT4 镜像网站推荐

ChatGPT4 镜像网站推荐

文章目录 1. TomChat2. Ai Doge3. 二狗问答4. 小莓用AI5. Ora6. ChatGPT镜像7. ChatGPT镜像8. VIVI-AI9. 小杰AI10. ChatGPT Web11. AIchatOS 什么是ChatGPT? ChatGPT，全称：聊天生成预训练转换器（英语：Chat Generative Pre-train…
阅读更多...
辅助驾驶功能开发-功能规范篇(16)-2-领航辅助系统NAP-HMI人机交互

辅助驾驶功能开发-功能规范篇(16)-2-领航辅助系统NAP-HMI人机交互

书接上回 2.3.7HMI人机交互 2.3.7.1显示 (1)图标 序号 图标状态 （图形、颜色供参考） 含义说明 备注 1 辅助驾驶功能READY
阅读更多...
Winform窗体利用WebApi接口实现ModbusTCP数据服务

Winform窗体利用WebApi接口实现ModbusTCP数据服务

在上位机开发过程中，有时候会遇到需要提供数据接口给MES或者其他系统，今天跟大家分享一下，如何在Winform等桌面应用程序中，开发WebApi接口，提供对外modbus设备的数据服务。通讯模型是： 为了更好地演示应用场…
阅读更多...
华为OD机试真题 Java 实现【简单的解压缩算法】【2023Q1 200分】

华为OD机试真题 Java 实现【简单的解压缩算法】【2023Q1 200分】

一、题目描述 现需要实现一种算法，能将一组压缩字符串还原成原始字符串，还原规则如下： 1、字符后面加数字N，表示重复字符N次。例如：压缩内容为A3，表示原始字符串为AAA。 2、花括号中的字符串加数字N&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023