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

news2024/11/20 11:29:27

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

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

输出结果：

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

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

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

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

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

相关文章

基于Springboot的漫画网站

基于Springboot的漫画网站

开发技术介绍 B/S架构 B/S结构是目前使用最多的结构模式，它可以使得系统的开发更加的简单，好操作，而且还可以对其进行维护。使用该结构时只需要在计算机中安装数据库，和一些很常用的浏览器就可以了。浏览器就会与数据库进行信息…
阅读更多...
chatgpt赋能Python-python3_7_2怎么安装

chatgpt赋能Python-python3_7_2怎么安装

Python 3.7.2 安装指南 Python 是一种广泛使用的计算机编程语言，在科学计算、数据处理、网络编程、人工智能等领域都有广泛应用。而 Python 3.7.2 是 Python 3 系列的一个重要版本。在本文中，我们将介绍如何在各种操作系统上安装 Python 3.7.2。 安装步…
阅读更多...
chatgpt赋能Python-python3_8降到3_7

chatgpt赋能Python-python3_8降到3_7

Python 3.8降级到3.7：这是否是一个明智的决策？ Python 3.8是Python语言的最新版本，拥有许多显著的改进和新功能。然而，许多开发者们发现3.8版本并非适用于每个项目，因此他们可能会想要降级回Python 3.7。本文将探讨降…
阅读更多...
5.19黄金持续下跌能否抄底做多？后市如何布局

5.19黄金持续下跌能否抄底做多？后市如何布局

近期有哪些消息面影响黄金走势？今日黄金多空该如何研判？ ​黄金消息面解析：周四(5月18日)，美市盘中，现货黄金价格跌创4月21日以来新低至1952.01美元/盎司，迹象表明华府和国会可能就提高美国债务上限达成协…
阅读更多...
使用CGImageRef创建图片及实现图片区域裁剪（附源码）

使用CGImageRef创建图片及实现图片区域裁剪（附源码）

一 CGImageRef和UIImage的互相转化 CGImageRef 是一个结构体指针，通过CGImageRef可以获得UIImage的所有参数，比如像素宽高、颜色通道位深、像素点位深、像素点字节排列及读取顺序等信息，CGImageRef与UIImage的互相转化如下： UII…
阅读更多...
GEE：计算每个斑块（超像素、对象）内的特征/统计值

GEE：计算每个斑块（超像素、对象）内的特征/统计值

作者：CSDN @ _养乐多_ 在遥感图像分析中，斑块（或对象）是指具有相似像素值的区域，通常代表地物或景观要素。通过计算斑块的特征，我们可以获得关于这些区域的有用信息，从而进行更深入的分析和研究。在本文中，我们将介绍如何使用Google Earth Engine（GEE）平台计算每个斑…
阅读更多...
深入理解Java虚拟机：JVM高级特性与最佳实践-总结-7

深入理解Java虚拟机：JVM高级特性与最佳实践-总结-7

深入理解Java虚拟机：JVM高级特性与最佳实践-总结-7 类文件结构概述无关性的基石 虚拟机类加载机制概述类加载的时机 类文件结构 代码编译的结果从本地机器码转变为字节码，是存储格式发展的一小步，却是编程语言发展的一大步 概述 我们写的程…
阅读更多...
JavaScript实现计算1-10之间的乘积的数的代码

JavaScript实现计算1-10之间的乘积的数的代码

以下为实现计算1-10之间的乘积的数的程序代码和运行截图 目录 前言 一、实现计算1-10之间的乘积 1.1 运行流程及思想 1.2 代码段 1.3 JavaScript语句代码 1.4 运行截图 前言 1.若有选择，您可以在目录里进行快速查找； 2.本博文代码可以根据题目要…
阅读更多...
chatgpt赋能Python-python3_7怎么换行

chatgpt赋能Python-python3_7怎么换行

Python 3.7 的换行方法详解 Python 是一种广泛应用的高级编程语言，它具有简单易学，功能强大，可移植性好等特点，深受全球开发者的喜爱。其中，每个程序员在编写代码时最常用的是打印输出函数，而其中换行更是…
阅读更多...
[c++] enum和string相互转换

[c++] enum和string相互转换

enum和string相互转换 简介满足的需求code使用方法可优化点 参考链接 简介 原理还是很朴素的方法，只是用宏省略了重复代码，降低维护难度； // enum to string std::string enum2Str(Color c) {switch(c){case RED: return "RED";c…
阅读更多...
Pytorch从零开始实现Vision Transformer (from scratch)

Pytorch从零开始实现Vision Transformer (from scratch)

Pytorch从零开始实现Vision Transformer 前言一、Vision Transformer架构介绍1. Patch Embedding2. Multi-Head Attention3. Transformer BlockFeed Forward 二、预备知识1. Einsum2. Einops 三、Vision Transformer代码实现0. 导入库1. Patch Embedding2. Residual & Norm…
阅读更多...
Ethereum以太坊事件日志查询参数

Ethereum以太坊事件日志查询参数

目录 一、Ethereum事件日志查询参数二、需求三、实现四、其他 一、Ethereum事件日志查询参数 addresses：合约地址列表fromBlock：开始区块toBlock：结束区块topics：主题数组blockhash：区块哈希，优先级高于fr…
阅读更多...
chatgpt赋能Python-python3_9_1怎么用

chatgpt赋能Python-python3_9_1怎么用

Python3.9.1是什么？ Python是一种高级、动态、解释型语言，具有优雅简洁、易于学习和阅读、功能丰富的特点。Python 3.9.1是Python编程语言的一个版本，于2020年12月21日正式发布，是Python 3的最新稳定版本。它包含了许多新的特性、…
阅读更多...
chatgpt赋能Python-python3_7降级3_6

chatgpt赋能Python-python3_7降级3_6

Python 3.7降级3.6：为什么？如何做？ 如果你是一个认真的Python开发者，你可能会对Python 3.7的某些改进感到兴奋。但是，在某些情况下，你可能需要将Python降级到3.6版本。在这篇文章中，我们将探讨…
阅读更多...
网吧管理系统修正

网吧管理系统修正

文章目录 网吧管理系统修正1. 改动1：上机缴费2. 改动2：下机超时计费3. 改动3：注销强制下机操作4. 改动4：计费标准数据的获取与释放 网吧管理系统修正 Carry文件中，打开文件忘记关闭了，虽然C语言中不会报错…
阅读更多...
【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第八届

【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第八届

文章目录 前言一、题目二、模块初始化三、代码实现interrupt.h:interrupt.c:main.h:main.c: 四、完成效果五、总结 前言 学习完了所有模块之后(LIS302考点取消了, 扩展板也找不到了，如果你能找到可能你不是在十四届省赛后买的扩展板), 跟省赛一样，先拿第…
阅读更多...
这个屏幕录制太好用了！

这个屏幕录制太好用了！

哈喽，大家好！今天给各位小伙伴测试了一屏幕录制的小工具——ApowerREC。它是一款专业同步录制屏幕画面及声音的录屏软件。界面简洁，操作简单，支持实时编辑屏幕录像、创建计划任务、录制摄像头高清视频等功能。废话不多说&#xff…
阅读更多...
汇编九、直接地址与寄存器、ROM和RAM

汇编九、直接地址与寄存器、ROM和RAM

1、直接地址与寄存器 1.1、A和ACC (1)A是没有地址的，可以当作寄存器使用。 (2)ACC是有地址的，地址为E0H(查数据手册)。 (3)如果使用压栈操作，要用ACC。因为ACC可当做直接地址。 (4)如果使用位操作，要用ACC。因为ACC可位寻址。…
阅读更多...
总结855

总结855

学习目标： 月目标：5月（张宇强化前10讲，背诵15篇短文，熟词僻义300词基础词） 周目标：张宇强化前3讲并完成相应的习题并记录，英语背3篇文章并回诵 每日必复习（5分钟&#…
阅读更多...
chatgpt赋能Python-python3_9_2怎么安装

chatgpt赋能Python-python3_9_2怎么安装

Python3.9.2的安装指南 Python是一种高级编程语言，广泛应用于各种领域，从数据科学到机器学习到Web应用程序。Python具有易学性和通用性，因此成为众多开发人员的首选语言。此篇文章将指导您如何安装Python3.9.2版本。 为什么选择Python3.9.2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023