【医学图像分析与理解课内实验】医学图像分类实验

Good

实验目的

任意选择分类算法，实现乳腺癌分类。要求所有分类算法均自己实现。
下图是一个良性样本：

下图是一个恶性样本：

实验过程

   由于能力和精力有限，我并没有选用CNN模型作为分类器。一方面是因为不借助PyTorch框架实现CNN对我来说过于困难，另一方面是因为本次课内实验提供的数据量太小，我觉得没有必要通过卷积神经网络来进行分类，故本次实验选用了相对简单的全连接神经网络实现。
  ①数据集的读取

本次实验的数据集正类样本和负类样本存放于两个不同的目录，因此可以调用Python的os模块，列举出目录中的所有文件并进行读取，作为数据集的特征。经过观察各图片的命名，可以发现所有的正类样本命名均为SOB_B_...，负类样本命名均为SOB_M_...，故可以从文件名入手，以下划线作为分隔符对文件名运用split方法，通过索引为1的元素（B或M）来确定数据样本的标签。每读取一个样本，就将其加入dataset列表，便于后续划分训练集和验证集。

1. def read_data(self):
2.     dataset = []
3.     for dir_name in self.dir_names:
4.         for filename in os.listdir(r'./data/' + dir_name):
5.             img = cv2.imread(r'./data/' + dir_name + '/' + filename)
6.             label = 0 if filename.split('_')[1] == 'B' else 1
7.             dataset.append([img, label])
8.     return dataset

复制代码

②数据集的划分

根据设定的test_size参数来划分出训练集和验证集。划分前通过random.shuffle方法对数据集洗牌，确定训练集和测试集大小后通过切片的方式进行划分，进一步提取出对应的特征和标签。对于数据样本的特征，输入网络时可将图像三个通道的像素展平，但这样可能会丢失一些上下相邻像素点之间的关联。

1. def train_test_split(self, dataset):
2.     random.shuffle(dataset)
3.     data_len = len(dataset)
4.     test_len = int(data_len * self.test_size)
5.     train_len = data_len - test_len
6.     train, test = dataset[:train_len], dataset[train_len:]
7.     X_train = np.array([i[0] for i in train])
8.     y_train = np.array([[i[1]] for i in train]).reshape(1, -1)
9.     X_test = np.array([i[0] for i in test])
10.     y_test = np.array([[i[1]] for i in test]).reshape(1, -1)
11.     X_train = X_train.reshape((X_train.shape[0], -1)).T
12.     X_test = X_test.reshape((X_test.shape[0], -1)).T
13.     return X_train, X_test, y_train, y_test

复制代码

③全连接神经网络

编写my_nn类实现全连接神经网络，从本质上来说是通过训练得到每两层之间的权重和偏置（即W1、b1、W2、b2），训练之前应对其进行随机初始化。神经网络的训练过程可以分为前向传播和反向传播。在前向传播中，设置隐藏层后使用tanh函数激活，输出结果使用sigmoid函数（调用scipy.special.expit实现）映射到                               [                      0                      ,                      1                      ]                          [0, 1]               [0,1] 区间。反向传播则是对矩阵求导，通过梯度下降法优化网络参数。

1. def init_parameters(self):
2.     W1 = np.random.randn(self.hidden_layer, self.input_layer) * 0.01
3.     b1 = np.zeros((self.hidden_layer, 1))
4.     W2 = np.random.randn(self.output_layer, self.hidden_layer) * 0.01
5.     b2 = np.zeros((self.output_layer, 1))
6.     return W1, W2, b1, b2
8. def tanh(self, x):
9.     return 2 / (1 + np.exp(-2 * x)) - 1
11. def forward(self, W1, W2, b1, b2, x):
12.     z1 = np.dot(W1, x) + b1
13.     a1 = self.tanh(z1)
14.     z2 = np.dot(W2, a1) + b2
15.     y_hat = expit(z2)
16.     return y_hat, a1
18. def backward(self, y_hat, a1, W2, N):
19.     dz2 = (-1 / N) * (self.y * (1 - y_hat) - y_hat * (1 - self.y))
20.     dW2 = np.dot(dz2, a1.T)
21.     db2 = dz2.sum(axis=1, keepdims=True)
22.     dz1 = np.dot(W2.T, dz2) * (1 - a1 ** 2)
23.     dW1 = np.dot(dz1, self.X.T)
24.     db1 = dz1.sum(axis=1, keepdims=True)
25.     return {'dW2': dW2, 'db2': db2, 'dW1': dW1, 'db1': db1}
27. def optim_GD(self, W1, W2, b1, b2, lr, grids):
28.     W1 -= lr * grids['dW1']
29.     W2 -= lr * grids['dW2']
30.     b1 -= lr * grids['db1']
31.     b2 -= lr * grids['db2']
32.     return W1, W2, b1, b2

复制代码

本次实验的神经网络设置隐藏层神经元数量为16，训练迭代次数为2000，学习率为0.1，损失函数选择交叉熵损失函数。
完整代码实现

项目结构如下图所示：

my_nn.py

1. import os
2. import random
4. import cv2
5. import numpy as np
6. from scipy.special import expit
9. class my_nn:
10.     def __init__(self, X, y, hidden_layer, iters, lr):
11.         self.X = X
12.         self.y = y
13.         self.input_layer = self.X.shape[0]
14.         self.output_layer = self.y.shape[0]
15.         self.hidden_layer = hidden_layer
16.         self.iters = iters
17.         self.lr = lr
19.     def init_parameters(self):
20.         W1 = np.random.randn(self.hidden_layer, self.input_layer) * 0.01
21.         b1 = np.zeros((self.hidden_layer, 1))
22.         W2 = np.random.randn(self.output_layer, self.hidden_layer) * 0.01
23.         b2 = np.zeros((self.output_layer, 1))
24.         return W1, W2, b1, b2
26.     def tanh(self, x):
27.         return 2 / (1 + np.exp(-2 * x)) - 1
29.     def forward(self, W1, W2, b1, b2, x):
30.         z1 = np.dot(W1, x) + b1
31.         a1 = self.tanh(z1)
32.         z2 = np.dot(W2, a1) + b2
33.         y_hat = expit(z2)
34.         return y_hat, a1
36.     def backward(self, y_hat, a1, W2, N):
37.         dz2 = (-1 / N) * (self.y * (1 - y_hat) - y_hat * (1 - self.y))
38.         dW2 = np.dot(dz2, a1.T)
39.         db2 = dz2.sum(axis=1, keepdims=True)
40.         dz1 = np.dot(W2.T, dz2) * (1 - a1 ** 2)
41.         dW1 = np.dot(dz1, self.X.T)
42.         db1 = dz1.sum(axis=1, keepdims=True)
43.         return {'dW2': dW2, 'db2': db2, 'dW1': dW1, 'db1': db1}
45.     def optim_GD(self, W1, W2, b1, b2, lr, grids):
46.         W1 -= lr * grids['dW1']
47.         W2 -= lr * grids['dW2']
48.         b1 -= lr * grids['db1']
49.         b2 -= lr * grids['db2']
50.         return W1, W2, b1, b2
52.     def cross_entropy(self, y_hat, N):
53.         assert self.y.shape == y_hat.shape
54.         return (-1 / N) * (np.dot(self.y, np.log(y_hat.T)) + np.dot((1 - self.y), np.log((1 - y_hat).T)))
56.     def cal_acc(self, y, y_hat):
57.         y_hat = y_hat.T
58.         for i in range(len(y_hat)):
59.             y_hat[i] = 0 if y_hat[i] < 0.5 else 1
60.         acc = (np.dot(y, y_hat) + np.dot(1 - y, 1 - y_hat)) / float(len(y_hat))
61.         return acc, y_hat
63.     def fit(self):
64.         W1, W2, b1, b2 = self.init_parameters()
65.         print('-' * 40 + ' Train ' + '-' * 40)
66.         for i in range(1, self.iters + 1):
67.             y_hat, a1 = self.forward(W1, W2, b1, b2, self.X)
68.             if i % 50 == 0:
69.                 cost = self.cross_entropy(y_hat, self.X.shape[1])[0][0]
70.                 acc, _ = self.cal_acc(self.y, y_hat)
71.                 acc = acc[0][0]
72.                 print('[Train] Iter: {:<4d} | Loss: {:<6.4f} | Accuracy: {:<6.4f}'.format(i, cost, acc))
73.             grids = self.backward(y_hat, a1, W2, self.X.shape[1])
74.             W1, W2, b1, b2 = self.optim_GD(W1, W2, b1, b2, self.lr, grids)
75.         return {'W1': W1, 'W2': W2, 'b1': b1, 'b2': b2}
77.     def eval(self, X_test, y_test, parameters):
78.         W1 = parameters['W1']
79.         W2 = parameters['W2']
80.         b1 = parameters['b1']
81.         b2 = parameters['b2']
82.         y_pred, _ = self.forward(W1, W2, b1, b2, X_test)
83.         acc, y_pred = self.cal_acc(y_test, y_pred)
84.         acc = acc[0][0]
85.         print('-' * 40 + ' Eval ' + '-' * 40)
86.         print('[Eval] Accuracy: {:<6.4f}'.format(acc))
87.         return y_pred
90. class Dataset:
91.     def __init__(self, dir_names, test_size):
92.         self.dir_names = dir_names
93.         self.test_size = test_size
95.     def read_data(self):
96.         dataset = []
97.         for dir_name in self.dir_names:
98.             for filename in os.listdir(r'./data/' + dir_name):
99.                 img = cv2.imread(r'./data/' + dir_name + '/' + filename)
100.                 label = 0 if filename.split('_')[1] == 'B' else 1
101.                 dataset.append([img, label])
102.         return dataset
104.     def train_test_split(self, dataset):
105.         random.shuffle(dataset)
106.         data_len = len(dataset)
107.         test_len = int(data_len * self.test_size)
108.         train_len = data_len - test_len
109.         train, test = dataset[:train_len], dataset[train_len:]
110.         X_train = np.array([i[0] for i in train])
111.         y_train = np.array([[i[1]] for i in train]).reshape(1, -1)
112.         X_test = np.array([i[0] for i in test])
113.         y_test = np.array([[i[1]] for i in test]).reshape(1, -1)
114.         X_train = X_train.reshape((X_train.shape[0], -1)).T
115.         X_test = X_test.reshape((X_test.shape[0], -1)).T
116.         return X_train, X_test, y_train, y_test

复制代码

main.py

1. from my_nn import Dataset, my_nn
3. dir_names = ['benign', 'malignant']
4. dataset = Dataset(dir_names, 0.3)
5. X_train, X_test, y_train, y_test = dataset.train_test_split(dataset.read_data())
7. model = my_nn(X_train, y_train, 16, 2000, 0.1)
8. parameters = model.fit()
9. model.eval(X_test, y_test, parameters)

复制代码

实验结果如下图所示：

由于只是一次课内实验，数据样本过少（正、负类样本各10张），很难通过分类的准确率来评判这个模型，但训练过程中损失值是在不断下降的。

来源：https://blog.csdn.net/qq_45554010/article/details/124620862
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！