用堆叠自编码器网络实现对指定文件夹内的4类三通道彩色图像进行分类并可视化混淆矩阵python代码

以下是用堆叠自编码器网络实现对指定文件夹内的4类三通道彩色图像进行分类并可视化混淆矩阵的 Python 代码：

import os
import numpy as np
from PIL import Image
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from keras.layers import Input, Dense
from keras.models import Model
import matplotlib.pyplot as plt

# 定义参数
input_shape = (120, 120, 3)
num_classes = 4
batch_size = 16
epochs = 50

# 加载数据
def load_data():
    data = []
    labels = []
    for category in os.listdir('data'):
        for file in os.listdir(os.path.join('data', category)):
            img_path = os.path.join('data', category, file)
            img = Image.open(img_path).resize(input_shape[:2])
            data.append(np.array(img))
            labels.append(category)
    return np.array(data), np.array(labels)

data, labels = load_data()

# 将标签转换为数字
label_dict = {'Type1': 0, 'Type2': 1, 'Type3': 2, 'Type4': 3}
labels = np.array([label_dict[label] for label in labels])

# 将数据拆分为训练集和测试集
train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, random_state=42)

# 归一化数据
train_data = train_data.astype('float32') / 255.
test_data = test_data.astype('float32') / 255.

# 定义模型
input_data = Input(shape=input_shape)
x = Dense(256, activation='relu')(input_data)
x = Dense(128, activation='relu')(x)
encoded = Dense(64, activation='relu')(x)
x = Dense(128, activation='relu')(encoded)
x = Dense(256, activation='relu')(x)
decoded = Dense(input_shape[2], activation='sigmoid')(x)
autoencoder = Model(input_data, decoded)
encoder = Model(input_data, encoded)

# 编译模型
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')

# 训练模型
autoencoder.fit(train_data, train_data, epochs=epochs, batch_size=batch_size, shuffle=True, validation_data=(test_data, test_data))

# 提取特征
train_features = encoder.predict(train_data)
test_features = encoder.predict(test_data)

# 定义分类器
inputs = Input(shape=(64,))
x = Dense(32, activation='relu')(inputs)
outputs = Dense(num_classes, activation='softmax')(x)
classifier = Model(inputs, outputs)

# 编译分类器
classifier.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# 训练分类器
classifier.fit(train_features, train_labels, epochs=epochs, batch_size=batch_size, shuffle=True, validation_data=(test_features, test_labels))

# 预测测试集
predictions = classifier.predict(test_features)
predictions = np.argmax(predictions, axis=1)

# 计算混淆矩阵
cm = confusion_matrix(test_labels, predictions)

# 可视化混淆矩阵
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.title('Confusion Matrix')
plt.colorbar()
tick_marks = np.arange(num_classes)
plt.xticks(tick_marks, ['Type1', 'Type2', 'Type3', 'Type4'], rotation=45)
plt.yticks(tick_marks, ['Type1', 'Type2', 'Type3', 'Type4'])
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.show()

其中，`data` 文件夹包含了所有的图像数据，每个子文件夹表示一个分类。代码首先加载数据，然后将标签转换为数字，并将数据拆分为训练集和测试集。接着，定义了一个堆叠自编码器网络，该网络可以将三通道的彩色图像压缩为一个 64 维的向量。使用该网络提取出的特征作为输入，训练一个简单的分类器。最后，使用预测结果计算混淆矩阵，并对其进行可视化。