用堆叠自编码器对指定文件夹内的图像进行分类并生成混淆矩阵tensorflow代码

首先，需要导入必要的库：

import tensorflow as tf
import numpy as np
import os

然后，定义一些必要的超参数：

num_epochs = 10
batch_size = 32
learning_rate = 0.001
latent_size = 64
num_classes = 10

接下来，定义一个函数用于读取文件夹内的图像数据：

def load_data(folder):
    data = []
    labels = []
    for subdir in os.listdir(folder):
        for file in os.listdir(os.path.join(folder, subdir)):
            img = tf.keras.preprocessing.image.load_img(os.path.join(folder, subdir, file), target_size=(128, 128))
            img = tf.keras.preprocessing.image.img_to_array(img)
            data.append(img)
            labels.append(subdir)
    return np.asarray(data), np.asarray(labels)

然后，准备数据集：

train_folder = "train_folder_path"
test_folder = "test_folder_path"

train_data, train_labels = load_data(train_folder)
test_data, test_labels = load_data(test_folder)

train_labels = tf.keras.utils.to_categorical(train_labels, num_classes=num_classes)
test_labels = tf.keras.utils.to_categorical(test_labels, num_classes=num_classes)

train_dataset = tf.data.Dataset.from_tensor_slices((train_data, train_labels)).shuffle(len(train_data)).batch(batch_size).prefetch(1)
test_dataset = tf.data.Dataset.from_tensor_slices((test_data, test_labels)).batch(batch_size).prefetch(1)

定义堆叠自编码器模型：

class Autoencoder(tf.keras.Model):
    def __init__(self, latent_size):
        super(Autoencoder, self).__init__()
        self.encoder = tf.keras.Sequential([
            tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu', padding='same'),
            tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
            tf.keras.layers.Conv2D(filters=64, kernel_size=3, activation='relu', padding='same'),
            tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
            tf.keras.layers.Conv2D(filters=128, kernel_size=3, activation='relu', padding='same'),
            tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
            tf.keras.layers.Flatten(),
            tf.keras.layers.Dense(latent_size, activation='relu')
        ])
        
        self.decoder = tf.keras.Sequential([
            tf.keras.layers.Dense(8*8*128, activation='relu'),
            tf.keras.layers.Reshape(target_shape=(8, 8, 128)),
            tf.keras.layers.Conv2DTranspose(filters=64, kernel_size=3, strides=2, padding='same', activation='relu'),
            tf.keras.layers.Conv2DTranspose(filters=32, kernel_size=3, strides=2, padding='same', activation='relu'),
            tf.keras.layers.Conv2DTranspose(filters=3, kernel_size=3, padding='same', activation=None)
        ])
        
    def call(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded, encoded

定义训练过程：

autoencoder = Autoencoder(latent_size)
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)

for epoch in range(num_epochs):
    train_loss = 0.
    test_loss = 0.
    for batch, (x, _) in enumerate(train_dataset):
        with tf.GradientTape() as tape:
            recon, _ = autoencoder(x)
            loss = tf.keras.losses.mean_squared_error(x, recon)
        gradients = tape.gradient(loss, autoencoder.trainable_variables)
        optimizer.apply_gradients(zip(gradients, autoencoder.trainable_variables))
        train_loss += loss.numpy()
    for batch, (x, _) in enumerate(test_dataset):
        recon, _ = autoencoder(x)
        loss = tf.keras.losses.mean_squared_error(x, recon)
        test_loss += loss.numpy()
    print('Epoch {} - train loss: {:.4f} - test loss: {:.4f}'.format(epoch+1, train_loss/(batch+1), test_loss/(batch+1)))

最后，使用训练好的自编码器进行分类：

train_emb = autoencoder.encoder(train_data).numpy()
test_emb = autoencoder.encoder(test_data).numpy()

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
              loss=tf.keras.losses.CategoricalCrossentropy(),
              metrics=[tf.keras.metrics.CategoricalAccuracy()])

model.fit(train_emb, train_labels, epochs=num_epochs, batch_size=batch_size, validation_data=(test_emb, test_labels))

y_pred = model.predict(test_emb)
y_pred = np.argmax(y_pred, axis=1)
y_test = np.argmax(test_labels, axis=1)

confusion_matrix = tf.math.confusion_matrix(y_test, y_pred, num_classes=num_classes)
print(confusion_matrix.numpy())

这是一个基本框架，您可能需要根据自己的具体需求进行一些调整。