标签: autoencoder

我正在玩一个玩具示例来理解 PCA 与 keras 自动编码器

我有以下用于理解 PCA 的代码：

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn import decomposition
from sklearn import datasets

iris = datasets.load_iris()
X = iris.data
pca = decomposition.PCA(n_components=3)
pca.fit(X)

pca.explained_variance_ratio_
array([ 0.92461621,  0.05301557,  0.01718514])

pca.components_
array([[ 0.36158968, -0.08226889,  0.85657211,  0.35884393],
       [ 0.65653988,  0.72971237, -0.1757674 , -0.07470647],
       [-0.58099728,  0.59641809,  0.07252408,  0.54906091]])

我已经用 keras 进行了一些阅读和播放代码，包括这个。

但是，参考代码感觉对我的理解水平飞跃太高了。

有人有一个简短的自动编码器代码可以告诉我吗

(1) 如何从自动编码器中提取前 3 个组件

(2) 如何理解自编码器捕获的方差量

(3) 自动编码器组件与 PCA 组件的比较

我正在尝试使用我在 Keras 示例（https://github.com/keras-team/keras/blob/master/examples/variational_autoencoder.py）中找到的变分自动编码器的实现。

我只是重构了代码，以便在 Jupyter 笔记本中更轻松地使用它（我的代码：https : //github.com/matbell/Autoencoders/blob/master/models/vae.py）。

但是，当我尝试在我的数据上拟合模型时，我得到以下输出：

Autoencoders/models/vae.py:69: UserWarning: Output "dense_5" missing from loss dictionary. We assume this was done on purpose, and we will not be expecting any data to be passed to "dense_5" during training.
self.vae.compile(optimizer='rmsprop')

Train on 15474 samples, validate on 3869 samples
Epoch 1/50
15474/15474 [==============================] - 1s 76us/step - loss: nan - val_loss: nan
Epoch 2/50
15474/15474 [==============================] - 1s 65us/step - loss: nan - val_loss: nan
Epoch 3/50 …

我是z Keras 的新手，并且一直在努力理解他们官方github 中变分自动编码器示例中变量的用法。我不明白为什么z没有被使用而不是变量latent_inputs。我运行了代码，它似乎有效，但我不明白是否z在幕后使用，以及 Keras 中负责它的机制是什么。这是相关的代码片段：

# VAE model = encoder + decoder
# build encoder model
inputs = Input(shape=input_shape, name='encoder_input')
x = Dense(intermediate_dim, activation='relu')(inputs)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)

# use reparameterization trick to push the sampling out as input
# note that "output_shape" isn't necessary with the TensorFlow backend
z = Lambda(sampling, output_shape=(latent_dim,), name='z')([z_mean, z_log_var])

# instantiate encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') …

当不使用 KL 散度项时，VAE 几乎完美地重建了 mnist 图像，但在提供随机噪声时无法正确生成新图像。

当使用 KL 散度项时，VAE 在重建和生成图像时给出相同的奇怪输出。

这是损失函数的pytorch代码：

def loss_function(recon_x, x, mu, logvar):
    BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), size_average=True)
    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())    
    return (BCE+KLD)

recon_x 是重建图像，x 是 original_image，mu 是均值向量，而 logvar 是包含方差对数的向量。

这里出了什么问题？提前致谢 ：）

我使用 keras 和张量流来实现带有 CNN 的深度自动编码器：

所以基本上该模型类似于：

    input_data = Input(shape=(40,500,1))

    #encoder  
    x= Conv2D(32,kernel_size=(3,3), padding="same",activation='linear')(input_data)       
    encoded= Conv2D(15,kernel_size=(1,2), strides=(1,2), padding="same",activation='linear')(x)  


    #decoder             
    x= Conv2DTranspose(15,kernel_size=(1,2), padding="same",activation='linear')(encoded)        
    x= Conv2DTranspose(32,kernel_size=(3,3), padding="same",activation='linear')(x)
    decoded = Conv2DTranspose(1, (3, 3), activation=activationfuntion, padding="same")(x)

    autoencoder = Model(inputs=input_data,outputs=decoded)
    encoder = Model(inputs=input_data,outputs=encoded)  

为了在训练期间保存最佳模型权重，我使用 ModelCheckpoint：

        autoencoder.compile(loss='mean_squared_error', optimizer='rmsprop');

        checkpoint=ModelCheckpoint('bestweight.best.hdf5',monitor='val_loss',verbose=1,save_best_only=True,mode='min');   
        callbacks_list=[checkpoint]

        history_info =autoencoder.fit(x_train, x_train,
                        batch_size=batch_size,
                        epochs=50,
                        validation_data=(x_validation,x_validation),
                        callbacks=callbacks_list,
                        shuffle=True)

然后在测试数据集上进行测试：

 autoencoder.load_weights('bestweight.best.hdf5');
 autoencoder.predict(test_data);

我的问题是：

我知道如何保存整个自动编码器的最佳权重，但是有没有办法只保存编码器部分的最佳训练权重，以便我稍后可以使用它进行测试。所以我可以这样使用它：

 encoder.load_weights('encoderbestweight.best.hdf5');
 encoder.predict(test_data);

如何构建卷积自动编码器的解码器部分？假设我有这个

(input -> conv2d -> maxpool2d -> maxunpool2d -> convTranspose2d -> output):

# CIFAR images shape = 3 x 32 x 32

class ConvDAE(nn.Module):
    def __init__(self):
        super().__init__()

        # input: batch x 3 x 32 x 32 -> output: batch x 16 x 16 x 16
        self.encoder = nn.Sequential(
            nn.Conv2d(3, 16, 3, stride=1, padding=1), # batch x 16 x 32 x 32
            nn.ReLU(),
            nn.BatchNorm2d(16),
            nn.MaxPool2d(2, stride=2) # batch x 16 x 16 x 16
        )

        # input: batch x 16 …

我正在 PyTorch 中构建变分自动编码器 (VAE)，但在编写与设备无关的代码时遇到问题。Autoencoder 是nn.Module编码器和解码器网络的子代，它们也是。网络的所有权重都可以通过调用从一个设备移动到另一个设备net.to(device)。

我遇到的问题是重新参数化技巧：

encoding = mu + noise * sigma

噪声是一个mu与sigma和大小相同的张量，并保存为自动编码器模块的成员变量。它在构造函数中初始化，并在每个训练步骤就地重新采样。我这样做是为了避免每一步构建一个新的噪声张量并将其推送到所需的设备。此外，我想修复评估中的噪音。这是代码：

class VariationalGenerator(nn.Module):
    def __init__(self, input_nc, output_nc):
        super(VariationalGenerator, self).__init__()

        self.input_nc = input_nc
        self.output_nc = output_nc
        embedding_size = 128

        self._train_noise = torch.randn(batch_size, embedding_size)
        self._eval_noise = torch.randn(1, embedding_size)
        self.noise = self._train_noise

        # Create encoder
        self.encoder = Encoder(input_nc, embedding_size)
        # Create decoder
        self.decoder = Decoder(output_nc, embedding_size)

    def train(self, mode=True):
        super(VariationalGenerator, self).train(mode)
        self.noise = self._train_noise

    def eval(self):
        super(VariationalGenerator, self).eval()
        self.noise = self._eval_noise

    def …

我正在尝试为以下对象创建自动编码器：

1. 训练模型
2. 分离式编码器和解码器
3. 可视化压缩数据（编码器）
4. 使用任意压缩数据获取输出（解码器）

from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D
from keras.models import Model
from keras import backend as K
from keras.datasets import mnist
import numpy as np

(x_train, _), (x_test, _) = mnist.load_data()

x_train = x_train.astype('float32') / 255.
x_train = x_train[:100,:,:,]
x_test = x_test.astype('float32') / 255.
x_test = x_train
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))  # adapt this if using `channels_first` image data format
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))  # adapt this if …

我有一个矩阵保存为 numpy 类型，称之为“X_before”（例如，它的形状是 100*30）。

因为我想使用 Pytorch 库将其提供给 AutoEncoder，所以我将其转换为torch.tensor如下所示：

X_tensor = torch.from_numpy(X_before, dtype=torch)

然后，我收到以下错误：

expected scalar type Float but found Double

Run Code Online (Sandbox Code Playgroud)

接下来，我尝试将元素设置为“float”，然后将它们转换为 torch.tensor：

X_before = X_before.astype(float)
X_tensor = torch.from_numpy(X_before)

同样的错误再次发生。我应该如何解决这个问题？如何将 torch.tensor 对象中的元素类型转换为另一种类型？

提前致谢

我正在尝试为 MNIST 构建一个简单的自动编码器，其中中间层只有 10 个神经元。我希望它能够学会对 10 位数字进行分类，并且我认为这最终会导致最低的错误（相对于再现原始图像）。

我有以下代码，我已经使用过相当多的代码了。如果我运行它最多 100 个 epoch，损失实际上不会低于 1.0，如果我评估它，它显然不起作用。我缺少什么？

训练：

import torch
import torchvision as tv
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from torchvision.utils import save_image

num_epochs = 100
batch_size = 64

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
trainset = tv.datasets.MNIST(root='./data',  train=True, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=4)

class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder,self).__init__()
        self.encoder = nn.Sequential(
            # 28 x 28
            nn.Conv2d(1, 4, kernel_size=5),
            nn.Dropout2d(p=0.2), …