精华内容
下载资源
问答
  • 自编码器自动编码器是一种无监督的深度学习算法,它学习输入数据的编码表示,然后重新构造与输出相同的输入。它由编码器和解码器两个网络组成。编码器将高维输入压缩成低维潜在代码(也称为潜在代码或编...

    自编码器

    自动编码器是一种无监督的深度学习算法,它学习输入数据的编码表示,然后重新构造与输出相同的输入。它由编码器和解码器两个网络组成。编码器将高维输入压缩成低维潜在代码(也称为潜在代码或编码空间) ,以从中提取最相关的信息,而解码器则解压缩编码数据并重新创建原始输入。

    这种架构的目标是在编码时最大化信息并最小化重构误差。但是重构误差是什么?它的名字也是重构损失,通常是输入为实值时重构输入与原始输入之间的均方误差。如果输入数据是分类数据,则使用的损失函数是交叉熵损失。

    在 Pytorch 中的实现

    1. 导入库和 MNIST 数据集

    我们可以使用库 torchvision 导入数据集。我们下载训练和测试数据集,并将图像数据集转换为 Tensor。我们不需要对图像进行标准化,因为数据集包含彩色图像。在我们将训练数据集划分为训练集和验证集之后,random_split 为这两个集提供了一个随机分区。DataLoader 用于为训练集、验证集和测试集创建数据加载器,这些数据加载器被分成小批量。 batchsize 是模型训练期间一次迭代中使用的样本数。

    import matplotlib.pyplot as plt # plotting library
    import numpy as np # this module is useful to work with numerical arrays
    import pandas as pd 
    import random 
    import torch
    import torchvision
    from torchvision import transforms
    from torch.utils.data import DataLoader,random_split
    from torch import nn
    import torch.nn.functional as F
    import torch.optim as optim
    
    
    data_dir = 'dataset'
    
    
    train_dataset = torchvision.datasets.MNIST(data_dir, train=True, download=True)
    test_dataset  = torchvision.datasets.MNIST(data_dir, train=False, download=True)
    
    
    train_transform = transforms.Compose([
    transforms.ToTensor(),
    ])
    
    
    test_transform = transforms.Compose([
    transforms.ToTensor(),
    ])
    
    
    train_dataset.transform = train_transform
    test_dataset.transform = test_transform
    
    
    m=len(train_dataset)
    
    
    train_data, val_data = random_split(train_dataset, [int(m-m*0.2), int(m*0.2)])
    batch_size=256
    
    
    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size)
    valid_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size)
    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,shuffle=True)
    

    2. 定义卷积自编码器

    在这里,我们定义了卷积层的自动编码器。它将由两个类组成: 一个用于编码器,另一个用于解码器。该编码器将包含三个卷积层和两个完全连接层。增加了一些批量规范层作为规范层。解码器将具有相同的架构,但顺序是相反的。

    class Encoder(nn.Module):
        
        def __init__(self, encoded_space_dim,fc2_input_dim):
            super().__init__()
            
            ### Convolutional p
            self.encoder_cnn = nn.Sequential(
                nn.Conv2d(1, 8, 3, stride=2, padding=1),
                nn.ReLU(True),
                nn.Conv2d(8, 16, 3, stride=2, padding=1),
                nn.BatchNorm2d(16),
                nn.ReLU(True),
                nn.Conv2d(16, 32, 3, stride=2, padding=0),
                nn.ReLU(True)
            )
            
            ### Flatten layer
            self.flatten = nn.Flatten(start_dim=1)
    ### Linear p
            self.encoder_lin = nn.Sequential(
                nn.Linear(3 * 3 * 32, 128),
                nn.ReLU(True),
                nn.Linear(128, encoded_space_dim)
            )
            
        def forward(self, x):
            x = self.encoder_cnn(x)
            x = self.flatten(x)
            x = self.encoder_lin(x)
            return x
    class Decoder(nn.Module):
        
        def __init__(self, encoded_space_dim,fc2_input_dim):
            super().__init__()
            self.decoder_lin = nn.Sequential(
                nn.Linear(encoded_space_dim, 128),
                nn.ReLU(True),
                nn.Linear(128, 3 * 3 * 32),
                nn.ReLU(True)
            )
    
    
            self.unflatten = nn.Unflatten(dim=1, 
            unflattened_size=(32, 3, 3))
    
    
            self.decoder_conv = nn.Sequential(
                nn.ConvTranspose2d(32, 16, 3, 
                stride=2, output_padding=0),
                nn.BatchNorm2d(16),
                nn.ReLU(True),
                nn.ConvTranspose2d(16, 8, 3, stride=2, 
                padding=1, output_padding=1),
                nn.BatchNorm2d(8),
                nn.ReLU(True),
                nn.ConvTranspose2d(8, 1, 3, stride=2, 
                padding=1, output_padding=1)
            )
            
        def forward(self, x):
            x = self.decoder_lin(x)
            x = self.unflatten(x)
            x = self.decoder_conv(x)
            x = torch.sigmoid(x)
            return x
    

    3.初始化Loss函数和优化器

    我们需要在训练自动编码器之前定义构建块:

    · torch.device 使用 GPU 等硬件加速器训练模型

    · 将移动到设备的 Encoder 和 Decoder 网络

    · nn.MSEloss 和 torch.optim.Adam

    ### Define the loss function
    loss_fn = torch.nn.MSELoss()
    
    
    ### Define an optimizer (both for the encoder and the decoder!)
    lr= 0.001
    
    
    ### Set the random seed for reproducible results
    torch.manual_seed(0)
    
    
    ### Initialize the two networks
    d = 4
    
    
    #model = Autoencoder(encoded_space_dim=encoded_space_dim)
    encoder = Encoder(encoded_space_dim=d,fc2_input_dim=128)
    decoder = Decoder(encoded_space_dim=d,fc2_input_dim=128)
    params_to_optimize = [
        {'params': encoder.parameters()},
        {'params': decoder.parameters()}
    ]
    
    
    optim = torch.optim.Adam(params_to_optimize, lr=lr, weight_decay=1e-05)
    
    
    # Check if the GPU is available
    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
    print(f'Selected device: {device}')
    
    
    # Move both the encoder and the decoder to the selected device
    encoder.to(device)
    decoder.to(device)
    

    4. 训练和评估模型

    我们定义了一个函数来训练 AE 模型。首先,我们将输入图像传递给编码器。稍后,将编码数据传递给编码器,然后我们使用 loss_fn(x_hat,x) 计算重建损失。在清除梯度以不累积其他值后,我们执行反向传播,最后通过调用 opt.step() 计算梯度。

    ### Training function
    def train_epoch_den(encoder, decoder, device, dataloader, loss_fn, optimizer,noise_factor=0.3):
        # Set train mode for both the encoder and the decoder
        encoder.train()
        decoder.train()
        train_loss = []
        # Iterate the dataloader (we do not need the label values, this is unsupervised learning)
        for image_batch, _ in dataloader: # with "_" we just ignore the labels (the second element of the dataloader tuple)
            # Move tensor to the proper device
            image_noisy = add_noise(image_batch,noise_factor)
            image_noisy = image_noisy.to(device)    
            # Encode data
            encoded_data = encoder(image_noisy)
            # Decode data
            decoded_data = decoder(encoded_data)
            # Evaluate loss
            loss = loss_fn(decoded_data, image_noisy)
            # Backward pass
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            # Print batch loss
            print('\t partial train loss (single batch): %f' % (loss.data))
            train_loss.append(loss.detach().cpu().numpy())
    
    
        return np.mean(train_loss)
    

    创建训练函数后,我们定义一个函数来评估模型的性能。和以前一样,我们将图像传递给编码器。编码后的图像被传递给解码器。然后,我们将所有图像批次和重建存储到两个不同的列表中,这将用于计算测试损失。

    ### Testing function
    def test_epoch(encoder, decoder, device, dataloader, loss_fn):
        # Set evaluation mode for encoder and decoder
        encoder.eval()
        decoder.eval()
        with torch.no_grad(): # No need to track the gradients
            # Define the lists to store the outputs for each batch
            conc_out = []
            conc_label = []
            for image_batch, _ in dataloader:
                # Move tensor to the proper device
                image_batch = image_batch.to(device)
                # Encode data
                encoded_data = encoder(image_batch)
                # Decode data
                decoded_data = decoder(encoded_data)
                conc_out.append(decoded_data.cpu())
                conc_label.append(image_batch.cpu())
            # Create a single tensor with all the values in the lists
            conc_out = torch.cat(conc_out)
            conc_label = torch.cat(conc_label) 
            # Evaluate global loss
            val_loss = loss_fn(conc_out, conc_label)
        return val_loss.data
    

    我们还希望在训练的每个时期看到重建的图像。目标是了解自动编码器如何从输入图像中学习。

    def plot_ae_outputs(encoder,decoder,n=5):
        plt.figure(figsize=(10,4.5))
        for i in range(n):
          ax = plt.subplot(2,n,i+1)
          img = test_dataset[i][0].unsqueeze(0).to(device)
          encoder.eval()
          decoder.eval()
          with torch.no_grad():
             rec_img  = decoder(encoder(img))
          plt.imshow(img.cpu().squeeze().numpy(), cmap='gist_gray')
          ax.get_xaxis().set_visible(False)
          ax.get_yaxis().set_visible(False)  
          if i == n//2:
            ax.set_title('Original images')
          ax = plt.subplot(2, n, i + 1 + n)
          plt.imshow(rec_img.cpu().squeeze().numpy(), cmap='gist_gray')  
          ax.get_xaxis().set_visible(False)
          ax.get_yaxis().set_visible(False)  
          if i == n//2:
             ax.set_title('Reconstructed images')
        plt.show()
    

    让我们将测试代码分解成小块:

    · test_dataset[i][0].unsqueeze(0) 用于从测试数据集中提取第 i 个图像,然后        在0 轴上增加 1 维。需要此步骤将图像传递给自动编码器。

    · decoder(encoder(img))用于获取重建图像

    · plt.imshow(img.cpu().squeeze().numpy()) 用于绘制原始图像。squeeze()删除之前添加的维度,这对于可视化图像至关重要。numpy() 将张量转换为 ndarray,这是函数 plt.imshow 接受的唯一对象类型。numpy() 将张量对象的副本返回到 CPU 内存中。

    现在我们终于可以开始在训练集上训练模型并在验证集上对其进行评估了。

    num_epochs = 30
    diz_loss = {'train_loss':[],'val_loss':[]}
    for epoch in range(num_epochs):
       train_loss =train_epoch(encoder,decoder,device,
       train_loader,loss_fn,optim)
       val_loss = test_epoch(encoder,decoder,device,test_loader,loss_fn)
       print('\n EPOCH {}/{} \t train loss {} \t val loss {}'.format(epoch + 1, num_epochs,train_loss,val_loss))
       diz_loss['train_loss'].append(train_loss)
       diz_loss['val_loss'].append(val_loss)
       plot_ae_outputs(encoder,decoder,n=5)
    

    可以注意到自动编码器能够在 30 个 epoch 后很好地重建图像,即使存在一些缺陷。但是由于这个模型真的很简单,所以它的表现非常好。现在模型已经训练完毕,我们要对测试集进行最终评估:

    test_epoch(encoder,decoder,device,test_loader,loss_fn).item()
    

    我们还可以观察重建损失如何随着epoch的推移而减少:

    # Plot losses
    plt.figure(figsize=(10,8))
    plt.semilogy(diz_loss['train_loss'], label='Train')
    plt.semilogy(diz_loss['val_loss'], label='Valid')
    plt.xlabel('Epoch')
    plt.ylabel('Average Loss')
    #plt.grid()
    plt.legend()
    #plt.title('loss')
    plt.show()
    

    5. 从潜在代码生成新样本

    为了从潜在代码生成新图像,我们定义了一个从潜在空间均匀采样的函数。这些样本将被传递到解码器,解码器将创建重建的图像。

    def plot_reconstructed(decoder, r0=(-5, 10), r1=(-10, 5), n=12):
        plt.figure(figsize=(20,8.5))
        w = 28
        img = np.zeros((n*w, n*w))
        for i, y in enumerate(np.linspace(*r1, n)):
            for j, x in enumerate(np.linspace(*r0, n)):
                z = torch.Tensor([[x, y]]).to(device)
                x_hat = decoder(z)
                x_hat = x_hat.reshape(28, 28).to('cpu').detach().numpy()
                img[(n-1-i)*w:(n-1-i+1)*w, j*w:(j+1)*w] = x_hat
        plt.imshow(img, extent=[*r0, *r1], cmap='gist_gray')
        
    plot_reconstructed(decoder, r0=(-1, 1), r1=(-1, 1))
    

    要绘制这些重建图,我们需要知道潜在空间的范围,您可以在下面的潜在空间可视化部分中看到。我们可以观察到,在图的左下角,数字没有意义。实际上,点 (-1,-1) 处的潜在空间是空的。

    6. 用 t-SNE 可视化潜在空间

    之后我们可以观察动态可视化以查看自编码器学习到的潜在空间。首先,我们使用测试集创建编码样本。

    encoded_samples = []
    for sample in tqdm(test_dataset):
        img = sample[0].unsqueeze(0).to(device)
        label = sample[1]
        # Encode image
        encoder.eval()
        with torch.no_grad():
            encoded_img  = encoder(img)
        # Append to list
        encoded_img = encoded_img.flatten().cpu().numpy()
        encoded_sample = {f"Enc. Variable {i}": enc for i, enc in enumerate(encoded_img)}
        encoded_sample['label'] = label
        encoded_samples.append(encoded_sample)
    encoded_samples = pd.DataFrame(encoded_samples)
    encoded_samples
    

    让我们使用颇有技巧的表达库绘制潜在的空间表示:

    import plotly.express as px
    
    
    px.scatter(encoded_samples, x='Enc. Variable 0', y='Enc. Variable 1', 
               color=encoded_samples.label.astype(str), opacity=0.7)
    

    从这个图中,我们看到相似的数字聚集在一起。例如“4”与“9”和“5”重叠。

    为了让表示更容易阅读,我们可以应用称为 t-SNE 的降维来可视化二维空间中的潜在代码。出于这个原因,我们将固定组件的数量等于 2。

    from sklearn.manifold import TSNE
    
    
    tsne = TSNE(n_components=2)
    tsne_results = tsne.fit_transform(encoded_samples.drop(['label'],axis=1))
    fig = px.scatter(tsne_results, x=0, y=1,
                     color=encoded_samples.label.astype(str),
                     labels={'0': 'tsne-2d-one', '1': 'tsne-2d-two'})
    fig.show()
    

    可以看到它清楚地区分了一个数字。有一些例外,点属于其他类别,但与之前的表示相比,t-SNE 仍然是一个改进。

    总结

    恭喜!你已经学会了实现卷积自编码器。自编码器提供了一种压缩图像并提取最重要信息的方法。该模型还有许多扩展以提高性能,其中一些是降噪自动编码器、变分自动编码器和生成对抗网络。 

    ·  END  ·

    HAPPY LIFE

    展开全文
  • 卷积神经网络自编码器实现与结果分析 (1)实现框架:Keras (2)数据集:Mnist 手写数字识别 (3)关键代码: 环境配置 使用conda,新建一个keras 和tensorflow的环境 在win cmd 终端中建立一个新的环境 新建用pip...

    卷积神经网络自编码器实现与结果分析

    (1)实现框架:Keras
    (2)数据集:Mnist 手写数字识别
    (3)关键代码:

    环境配置

    使用conda,新建一个keras 和tensorflow的环境

    在win cmd 终端中建立一个新的环境
    新建用pip安装三个包

    C:\Users\TJ619\Downloads\autoencoder-master>conda create -n keras_only python=3.9
    (base) C:\Users\TJ619\Downloads\autoencoder-master>conda activate keras_only
    (keras_only) C:\Users\TJ619\Downloads\autoencoder-master> conda install pip
    (keras_only) C:\Users\TJ619\Downloads\autoencoder-master>pip install keras tensorflow matplotlib
    (keras_only) C:\Users\TJ619\Downloads\autoencoder-master>conda list
    # packages in environment at C:\Users\TJ619\AppData\Local\Continuum\anaconda3\envs\keras_only:   
    #
    # Name                    Version                   Build  Channel
    absl-py                   1.0.0                    pypi_0    pypi
    astunparse                1.6.3                    pypi_0    pypi
    ca-certificates           2021.10.26           haa95532_2    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    cachetools                4.2.4                    pypi_0    pypi
    certifi                   2021.10.8        py39haa95532_0    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    charset-normalizer        2.0.9                    pypi_0    pypi
    cycler                    0.11.0                   pypi_0    pypi
    flatbuffers               2.0                      pypi_0    pypi
    fonttools                 4.28.3                   pypi_0    pypi
    gast                      0.4.0                    pypi_0    pypi
    google-auth               2.3.3                    pypi_0    pypi
    google-auth-oauthlib      0.4.6                    pypi_0    pypi
    google-pasta              0.2.0                    pypi_0    pypi
    grpcio                    1.42.0                   pypi_0    pypi
    h5py                      3.6.0                    pypi_0    pypi
    idna                      3.3                      pypi_0    pypi
    importlib-metadata        4.8.2                    pypi_0    pypi
    keras                     2.7.0                    pypi_0    pypi
    keras-preprocessing       1.1.2                    pypi_0    pypi
    kiwisolver                1.3.2                    pypi_0    pypi
    libclang                  12.0.0                   pypi_0    pypi
    markdown                  3.3.6                    pypi_0    pypi
    matplotlib                3.5.0                    pypi_0    pypi
    numpy                     1.21.4                   pypi_0    pypi
    oauthlib                  3.1.1                    pypi_0    pypi
    openssl                   1.1.1l               h2bbff1b_0    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    opt-einsum                3.3.0                    pypi_0    pypi
    packaging                 21.3                     pypi_0    pypi
    pillow                    8.4.0                    pypi_0    pypi
    pip                       21.2.4           py39haa95532_0    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    protobuf                  3.19.1                   pypi_0    pypi
    pyasn1                    0.4.8                    pypi_0    pypi
    pyasn1-modules            0.2.8                    pypi_0    pypi
    pyparsing                 3.0.6                    pypi_0    pypi
    python                    3.9.7                h6244533_1    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    python-dateutil           2.8.2                    pypi_0    pypi
    requests                  2.26.0                   pypi_0    pypi
    requests-oauthlib         1.3.0                    pypi_0    pypi
    rsa                       4.8                      pypi_0    pypi
    setuptools                58.0.4           py39haa95532_0    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    setuptools-scm            6.3.2                    pypi_0    pypi
    six                       1.16.0                   pypi_0    pypi
    sqlite                    3.36.0               h2bbff1b_0    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    tensorboard               2.7.0                    pypi_0    pypi
    tensorboard-data-server   0.6.1                    pypi_0    pypi
    tensorboard-plugin-wit    1.8.0                    pypi_0    pypi
    tensorflow                2.7.0                    pypi_0    pypi
    tensorflow-estimator      2.7.0                    pypi_0    pypi
    tensorflow-io-gcs-filesystem 0.22.0                   pypi_0    pypi
    termcolor                 1.1.0                    pypi_0    pypi
    tomli                     1.2.2                    pypi_0    pypi
    typing-extensions         4.0.1                    pypi_0    pypi
    tzdata                    2021e                hda174b7_0    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    urllib3                   1.26.7                   pypi_0    pypi
    vc                        14.2                 h21ff451_1    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    vs2015_runtime            14.27.29016          h5e58377_2    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    werkzeug                  2.0.2                    pypi_0    pypi
    wheel                     0.37.0             pyhd3eb1b0_1    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    wincertstore              0.2              py39haa95532_2    http://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
    wrapt                     1.13.3                   pypi_0    pypi
    zipp                      3.6.0                    pypi_0    pypi
    

    在这里插入图片描述

    I)在 Keras 编码中,反卷积的实现代码便是卷积操作,具体解释详见上述博
    客。https://blog.csdn.net/quiet_girl/article/details/84579038 。
    ii)UpSampling2D()实现的是反平均卷积的操作。
    iii) autoencoder.summary()如下:

    o enable them in other operations, rebuild TensorFlow with the appropriate compiler fl
    Model: "model"
    _________________________________________________________________
     Layer (type)                Output Shape              Param #
    =================================================================
     input_1 (InputLayer)        [(None, 28, 28, 1)]       0
    
     conv2d (Conv2D)             (None, 28, 28, 16)        160
    
     max_pooling2d (MaxPooling2D  (None, 14, 14, 16)       0
     )
    
     conv2d_1 (Conv2D)           (None, 14, 14, 8)         1160
    
     max_pooling2d_1 (MaxPooling  (None, 7, 7, 8)          0
     2D)
    
     conv2d_2 (Conv2D)           (None, 7, 7, 8)           584
    
     up_sampling2d (UpSampling2D  (None, 14, 14, 8)        0
     )
    
     conv2d_3 (Conv2D)           (None, 14, 14, 16)        1168
    
     up_sampling2d_1 (UpSampling  (None, 28, 28, 16)       0
     2D)
    
     conv2d_4 (Conv2D)           (None, 28, 28, 1)         145
    
    =================================================================
    Total params: 3,217
    Trainable params: 3,217
    Non-trainable params: 0
    Non-trainable params: 0
    _________________________________________________________________
    Epoch 1/20                                                            
    

    在这里插入图片描述

    整体程序如下

    # python3
    # -*- coding: utf-8 -*-
    # @Author  : ziyue
    # @Time    : 2021 12 10
    """
    Convolutional Autoencoder.
    """
    import numpy as np
    
    from keras.datasets import mnist
    from keras.models import Model
    from keras.layers import Conv2D, MaxPool2D,Input, UpSampling2D
    import matplotlib.pyplot as plt
    
    np.random.seed(33)   # random seed,to reproduce results.
    
    
    
    def train(x_train):
        """
        build autoencoder.
        :param x_train:  the train data
        :return: encoder and decoder
        """
        # input placeholder
        input_image = Input(shape=(28, 28, 1))
    
        # encoding layer
        x = Conv2D(CHANNEL_1, (3, 3), activation='relu', padding="same")(input_image)
        x = MaxPool2D((2, 2), padding='same')(x)
        x = Conv2D(CHANNEL_2, (3, 3), activation='relu', padding='same')(x)
        encoded = MaxPool2D((2, 2), padding='same')(x)
    
        # decoding layer
        x = Conv2D(CHANNEL_2, (3, 3), activation='relu', padding='same')(encoded)
        x = UpSampling2D((2, 2))(x)
        x = Conv2D(CHANNEL_1, (3, 3),activation='relu', padding='same')(x)
        x = UpSampling2D((2, 2))(x)
        decoded = Conv2D(CHANNEL_OUTPUT, (3, 3), activation='sigmoid', padding='same')(x)
    
        # build autoencoder, encoder, decoder
        autoencoder = Model(inputs=input_image, outputs=decoded)
        encoder = Model(inputs=input_image, outputs=encoded)
    
        # compile autoencoder
        autoencoder.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    
        autoencoder.summary()
    
        # training
        # need return history, otherwise can not use history["acc"]
        history_record = autoencoder.fit(x_train, x_train, epochs=EPOCHS, batch_size=BATCH_SIZE, shuffle=True, )
    
        return encoder, autoencoder, history_record
    
    def plot_accuray(history_record):
        """
        plot the accuracy and loss line.
        :param history_record:
        :return:
        """
        accuracy = history_record.history["accuracy"]
        loss = history_record.history["loss"]
        epochs = range(len(accuracy))
        plt.plot(epochs, accuracy, 'bo', label='Training accuracy')
        plt.title('Training accuracy')
        plt.legend()
        plt.figure()
        plt.plot(epochs, loss, 'bo', label='Training loss')
        plt.title('Training loss')
        plt.legend()
        plt.show()
    
    def show_images(decode_images, x_test):
        """
        plot the images.
        :param decode_images: the images after decoding
        :param x_test: testing data
        :return:
        """
        n = 10
        plt.figure(figsize=(20, 4))
        for i in range(n):
            ax = plt.subplot(2, n, i+1)
            ax.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)
            ax.imshow(decode_images[i].reshape(28, 28))
            plt.gray()
            ax.get_xaxis().set_visible(False)
            ax.get_yaxis().set_visible(False)
        plt.show()
    
    
    
    if __name__ == '__main__':
        CHANNEL_1 = 16
        CHANNEL_2 = 8
        CHANNEL_OUTPUT = 1
        EPOCHS = 1
        BATCH_SIZE = 64
        # Step1: load data  x_train: (60000, 28, 28), y_train: (60000,) x_test: (10000, 28, 28), y_test: (10000,)
        (x_train, y_train), (x_test, y_test) = mnist.load_data()
    
        # Step2: normalize
        x_train = x_train.astype('float32') / 255.
        x_test = x_test.astype('float32') / 255.
    
        # Step3: reshape data, x_train: (60000, 28, 28, 1), x_test: (10000, 28, 28, 1), one row denotes one sample.
        x_train = x_train.reshape((x_train.shape[0], 28, 28, 1))
        x_test = x_test.reshape((x_test.shape[0], 28, 28, 1))
    
        # Step4: train
        encoder, autoencoder, history_record = train(x_train=x_train)
    
        # show images
        decode_images = autoencoder.predict(x_test)
        show_images(decode_images, x_test)
        plot_accuray(history_record)
    
    
    
    
    

    论文名称:Stacked Convolutional Auto-Encoders for
    Hierarchical Feature Extraction

    论文地址:https://people.idsia.ch//~ciresan/data/icann2011.pdf
    摘要:

    我们提出了一种新颖的卷积自动编码器(CAE),用于 无监督特征学习。一堆 CAE 形成一个卷积 神经网络(CNN)。每个 CAE 都使用传统的在线训练 没有额外的正则化项的梯度下降。最大池化 层对于学习生物学上合理的特征是必不可少的 以前的方法发现的那些。用 a 的过滤器初始化 CNN 训练有素的 CAE 堆栈在数字 (MNIST) 和 对象识别 (CIFAR10) 基准。

    介绍:

    无监督学习方法的主要目的是从未标记的数据中提取普遍有用的特征,检测和去除输入冗余,以及
    仅保留数据的基本方面以稳健和有区别的表示。无监督方法已在许多科学中常规使用和工业应用。在神经网络架构的背景下,无监督层可以相互堆叠以构建深层层次结构[7]。输入层激活被馈送到第一层,它馈送下一层,并且
    依此类推,对于层次结构中的所有层。可以训练深度架构无监督的逐层时尚,然后通过反向传播进行微调以成为分类器 [9]。无监督初始化倾向于避免局部最小值和提高网络的性能稳定性[6]。

    3 卷积自编码器 (CAE) 全连接 AE 和 DAE 都忽略了 2D 图像结构。这不是 只是在处理实际大小的输入时出现问题,而且还引入了 参数中的冗余,迫使每个特征都是全局的(即跨越 整个视野)。然而,视觉和物体识别的趋势采用 最成功的模型 [17,25] 是发现在整个输入中重复的局部特征。 CAE 与传统 AE 的不同之处在于它们的 权重在输入中的所有位置之间共享,从而保持空间局部性。 因此重建是由于基本图像块的线性组合 基于潜在代码。

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    结论
    我们介绍了卷积自动编码器,这是一种用于分层特征提取的无监督方法。它学习生物学上合理的过滤器。一个CNN可以由 CAE 堆栈初始化。虽然 CAE 的过完备隐藏表示使学习比标准自动编码器更难,但好的过滤器
    如果我们使用最大池化层,就会出现,这是一种强制执行稀疏代码的优雅方式无需通过反复试验设置任何正则化参数。预训练CNN 的性能往往略胜于随机初始化的网络,但始终如一。我们的 CIFAR10 结果是任何在原始数据上训练的无监督方法的最佳结果数据,并接近该基准测试的最佳发布结果.

    展开全文
  • 基于栈自编码器的图像分类器林丽惠1,2,4,殷瑞1,3,李绍滋1,3*,苏松志1,3,曹...基于一个性能优异的分类器与特征表示对图像分类系统同等重要的思想,提出了基于卷积特征的栈自编码器(stackedautoencoderonconvolutionalf...

    基于栈自编码器的图像分类器

    林丽惠

    1,2,4,

    1,3,

    李绍滋

    1,3 *,

    苏松志

    1,3,

    曹冬林

    1,3

    【摘

    要】

    摘要:

    图像分类问题包含两个重要的部分

    :

    特征提取器和分类器.多

    年来研究人员一直将精力投入到特征表示中

    ,

    对于分类器却仅进行局部调参.基

    于一个性能优异的分类器与特征表示对图像分类系统同等重要的思想

    ,

    提出了基

    于卷积特征的栈自编码器

    (stacked

    autoencoder

    on

    convolutional

    feature

    maps

    SACF)

    的分类系统,并在数据集

    CUB-200

    VGG-flower

    上进行了实

    ,

    对比了

    SACF

    与基于卷积特征和多层感知机的卷积神经网络

    (CNN)

    分类系统

    的分类效果,实验结果表明

    SACF

    具有更优的分类效果.

    【期刊名称】

    厦门大学学报(自然科学版)

    【年

    (

    ),

    期】

    2018(057)001

    【总页数】

    6

    【关键词】

    图像分类

    ;

    特征提取

    ;

    分类器

    ;

    栈自编码器

    ;

    卷积神经网络

    分类问题是计算机视觉的一个经典问题

    ,

    大多数视觉任务最终都能转换为分类问

    ,

    如目标检测、人脸识别、行为识别等.分类系统可分为两部分

    :

    特征提取和分

    类.首先提取图像特征

    ,

    包括局部特征或全局特征

    ,

    然后将提取的特征作为分类器

    的输入.传统的特征提取方法大多根据经验手动设计

    ,

    如局部二值模式

    (LBP)[1]

    (SIFT)[2]

    (BRIEF)[3]

    BRIEF(ORB)[4]

    、二元提升算法

    (BINBOOST)[5]

    等.而分类器一般采用线性支

    持向量机

    (support

    vector

    machine,SVM)[6]

    、非线性的提升

    (boost)

    分类器或

    者核支持向量机

    (kernel SVM)

    等.

    近几年,卷积神经网络

    (CNN)[7]

    在目标分类问题上取得了巨大的成功

    ,

    也引领了

    展开全文
  • 本文主要介绍的就是关于卷积编码的相关介绍,希望通过本文能让你对卷积编码有更深的认识。卷积编码在信道编码研究的初期,人们探索、研究出各种各样的编码构造方法,其中包括卷积码。早在1955年,P.Elias首先提出了...

    在现代数字通信中,为降低数据传输的误码率,提高通信质量及其可靠性,常在通信中采用纠错编码技术。

    本文主要介绍的就是关于卷积编码的相关介绍,希望通过本文能让你对卷积编码有更深的认识。

    卷积编码

    在信道编码研究的初期,人们探索、研究出各种各样的编码构造方法,其中包括卷积码。早在1955年,P.Elias首先提出了卷积码。但是它又经历了十几年的研究以后,才开始具备应用价值。在这十几年期间,J.M.Wozencraft提出了适合大编码约束度的卷积码的序列译码,J.L.Massey提出了实现简单的门限译码,A.J.Viterbi提出了适合小编码约束度的卷积码Viterbi算法。20年后,即1974年,L.R.Bahl等人又提出一种支持软输入软输出(SISO,Soft-InputSoft-Output)的最大后验概率(MAP,MaximumAPosteriori)译码——BCJR算法。其中,Viterbi算法有力地推动了卷积码的广泛应用,BCJR算法为后续Turbo码的发现奠定了基础。

    fb71db4fd34adbd9f52ddcaf9544fa54.png

    编码技术

    在卷积码的编码过程中,对输入信息比特进行分组编码,每个码组的编码输出比特不仅与该分组的信息比特有关,还与前面时刻的其他分组的信息比特有关。同样,在卷积码的译码过程中,不仅从当前时刻收到的分组中获取译码信息,还要从前后关联的分组中提取相关信息。正是由于在卷积码的编码过程中充分利用了各组的相关性,使得卷积码具有相当好的性能增益。

    编码器图中,编码器的每组输入包含k0个信息比特,第一组寄存器单元存储当前时刻的k0个信息比特,而其他组寄存器单元存储前面时刻的(K−1)k0个信息比特。编码器有n0个编码输出,每个编码输出Yi由当前时刻的输入信息分组以及其他(K−1)个寄存器单元内的信息分组根据相应的连接关系进行模2运算来确定。

    因此,一般定义K为编码约束度,说明编码过程中相互关联的分组个数,定义m=k-1为编码存储级数,码率R=k0/n0,这类码通常称为(n0,k0,K)卷积码。在许多实际应用场合,往往采用编码约束度比较小、码率为的卷积码。如图3-29所示的两种卷积码(2,1,9)和(3,1,9),它们的存储级数都是8,加法器完成二进制加法(模2加)。图中省略了存储当前时刻输入的寄存器单元。在图3-29(a)中,(2,1,9)卷积码编码器有一个输入端口、两个输出端口,这两个输出端口分别对应两个生成多项式(使用八进制表示):561和753。该码率是1/2。在图3-29(b)中,(3,1,9)卷积码编码器有一个输入端口、3个输出端口,这3个输出端口分别对应3个生成多项式(使用八进制表示):557、663和711。该码率是1/3。

    TD-LTE系统中采用了(3,1,7)卷积码,存储级数是6,使用了6个寄存器。这个卷积码的主要优点包括最优距离谱、咬尾编码、译码复杂度小。具体描述见后续章节内容。另外,卷积码也可以按照其他方式进行分类,比如系统码或者非系统码,递归码或者非递归码,最大自由距离码或者最优距离谱码。常用的卷积码一般是非递归的非系统码,而Turbo码常常使用递归的系统卷积码。

    咬尾编码通常卷积码编码器开始工作时都要进行初始化,常常将编码器的所有寄存器单元都进行清零处理。而在编码结束时,还要使用尾比特进行归零的结尾操作(TailedTermination)。相对于编码比特而言,尾比特增加了编码开销。TD-LTE系统的卷积码编码器采用了咬尾编码方法。

    编码器开始工作时要进行特殊的初始化,将输入信息比特的最后m个比特依次输入编码器的寄存器中,当编码结束时,编码器的结束状态与初始状态相同。由于这个编码方法没有出现尾比特,因此称为咬尾编码。咬尾编码减少了尾比特的编码开销。对于咬尾编码方法,在译码过程中,由于编码器的初始状态和结尾状态是未知的,因此就需要增加一定的译码复杂度,才能确保好的译码性能。3.性能界卷积码的性能一般使用误比特率(BER,BitErrorRate)来统计,其理论上界(UpperBound)一般使用联合界(UnionBound)来确定,即

    35258300644fd5a15350fc65960901a9.png(3-13)其中,卷积码的转移函数(TransferFunction),代表非零输入信息比特的转移分支,Y的指数表示输入信息比特的汉明重量,Z代表输出编码比特的转移分支,Z的指数表示输出编码比特的汉明重量。为了进一步分析上述性能界,一般假设最大似然译码(ML,Maximum-Likelihood)、BPSK调制和加性高斯白噪声(AWGN,AdditiveWhiteGaussianNoise)信道,则有

    7aa7cd8c29c260e9a3124a6542f66908.png

    (3-14)其中,Bd是所有重量为d的码字的非零信息比特的重量,为卷积码的自由距离。当信噪比很高时,则式(3-14)近似为

    f946599da4f05bdc9db6ff5a793f749d.png(3-15)BPSK调制性能为

    62d9e5dbab21fc1e9db80da10bb3ce6d.png(3-16)考虑到误码性能主要是指数项占据主导作用,与未编码系统相比,卷积码的编码增益为

    5bb78aa6abae456c961135636154ec38.png(3-17)式(3-17)说明卷积码的渐近性能主要是由自由距离()决定的。因此,相对而言,卷积码的自由距离越大,其性能越好。以上述二进制卷积码(2,1,9)和(3,1,9)为例,自由距离分别为12和18,编码增益都为7.78dB。实际上,性能最佳的卷积码往往具有最优的距离谱(ODS,OptimumDistanceSpectrum)或者重量分布,而且,具有最优距离谱的卷积码也具有最大的自由距离(MFD,MaximumFreeDistance)。TD-LTE系统采用了最优距离谱的卷积码。

    基于VHDL的卷积编码实现

    在现代数字通信中,为降低数据传输的误码率,提高通信质量及其可靠性,常在通信中采用纠错编码技术。其中卷积码就是一种具有较强纠错能力的纠错码。由于Vitebrbi译码算法比较容易实现,卷积码得到了广泛应用。本课题简明地介绍了用EDA技术实现卷积码编码器的实现。卷积码纠错性能常常优于分组码,是一种性能优越的信道编码。由于码字之间的相关性,其编码器要利用移位寄存器来存储状态。

    随着纠错编码理论研究的不断深入,卷积码的实际应用越来越广泛。卷积码作为通信系统中重要的编码方式,以其良好的编码性能,合理的译码方式,被广泛应用。本文在阐述卷积码编码器基本工作原理的基础上,给出了(2,1,2)卷积编码器的VHDL设计,在QuartusⅡ环境下进行了波形功能仿真,并下载到EP1C6T144C8N芯片上进行验证,最终实现输入四位序列,编码输出八位通过指示灯显示。

    967dab48a2dc5b95971b04fcc5b01afd.png

    4ee3048791c06f7b9375ebd0b8810ffb.png

    卷积编码的编码约束长度定义为:串行输入比特通过编码其所需的移位次数,它表示编码过程中相互约束的分支码数,所以具有m级移位寄存器的编码器得约束长度为m十1,有时也说(m十1)n为卷积编码的编码约束长与分组编码一样。

    卷积编码的编码效率也定义为R=k/η,与分组码具有固定码长η不同,卷积码没有,我们可通过周期性地截断来获得分组长度为了达到清空编码移位寄存器数据bit的目的,需要在输入数据序列末尾附加若于0bit。由于附加的0不包含任何信息,因而,有效编码效率降至kn以如果截断周期取值较大,则有效编码效率会逼近kn。

    bc9e24377c7ae1f382f2b09a3b198a46.png

    b8a9025563d06eb0c6ffaa7f7014adce.png

    图中的小框表示寄存器的状态,连接小框的箭头表示状态转移的方向,两线旁的数字表示:输出分支码字/输入信息比特。状态图简明的表示了在某一时刻编码器的输入比特和输出分支码字的关系。

    38f3cdbd6ea566c78fba00ed3f750acb.png

    结语

    关于卷积编码的相关介绍就到这了,如有不足之处欢迎指正。

    展开全文
  • 文章目录前言自动编码器介绍自动编码器重建手写数字关于损失函数重建结果这部分实验代码 前言 先来看看实验: 我们使用 MNIST 手写数字,测试通过自动编码器和对抗性自动编码器学习重建恢复效果。 原始图像: 自动...
  • 自编码器处理数据

    2021-05-25 09:47:03
    自编码器组成: 1、正向卷积编码器(Encoder) 2、反向卷积的解码器(Decoder) 自编码器流程: softmax 输入数据的仿制品 输入数据 Encoder Decoder 流程一:Encoder是一个正向卷积的神经网络,通过卷积层,池化...
  • 本文主要分享自编码器、变分自编码器和条件变分自编码器的相关知识以及在实际实践中的应用技巧,原创不易转载请注明出处,原稿获取请关注公众号【AI机器学习与知识图谱】回复:自编码器,下面首先简单认识一下:...
  • 自编码器的介绍1)传统自编码器2)降噪自编码器3)卷积自编码器2.自编码器的应用1)文字检索(Text Retrieval)2)相识图像检索(Similar Image Search)3)模型的预训练(Pre-training)3.自编码器的实现参考代码...
  • 深度学习--自编码器(AutoEncoder)

    千次阅读 2021-12-17 15:48:39
    自编码器自编码器是用于无监督学习,高效编码的神经网络,自动编码器的目的就在于,学习一组数据的编码,通常用于数据的降维,编码是一种无监督的算法,网络分为:输入层,隐藏层(编码层),解码层,该网络的...
  • 自动编码器(AE,DAE,CAE,SAE)的方法介绍与简单实现(附代码)自动编码器的发展简述自动编码器(Auto-Encoders,AE)降噪编码(Denoising Auto-Encoders, DAE)(2008)堆叠降燥自动编码器 (Stacked Denoising Auto-Encoders,...
  • 监督学习是训练机器学习模型的传统方法,它在训练时每一个观察到的数据都需要有标注好的标签。...Facebook AI的kaiming大神等人提出了一种带掩码自编码器(MAE)²,它基于(ViT)³架构。他们的方法在Image
  • 讲述监督学习与无监督学习,判别模型与生成模型,无监督生成模型的原理,分类…… 部分PPT预览如下: 下面是几分钟的预览,大家可以试听: 点击边框调出视频工具条 第2节:自编码器与变分自编码器 本次课程是阿里...
  • 自编码器在实际应用中用的很少,2012年人们发现在卷积神经网络中使用自编码器做逐层预训练可以训练深度网络,但很快人们发现良好的初始化策略在训练深度网络上要比费劲的逐层预训练有效得多,2014年出现的Batch ...
  • 目录自编码器与变分自编码器自编码器变分自编码器图变分自编码器 自编码器与变分自编码器 自编码器 自编码器即 Auto Encoders,简称 AE,假设存在一个神经网络: 容易发现,该神经网络的输入与输出维度相同,隐藏层...
  • 根据所解决的问题不同 ,编码可以有许多种不同形式的变形,例如: 去噪自编码器(DAE)、变分自编码器 (VAE)、收缩自编码器(CAE)和稀疏自编码器等 。下面我们先从去噪编码讲起。一 去噪编码要想取得好的特征只...
  • 在这篇论文中,他们提出一个无监督版本的胶囊网络,通过可查看所有部件的神经编码器,进而推断物体胶囊的位置与姿势。该编码器通过解码器进行反向传播训练,通过混合式姿势预测方案来预测已发现部件的姿势。同样是...
  • 简介我最近的一篇文章是关于卷积网络、它的工作和组件:在本文中,我们将使用卷积神经网络执行图像分类,并详细了解所有步骤。因此,如果你对此不熟悉,请继续阅读。简而言之,CNN 是一种深度学习...
  • 卷积神经网络(CNN)实现CIFAR100类别分类 1. CIFAR100数据集介绍 这个数据集就像CIFAR-10,除了它有100个类,每个类包含600个图像。,每类各有500个训练图像和100个测试图像。CIFAR-100中的100个类被分成20个超类。...
  • 随着这几年深度学习的出现,人工智能也得到了更好的发展, 不知不觉已进入我们的生活,并且一点一点地影响着我们....如图一个5x5的矩阵 通过一个3x3的卷积核的得到一个3x3的矩阵(为什么做卷积呢,我们把.
  • 这个核心可训练的分割引擎由一个编码器、对应解码器和一个像素级分类层组成。编码器网络的结构在拓扑结构上与的13个卷积层的VGG16网络相同。解码器网络的作用是将低分辨率编码器特征映射到与输入分辨率大小的特征,...
  • 关于使用Dense层(密集连接型网络)处理MNIST数字图像分类的问题,可以参考使用keras构建和训练mnist的神经网络。 卷积神经网络,是计算机视觉领域使用最广泛的一种深度学习模型。可以对比,使用简单的卷积神经网络...
  • 一、垃圾分类 如何通过垃圾分类管理,最大限度地实现垃圾资源利用,减少垃圾处置量,改善生存环境质量,是当前世界各国共同关注的迫切问题之一。根据国家制定的统一标准,现在生活垃圾被广泛分为四类,分别是可回收...
  • MATLAB中图分类号 TN911 文献标识码 A 文章编号 1673-9671-(2012)071-0104-021 卷积码简介1.1 卷积码的编码卷积编码器的一般形式如下图所示,包括一个由N段组成的输入移位寄存器,每段有K级,...
  • 表1十种方法的目标识别准确率一览表方法识别率(%)最大相关分类器(MCC)62.42自适应高斯分类器(AGC)85.63线性支持向量机(LSVM)86.70线性判别分析结合支持向量机(LDA)81.30主成分分析结合支持向量机(PCA)83.81深度置信...
  • 卷积神经网络(人马分类)

    千次阅读 2021-01-25 22:00:31
    class_mode:"categorical","binary","sparse"或None之一,默认为”categorical",该参数决定了返回的标签数组的形式,"categorical"会返回2D的one-hot编码标签(one hot编码进行数据的分类更准确,许多机器学习算法...
  •     根据最近神经网络在药物设计和灵敏度预测方面的进展,我们提出了一种新的模型,利用基于多模态注意机制的卷积编码器对抗癌化合物灵敏度进行可解释预测。我们的模型基于药物敏感性的三个关键数据:化合物结构...
  • 深度学习入门实践之基于CNN的水果分类 主要环境配置 win10,pycharm Python3.6 keras2.2.0 numpy1.16.0 pillow8.1.1 scipy1.5.4 tensorflow-gpu1.11.0 先使用自己的配置,没有问题的话就不用更改 数据介绍 Fruits 360...
  • 【时间序列】时间卷积神经网络

    千次阅读 2021-05-20 00:16:48
    在深度学习的知识宝库中,除了前面文章中介绍的RNN,还有一个重要的分支:卷积神经网络(CNN),其广泛应用于视觉,视频等二维或者多维的图像领域。卷积网络具有深度,可并行等多种特性,这种技术...
  • encoder1.1 PCA1.2 Deep Auto-encoder2 Some Applications2.1 Text Retrieval(文字检索)2.2 Similar Image Search(相似图片搜索)2.3 Pre-training(预训练)3 De-noising Auto-encoder(加噪的自编码器)4 Auto-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,546
精华内容 11,018
关键字:

卷积自编码器分类