使用 CNN 进行乳腺癌图像分类（TensorFlow - Python）

Question

我需要帮助来完成使用 CNN 对乳腺癌图像进行分类的代码。

我需要模型从随机图像中进行预测，但它一直为总共 306 个图像提供一个预测类（侵入性）。 另外，我需要计算准确率和混淆矩阵。 我很感激帮助。 部分代码如下：

s=100
X_train = []
y_train = []
for folder in  os.listdir(trainpath +'TrainingSet') : 
    files = gb.glob(pathname= str( trainpath +'TrainingSet//' + folder + '/*.png'))
    for file in files: 
        image = cv2.imread(file)
        image_array = cv2.resize(image , (s,s))
        X_train.append(list(image_array))
        y_train.append(code[folder])



X_pred = []
s=100
files = gb.glob(pathname= str(testpath + 'ValidationSet/*.png'))
for file in files: 
    image = cv2.imread(file)
    image_array = cv2.resize(image , (s,s))
    X_pred.append(list(image_array))



X_train = np.array(X_train)
y_train = np.array(y_train)
X_pred_array = np.array(X_pred)


print(f'X_train shape  is {X_train.shape}')
print(f'y_train shape  is {y_train.shape}')
print(f'X_pred shape  is {X_pred_array.shape}')



KerasModel = keras.models.Sequential([
        keras.layers.Conv2D(200,kernel_size=(3,3),activation='relu',input_shape=(s,s,3)),
        keras.layers.Conv2D(150,kernel_size=(3,3),activation='relu'),
        keras.layers.MaxPool2D(4,4),
        keras.layers.Conv2D(120,kernel_size=(3,3),activation='relu'),    
        keras.layers.Conv2D(80,kernel_size=(3,3),activation='relu'),    
        keras.layers.Conv2D(50,kernel_size=(3,3),activation='relu'),
        keras.layers.MaxPool2D(4,4),
        keras.layers.Flatten() ,    
        keras.layers.Dense(120,activation='relu') ,    
        keras.layers.Dense(100,activation='relu') ,    
        keras.layers.Dense(50,activation='relu') ,        
        keras.layers.Dropout(rate=0.5) ,            
        keras.layers.Dense(3,activation='softmax') ,    
        ])

KerasModel.compile(optimizer ='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
print('Model Details are : ')
print(KerasModel.summary())


epochs = 15

ThisModel = KerasModel.fit(X_train, y_train, epochs=epochs,batch_size=16,verbose=1, callbacks=[learn_control, checkpoint])


ModelLoss, ModelAccuracy = KerasModel.evaluate(X_train, y_train)

print('Total Loss is {}'.format(ModelLoss))
print('Total Accuracy is {}'.format(ModelAccuracy ))



y_result = KerasModel.predict(X_pred_array)

print('Prediction Shape is {}'.format(y_result.shape))



import warnings
warnings.filterwarnings('always')
warnings.filterwarnings('ignore')
import fnmatch 
import os 
from sklearn.metrics import confusion_matrix

image_path = 'Data\ValidationSet'
for filename in os.listdir(image_path):
    filename = os.path.basename(filename)
    Actual_list    = []
    Predicted_list = []       
    if any(map(filename.startswith, 'InSitu_')):
        Actual='Insitu'
            
    if any(map(filename.startswith, 'SOB_B_')):
        Actual='Benign'
            
    if any(map(filename.startswith, 'SOB_M_')):
        Actual='Invasive'

plt.figure(figsize=(20,40))
for n , i in enumerate(list(np.random.randint(0,len(X_pred),306))) : 
    plt.subplot(34,9,n+1)
    plt.imshow(X_pred[i]) 
    plt.axis('off')
    Predicted= getcode(np.argmax(y_result[i]))
    plt.title('Predicted:  ' + Predicted +'\n' + 'Actual:' + Actual)
    Actual_list.append(Actual)
    Predicted_list.append(Predicted)

训练过程的输出：

Epoch 1/15
1231/1231 [===] - 284s 230ms/step - loss: 0.6721 - accuracy: 0.7295
Epoch 2/15
1231/1231 [===] - 279s 227ms/step - loss: 0.6698 - accuracy: 0.7295
Epoch 3/15
1231/1231 [===] - 259s 211ms/step - loss: 0.6784 - accuracy: 0.7295
Epoch 4/15
1231/1231 [===] - 263s 214ms/step - loss: 0.6751 - accuracy: 0.7295   
Epoch 5/15
1231/1231 [===] - 255s 207ms/step - loss: 0.6715 - accuracy: 0.7295
Epoch 6/15
1231/1231 [===] - 255s 207ms/step - loss: 0.6695 - accuracy: 0.7295
Epoch 7/15
1231/1231 [===] - 253s 205ms/step - loss: 0.6737 - accuracy: 0.7295
Epoch 8/15
1231/1231 [===] - 256s 208ms/step - loss: 0.6730 - accuracy: 0.7295
Epoch 9/15
1231/1231 [===] - 263s 214ms/step - loss: 0.6733 - accuracy: 0.7295
Epoch 10/15
1231/1231 [===] - 277s 225ms/step - loss: 0.6741 - accuracy: 0.7295
Epoch 11/15
1231/1231 [===] - 279s 227ms/step - loss: 0.6698 - accuracy: 0.7295
Epoch 12/15
1231/1231 [===] - 254s 206ms/step - loss: 0.6743 - accuracy: 0.7295
Epoch 13/15
1231/1231 [===] - 255s 207ms/step - loss: 0.6758 - accuracy: 0.7295
Epoch 14/15
1231/1231 [===] - 254s 206ms/step - loss: 0.6722 - accuracy: 0.7295
Epoch 15/15
1231/1231 [===] - 257s 209ms/step - loss: 0.6706 - accuracy: 0.7295

总损失和准确率：

1231/1231 [===============================] - 114s 93ms/步 总损失为 0.667820717773236 总精度为 0.7294881939888

Answer 1

首先，您需要找到正确和错误的预测。

def get_tested_predictions(Actual_list, Predicted_list):
    correct_preds = []
    incorrect_preds = []
    correct_count = 0
    incorrect_count = 0
    for ii in range(len(Actual_list)):
        label_idx = np.argmax(Actual_list[ii])
        prediction_idx = np.argmax(Predicted_list[ii])
        prediction = Predicted_list[ii][prediction_idx]
        if prediction_idx == label_idx:
            correct_preds.append(prediction)
            incorrect_preds.append(np.nan)
            correct_count = correct_count + 1
        if prediction_idx != label_idx:
            incorrect_preds.append(prediction)
            correct_preds.append(np.nan)
            incorrect_count = incorrect_count + 1
    return correct_preds, correct_count, incorrect_preds, incorrect_count

correct_preds, correct_count, incorrect_preds, incorrect_count = get_tested_predictions(Actual_list,Predicted_list)
print("Correct predictions: %d/%d" % (correct_count,len(Predicted_list)))
print("Incorrect predictions: %d/%d" % (incorrect_count,len(Predicted_list)))

现在，我们需要从 sklearn 导入混淆矩阵并绘制它：

import itertools
from sklearn.metrics import confusion_matrix

y_trues = [np.argmax(ii) for ii in Actual_list]
y_preds = [np.argmax(ii) for ii in Predicted_list]


def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):

    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

cnf_matrix = confusion_matrix(y_trues, y_preds)
class_names=list(set(np.concatenate((y_trues,y_preds),axis=0)))

# Plot non-normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion matrix, without normalization')
plt.show()

名称错误现已修复。