【论文模型复现】深度学习、地质流体识别、交叉学科融合？什么情况，让我们来看看

文献：蓝茜茜,张逸伦,康志宏.基于深度学习的复杂储层流体性质测井识别——以车排子油田某井区为例[J].科学技术与工程,2020,20(29):11923-11930.

本文目录

一、前言
二、文献阅读-基于深度学习的复杂储层流体性质测井识别
- 2.1 摘要
- 2.2 当前研究不足
- 2.3 本文创新
- 2.4 论文中图表分析
- 2.5 论文框架总结
- 2.6 本文存在不足与研究展望
三.模型复现-从实现的角度
- 实现1—数据集样本优化
- - （1）数据集介绍
  - （2）混合采样技术
  - - 1）对大样本类下采样
    - 2）对小样本类上采样
- 实现2—神经网络结构的优化
- 实现3—论文中的图表
- - （1）表1
  - （2）表2
  - （3）图5
四、最后

一、前言

本文复现一篇典型应用深度学习模型进行识别分类任务的论文。
当然，作为计算机的学生，对这篇论文的理解会基于计算机领域角度，侧重深度学习。而论文第2部分-区域概况与测井响应特征、后文3.2节中识别结果分析，包含了大量地质资料特征分析与解释，这些专业知识是我们计算机学生不具备的，却是做交叉学科融合的同学更应该重点学习的，也是一大亮点与难点。
废话不多唠，进入正题。

二、文献阅读-基于深度学习的复杂储层流体性质测井识别

2.1 摘要

先看一下该论文的摘要部分，对论文有个宏观认识，主要内容已标出：

在这里插入图片描述

图2.1 论文摘要部分

(1) 目的

解决复杂储层流体性质识别率低、严重依赖人工经验的问题，提出一种优化深度神经网络识别流体性质的方法。

(2) 方法

将深度学习方法引入到复杂储层流体识别中；
组合优化常规神经网络，提高网络模型的性能；
实验对比了4种组合优化方法对模型性能的影响。

(3) 创新

利用混合采用技术进行样本数据集均衡化，避免样本不均衡；
在网络中使用 ReLu + Softmax激活函数，提高的模型多分类问题的准确率；
在网络中使用 Dropout正则化 ，有效防止模型过拟合。

(4) 结果与结论

优化后的模型对 4 种性质流体识别准确率达82. 7%，单一流体识别率也均较高。本文使用的组合优化方法的识别效果明显优于其他方法，提高了对小样本类别的识别率。

2.2 当前研究不足

仅利用单一的测井资料或者储层参数无法准确识别储层流体性质。
传统识别方法综合多种测井资料及储层参数解释为主要识别手段，智能化程度低。
现常用的 BP 神经网络等识别方法网络结构简单，只能挖掘到样本浅层的特征信息。

2.3 本文创新

新方法-引入深度学习方法研究流体性质识别；
新模型-优化常规神经网络；
新结果-对比多种组合优化方法对模型的影响。

2.4 论文中图表分析

图1 单个神经元前馈传递过程。神经网络基础原理。
图2 不同类型的激活函数。神经网络基础原理。
图3 Dropout正则化示意图。神经网络基础原理。Dropout正则化 模型训练过程中按照一定比例随机丢弃一些“神经元”，每一次训练的网络结构均不同，降低了网络结构复杂的关联性，学习到的样本特征更具鲁棒性，从而避免过拟合。
图4 深度神经网络结构。典型多层神经网络，输入9个特征参数—输出4个类别概率。
图5 样本集数量分布。数据集样本数量分布。
图6 人工解释结论与模型预测结果对比。模型预测结果对比。
图7 不同优化方法的识别效果F值对比。本文选用的组合方法最优。
表1 目标区测井资料统计。关于数据集的统计信息。
表2 识别结果混淆矩阵。混淆矩阵是神经网络多分类器中常用的评价手段。评价模型对不同类别的识别效果。

2.5 论文框架总结

案例：一个案例，对车排子油田某井区12 口井储层流体性质识别。
方法：对样本数据和神经网络结构进行优化，建立储层测井参数与流体性质之间的神经网络模型。

影响因素：

数据集样本均衡化方法；
神经网络模型中激活函数的组合；
避免模型过拟合方法。

评价指标：

划分大小样本标准：每种类别中样本数的平均值 k；
模型性能评价指标：精准率( Precision ) ，召回率( Recall ) ，F 值( F-measure ) 。

2.6 本文存在不足与研究展望

组合优化方法对比，是简单的“正反面”形式的方法组合对比，没有与其它优化模型方法对比；
本文是单一常规神经网络模型的应用，没有与其它经典模型进行对比；
本文验证了基于优化组合策略的深度神经网络方法在实际应用中的优越性，为其它模型优化提供了一种思路。

三.模型复现-从实现的角度

实现1—数据集样本优化

（1）数据集介绍

由于论文的原始数据集无法获取，在复现过程中选用葡萄酒（WINE）数据集。这两个数据集（论文数据集和葡萄酒数据集）都可以完成分类任务。

Wine数据集：数据是对生长在意大利同一地区但来自三个不同品种的葡萄酒进行化学分析的结果，数据集中确定了三种葡萄酒中13种成分的含量。即有3个类别，13种特征参数（葡萄酒的13种成分含量）。数据集下载：https://download.csdn.net/download/mdong9/90005091

每个样本的第一个属性是类别（1或2或3），其余按顺序均有如下13个属性：

Alcohol
Malic acid
Ash
Alcalinity of ash
Magnesium
Total phenols
Flavanoids
Nonflavanoid phenols
Proanthocyanins
Color intensity
Hue
OD280/OD315 of diluted wines
Proline

在这里插入图片描述

图3.1 Wine数据集部分

（2）混合采样技术

论文中的混合采样技术其实就是一种解决不同类别中样本数不平衡策略。比如Wine数据集中，三种葡萄酒的样本数分别是59（label=1）、71（label=2）、48（label=3），很明显第2类葡萄酒样本数最多，第三类最少，夸张的讲这就是一个样本数不均衡的数据集（其实还好）。

而混合采样技术来解决样本不均衡问题，思路是：

计算每类中样本数的平均值 k，以k 为分界，大于 k 的类别为大样本类，反之则为小样本类。
对于大样本类下采样，下采样过程中采用 K-means 聚类算法减少多样本类别的样本数。
对于小样本类上采样，上采样过程中采用 Smote 算法增加少样本类别的样本数。

经过上述步骤的混合采样后每类样本大小均为 k，原始不均衡样本数据集就变成了均衡样本数据集。

知道思路后，下面就一步步来将Wine数据集变成三类样本数平衡的数据集。在Wine数据集中，平均值 $k = (59 + 71 + 48) /3 = 59.33$ ，取整后刚好是类别1的样本数59，则类别2是大样本类，类别3是小样本类。

1）对大样本类下采样

对于大样本类，K-means 算法将样本聚为 k类，仅保留距离每个聚类中心最近的一个样本，聚类后的 k 个样本在降采样的基础上仍保留了原始数据的全部特征。

方便理解，这里给出一个下采样的例子：

"""
在这个示例中，我们将通过 K-means 聚类算法将一组多样本类别减少到 5 个类别。
"""
from sklearn.cluster import KMeans  
import numpy as np  
  
# 假设你有一个多样本类别的数据集，这里我们随机生成一些数据作为例子  
X = np.random.rand(100, 10)  # 100个样本，每个样本有10个特征  
  
# 设置聚类的数量  
n_clusters = 5  
  
# 创建 KMeans 对象  
kmeans = KMeans(n_clusters=n_clusters, random_state=0)  
  
# 进行聚类  
y_kmeans = kmeans.fit_predict(X)  
  
# 输出结果  
print("Cluster centers:")  
print(kmeans.cluster_centers_)  
print("\nLabels:")  
print(y_kmeans)

# 获取每个聚类的中心
cluster_centers = kmeans.cluster_centers_

# 找到每个样本到其所属聚类中心的距离
distances = np.linalg.norm(X[:, np.newaxis] - cluster_centers, axis=2)

# 对于每个聚类，找到距离其中心最近的样本的索引
nearest_indices = np.argmin(distances, axis=0)

# 输出结果
print("Nearest indices:")
print(nearest_indices)

输出结果：

Cluster centers:
[[0.56870198 0.33340756 0.74812813 0.50208413 0.80879522 0.75691573
  0.28995045 0.58835733 0.53986648 0.52429174]
 [0.24773952 0.29674511 0.39650162 0.65400547 0.28843251 0.55949072
  0.48438144 0.39485121 0.65630189 0.31650354]
 [0.69576183 0.38668387 0.51523792 0.71425985 0.50791891 0.27670777
  0.67150517 0.69364469 0.50809951 0.71037073]
 [0.48304122 0.75197772 0.21397284 0.43701465 0.61980822 0.61062874
  0.49566418 0.50509653 0.42412438 0.71218052]
 [0.65337793 0.6093431  0.78001226 0.25850624 0.32640479 0.31990074
  0.44351127 0.52801434 0.55983808 0.43707075]]

Labels:
[0 2 1 0 0 1 3 2 4 0 0 0 2 2 4 1 2 1 1 3 0 0 1 3 3 0 3 0 0 4 0 4 3 0 1 1 1
 4 4 4 4 2 3 2 2 3 2 1 1 0 0 3 3 3 1 3 4 1 3 3 4 1 4 2 4 0 2 4 4 4 0 2 1 0
 3 0 3 2 1 2 1 4 3 3 2 2 4 2 3 0 1 3 0 4 2 4 1 2 2 4]
Nearest indices:
[10 35 46  6 29]

2）对小样本类上采样

对于小样本类，Smote 算法以欧式距离为标准计算每个样本到其他所有样本的距离，并得到距离其最近的 p 个样本，即“p 近邻”。根据样本不均衡比例确定上采样倍率，对于每个少数类样本 $n_i$ 从其“p 近邻”中随机选择若干个样本n分别与原样本按照公式构建新样本 $n_{new}$ 。

公式： $n_{new} = n_i + R(n - n_i)$ ，Ｒ为一个均匀分布在0 ～ 1间的随机数。

Smote 通过创建合成样本来增加少数类的数量。Smote 就是使用欧式距离作为距离度量标准的。在Smote 算法中，首先为每个少数类样本找到其k个最近邻样本，然后从这些邻居中随机选择一个，最后通过插值生成一个新的合成样本。

方便理解，这里给出一个上采样的例子：

from imblearn.over_sampling import SMOTE  
from sklearn.datasets import make_classification  
from sklearn.model_selection import train_test_split  
from sklearn import metrics  
  
# 创建一个不平衡的数据集  
X, y = make_classification(n_classes=2, class_sep=2,   
                           weights=[0.1, 0.9], n_informative=3,   
                           n_redundant=1, flip_y=0, n_features=20,   
                           n_clusters_per_class=1, n_samples=1000, random_state=10)  
  
# 数据划分为训练集和测试集  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 输出原始数据集大小
print('Original dataset shape %s' % Counter(comb_y))
  
# 初始化SMOTE实例  
smote = SMOTE(random_state=42)  
  
# 对训练集进行过采样处理  
X_res, y_res = smote.fit_resample(X_train, y_train)  
  
# 输出重采样后的数据集大小  
print('Resampled dataset shape %s' % Counter(y_res))

输出结果：

Original dataset shape Counter({1: 628, 0: 72})
Resampled dataset shape Counter({1: 628, 0: 628})

理解了上述两个步骤后，我们来完成对Wine数据集的混合采样优化，代码如下：

# 导入需要用到的包
from collections import Counter

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from imblearn.over_sampling import SMOTE
from sklearn.model_selection import train_test_split
from sklearn.cluster import KMeans

# 1.数据集
# 读取Excel文件
df = pd.read_excel('./dataset/wine.xlsx')
wine = df

# 2.数据集样本优化，混合采样技术
# 在Wine数据集中，平均值k = (59 + 71 + 48) / 3 = 59.33，取整后刚好是类别1的样本数59，则类别2是大样本类，类别3是小样本类。

# 2.1 对类别2的样本下采样----KMeans
mask = (wine['label'] == 2)
cls_2 = wine.loc[mask]
print(cls_2)
cls_2_X = np.array(cls_2.iloc[:, 1:])  # 类别2的样本

# 设置聚类的数量
n_clusters = 59  # 将样本聚为k类，仅保留距离每个聚类中心最近的一个样本
# 创建 KMeans 对象
kmeans = KMeans(n_clusters=n_clusters, random_state=0)
# 进行聚类
labels = kmeans.fit_predict(cls_2_X)  # 对数据进行聚类，并返回每个样本的类别标签
# 获取每个聚类的中心
cluster_centers = kmeans.cluster_centers_
# 找到每个样本到其所属聚类中心的距离
# print(cls_2_X[:, np.newaxis])
distances = np.linalg.norm(cls_2_X[:, np.newaxis] - cluster_centers, axis=2)
# 对于每个聚类，找到距离其中心最近的样本的索引
nearest_indices = np.argmin(distances, axis=0)

# 输出结果
print("Nearest indices:")
print(nearest_indices + 59)  # 每个聚类中心最近的一个样本的索引，+59得到原始索引

# 新类别2样本
nearest_idx = nearest_indices + 59
new_cls_2 = wine.iloc[nearest_idx, :]

# 2.2 对类别3的样本上采样----SMOTE
mask = (wine['label'] == 3)
cls_3 = wine.loc[mask]
cls_3_X = np.array(cls_3.iloc[:, 1:])  # 类别3的样本

mask = (wine['label'] == 1)
cls_1 = wine.loc[mask]  # 类别1

comb_dataset = pd.concat([cls_1, new_cls_2, cls_3])  # 组合样本

comb_X = comb_dataset.iloc[:, 1:]
comb_y = comb_dataset.label
print('Original dataset shape %s' % Counter(comb_y))

# 初始化SMOTE实例
smote = SMOTE(random_state=42)

# 对数据集进行过采样处理
X_res, y_res = smote.fit_resample(comb_X, comb_y)

# 输出重采样后的数据集大小
print('Resampled dataset shape %s' % Counter(y_res))

# 组合出优化后的数据集
new_dataset = X_res.assign(label=y_res)

# 保存优化后的数据集
new_dataset.to_excel('./dataset/new_wine.xlsx', index=False)

Wine数据集经混合采样优化后达到均衡，三类样本数为59(label=1)、59(label=2)、59(label=3)。到这里就成功复现了论文中的混合采样技术。

实现2—神经网络结构的优化

从代码实现的角度对本文中储层流体性质识别模型进行复现，对该模型的学习完全可以作为深度学习入门的过程。先来了解一下本文的神经网络结构，一图胜千言：

图3.2 储层流体性质识别网络结构

论文中提到的网络结构优化，是在网络中引入了 ReLU激活函数、Softmax 层 和 Dropout 正则化，使得网络模型更好地适应多分类问题，防止出现“过拟合”现象，有效提高训练模型的稳定性。

该网络的代码实现：

class MLP(nn.Module):
    def __init__(self, input_size, output_size):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, 20)    # 输入层->隐藏层1
        self.fc2 = nn.Linear(20, 25)            # 隐藏层1->隐藏层2
        self.fc3 = nn.Linear(25, 30)            # 隐藏层2->隐藏层3
        self.fc4 = nn.Linear(30, 25)            # 隐藏层3->隐藏层4
        self.fc5 = nn.Linear(25, 15)            # 隐藏层4->隐藏层5
        self.fc6 = nn.Linear(15, output_size)   # 隐藏层5->输出层

        self.dropout = nn.Dropout(p=0.2)  # Dropout层，设置丢弃概率为0.2

    def forward(self, x):
        x = F.relu(self.fc1(x))     # 应用激活函数ReLu
        x = self.dropout(x)         # 应用Dropout层
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = F.relu(self.fc3(x))
        x = self.dropout(x)
        x = F.relu(self.fc4(x))
        x = self.dropout(x)
        x = F.relu(self.fc5(x))
        x = self.dropout(x)
        x = self.fc6(x)
        return F.softmax(x, dim=0)  # 在这里使用softmax函数

下面我们就利用这个网络结构，用Wind数据集去训练出一个识别葡萄酒类别的模型，完成识别分类任务，近似的去复现复杂储层流体性质识别模型。

完整的模型训练和应用模型识别葡萄酒类别的代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_score, recall_score, f1_score

'''
教程：B站我是土堆 + 博客
'''


class MLP(nn.Module):
    def __init__(self, input_size, output_size):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, 20)    # 输入层->隐藏层1
        self.fc2 = nn.Linear(20, 25)            # 隐藏层1->隐藏层2
        self.fc3 = nn.Linear(25, 30)            # 隐藏层2->隐藏层3
        self.fc4 = nn.Linear(30, 25)            # 隐藏层3->隐藏层4
        self.fc5 = nn.Linear(25, 15)            # 隐藏层4->隐藏层5
        self.fc6 = nn.Linear(15, output_size)   # 隐藏层5->输出层

        self.dropout = nn.Dropout(p=0.2)  # Dropout层，设置丢弃概率为0.2

    def forward(self, x):
        x = F.relu(self.fc1(x))     # 应用激活函数ReLu
        x = self.dropout(x)         # 应用Dropout层
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = F.relu(self.fc3(x))
        x = self.dropout(x)
        x = F.relu(self.fc4(x))
        x = self.dropout(x)
        x = F.relu(self.fc5(x))
        x = self.dropout(x)
        x = self.fc6(x)
        return F.softmax(x, dim=0)  # 在这里使用softmax函数


# 归一化处理
def normalize_features(input_tensor):
    # 计算每个特征的最大值和最小值
    v_min = torch.min(input_tensor)
    v_max = torch.max(input_tensor)

    # 对特征进行归一化
    normalized_res = (input_tensor - v_min) / (v_max - v_min)

    return normalized_res


# 设置超参数
num_epochs = 200
learning_rate = 0.001

# 创建模型实例
model = MLP(13, 3)  # (input_size，output_size)
print(model)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 使用交叉熵作为损失函数
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 输入数据，训练集数据
# 读取 Excel 文件
dataset = pd.read_excel(r'./dataset/new_wine.xlsx')

X = torch.tensor(dataset.iloc[:, :-1].values).float()
y = dataset.iloc[:, -1]

# 对输入张量的特征进行归一化
normalized_input = normalize_features(X)

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(normalized_input, y, test_size=0.2, random_state=42)

# 训练模型
for epoch in range(num_epochs):
    model.train()  # 设置为训练模式

    for i in range(len(X_train)):
        outputs = model(X_train[i])  # 前向传播

        # 计算损失
        loss = criterion(outputs.unsqueeze(0),  # 注意这里需要多一个维度，表示样本的数量
                         torch.tensor([y_train.iloc[i] - 1]))  # 索引从0开始，因此类别[1],[2],[3]->[0],[1],[2]

        # 反向传播和优化
        optimizer.zero_grad()  # 清空梯度
        loss.backward()  # 反向传播，计算梯度
        optimizer.step()  # 更新权重

    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# 保存模型
torch.save(model.state_dict(), 'model.pth')  # 保存模型参数到文件'model.pth'中

# 设置模型为评估模式
model.eval()

y_true = torch.tensor(y_test.tolist())  # 真实值
y_pred = []  # 模型的预测值
# 进行预测
with torch.no_grad():  # 关闭梯度计算以节省内存
    for i in range(len(X_test)):
        pre_y = model(X_test[i])

        # 使用 torch.argmax() 找到最大值的索引
        _, predicted_class = torch.max(pre_y, 0)
        # print("Predicted class:", predicted_class.item() + 1)
        y_pred.append(predicted_class.item() + 1)

y_pred = torch.tensor(y_pred)
# 使用 sklearn 的函数来计算 Precision, Recall 和 F1-score
precision = precision_score(y_true.numpy(), y_pred.numpy(), average='macro')
recall = recall_score(y_true.numpy(), y_pred.numpy(), average='macro')
f1 = f1_score(y_true.numpy(), y_pred.numpy(), average='macro')

print(f'Precision: {precision}, Recall: {recall}, F1-score: {f1}')

过程中输出的内容：

MLP(
  (fc1): Linear(in_features=13, out_features=20, bias=True)
  (fc2): Linear(in_features=20, out_features=25, bias=True)
  (fc3): Linear(in_features=25, out_features=30, bias=True)
  (fc4): Linear(in_features=30, out_features=25, bias=True)
  (fc5): Linear(in_features=25, out_features=15, bias=True)
  (fc6): Linear(in_features=15, out_features=3, bias=True)
  (dropout): Dropout(p=0.2, inplace=False)
)
Epoch [10/100], Loss: 1.0862
Epoch [20/100], Loss: 1.0778
Epoch [30/100], Loss: 1.0782
Epoch [40/100], Loss: 1.2110
Epoch [50/100], Loss: 1.5514
Epoch [60/100], Loss: 1.5169
Epoch [70/100], Loss: 1.4014
Epoch [80/100], Loss: 1.5513
Epoch [90/100], Loss: 1.5514
Epoch [100/100], Loss: 1.1985
Precision: 0.8260869565217391, Recall: 0.6493506493506493, F1-score: 0.5789341377576672

就我目前训练得到的模型实验情况来看，模型各项评价指标都比较低，说明论文中的网络结构不太适合我们选用的Wine数据集，这是很正常的。因为论文的网络结构是用于测井数据集的，针对这个数据集不断实验训练模型，最终才确定了这样一个网络结构。如果想适配我们选用的Wine数据集，也需要做大量调超参、优化网络结构的模型训练实验。

到这里就成功复现了论文中优化后的模型。我这里给出了一个简单识别葡萄酒类别的例子，完成了深度学习模型进行识别分类任务基本流程，可以作为参考。但是想得到性能优秀的模型，比如针对自己的特定数据集的识别模型，还有很多实验、工作要做，这也是必经之路。

实现3—论文中的图表

这里只复现论文中的表1、表2和图5，比较重要。因为没有去做对比实验，所以没有复现图7，这个对比实验比较简单，知道了表2中的F值如何来的，就能得到图7。

（1）表1

论文中表1：
在这里插入图片描述

针对Wine数据集，我们也生成一个和表1一样的资料统计表：
在这里插入图片描述

图3.3 葡萄酒资料统计

当然还要做出轻微的修改，label行需要删掉。资料统计表通过下面代码生成：

import pandas as pd

# 1.数据集资料统计
# 读取Excel文件
df = pd.read_excel('./dataset/wine.xlsx')

# 数据集的基本描述
view = df.describe(percentiles=[], include='all').T
view.to_excel('./results/资料统计.xlsx')

（2）表2

论文中表2：
在这里插入图片描述
计算评价指标的公式：

针对Wine数据集，我们也做一个和表2一样的识别结果混淆矩阵，得到这个表中数据麻烦一点，需要我们在模型训练那块代码中打印出这些数据。然后评价指标值，我们可以根据论文中给的公式，再依据表中的数据，手动计算出来（偷个懒，不写代码算，代码中也计算了这些评价指标，但是针对所有类别的平均，没有算单个类别）。

直接贴出某一次训练模型时候打印的值：

真实类别：[1, 1, 3, 1, 2, 1, 3, 3, 2, 3, 1, 3, 1, 3, 1, 2, 2, 2, 1, 2, 1, 2, 2, 3, 3, 3, 2, 2, 2, 1, 1, 3, 3, 1, 1, 1]
预测类别：[3, 1, 2, 1, 3, 1, 2, 3, 2, 2, 3, 3, 1, 3, 1, 2, 2, 3, 1, 2, 1, 3, 3, 3, 2, 3, 3, 2, 3, 1, 1, 3, 2, 1, 1, 1]

填入表中：

表3.1 葡萄酒识别结果混淆矩阵

在这里插入图片描述

（3）图5

论文中图5：
在这里插入图片描述
针对Wine数据集，我们也生成一个样本集数量分布，这里我使用的是代码进行数据统计+Excel绘制饼状图的方式。

代码进行数据统计，在将样本集划分为训练集和测试集的时候，我打印每个类别的样本数。代码如下：

# 导入需要用到的包
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

# 1.数据集资料统计
# 读取Excel文件
df = pd.read_excel('./dataset/wine.xlsx')
print(df)

# 2.样本集数量分布
# 划分训练集和测试集，再绘制饼状图
wine = df
X = wine.iloc[:, 1:]
y = wine.label

# 拆分成训练集和测试集，训练集80%和测试集20%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
print('------训练集样本数量---------')
print(y_train.value_counts())
print('------测试集样本数量---------')
print(y_test.value_counts())

输出结果：

------训练集样本数量---------
2    54
1    48
3    40
Name: label, dtype: int64
------测试集样本数量---------
2    17
1    11
3     8
Name: label, dtype: int64

将数值用Excel表画成饼状图，如下图：

在这里插入图片描述

图3.4 样本集数量分布

四、最后

至此，《基于深度学习的复杂储层流体性质测井识别——以车排子油田某井区为例》论文复现之旅也将行至终点，当然还有很多细节没考虑到，后面肯定还会完善这块模型内容，期待。不得不说，这个搭建模型的整个过程完全可以作为深度学习入门，也让我更理解了之前学的碎片化知识，收获满满。

纸上得来终觉浅，绝知此事要躬行。动手学深度学习才是最快提升方法，没有之一，共勉之。

以上就是本文的全部内容，欢迎点赞评论，指出不足，笔者由衷感谢！~