如何使用 Python 堆实现自编码器算法？

import numpy as np
import heapq
from sklearn.preprocessing import StandardScaler

from keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 调整输入格式
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.

# 将数据转换为向量形式
x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))

# 标准化数据
scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

class Autoencoder:
    def __init__(self, input_dim, hidden_dim):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.encoder_heap = []
        self.decoder_heap = []

    def encode(self, data):
        encoded = []
        for i in range(self.hidden_dim):
            heapq.heappush(self.encoder_heap, (np.dot(data, self.encoder_weights[i]), i))
        for i in range(self.hidden_dim):
            encoded.append(heapq.heappop(self.encoder_heap)[1])
        return encoded

    def decode(self, encoded):
        decoded = []
        for i in range(self.input_dim):
            heapq.heappush(self.decoder_heap, (-encoded[i], i))
        for i in range(self.hidden_dim):
            heapq.heappop(self.decoder_heap)
        for i in range(self.input_dim):
            decoded.append(heapq.heappop(self.decoder_heap)[1])
        return decoded

    def train(self, x_train):
        # 随机初始化编码器和解码器权重
        self.encoder_weights = np.random.randn(self.input_dim, self.hidden_dim)
        self.decoder_weights = np.random.randn(self.hidden_dim, self.input_dim)

        # 循环训练
        for epoch in range(10):
            epoch_loss = 0
            for data in x_train:
                # 编码器
                encoded_data = self.encode(data)

                # 解码器
                decoded_data = self.decode(encoded_data)

                # 误差
                loss = np.linalg.norm(data - decoded_data)

                # 更新权重
                encoder_gradient = np.outer(data, encoded_data)
                self.encoder_weights += (0.1 * encoder_gradient)

                decoder_gradient = np.outer(encoded_data, decoded_data)
                self.decoder_weights += (0.1 * decoder_gradient)

                epoch_loss += loss

            print('Epoch {}, loss: {}'.format(epoch + 1, epoch_loss / len(x_train)))

autoencoder = Autoencoder(x_train.shape[1], 100)
autoencoder.train(x_train)

decoded_imgs = []
for encoded_data in autoencoder.encode(x_test):
    decoded_imgs.append(autoencoder.decode(encoded_data))
decoded_imgs = np.array(decoded_imgs)

# 可视化预测结果
import matplotlib.pyplot as plt

n = 10  # 可视化的数字数量
plt.figure(figsize=(20, 4))
for i in range(n):
    # 原始图像
    ax = plt.subplot(2, n, i + 1)
    plt.imshow(x_test[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    # 解码后的图像
    ax = plt.subplot(2, n, i + 1 + n)
    plt.imshow(decoded_imgs[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()