精华内容
下载资源
问答
  • 来源 | 数据派 THU概述自动编码器什么?自动编码器是如何工作的?本文将回答这些问题。我们将通过一个案例——如何提高模糊图像的分辨率,来探讨自动编码器的概念。简介你还记得胶卷相机的...

    来源 | 数据派 THU

    概述

    • 自动编码器是什么?自动编码器是如何工作的?本文将回答这些问题。

    • 我们将通过一个案例——如何提高模糊图像的分辨率,来探讨自动编码器的概念。

    简介

    你还记得胶卷相机的时代吗?冲洗照片是一个神秘的过程,只有摄影师和专业人士才能够驾轻就熟。大多数人的印象中只有弥漫着昏暗红光的暗室。简而言之,冲洗照片是一个耗时的过程。

    后来数码相机革命开始了,过往的时代一去不复返!我们甚至不想再打印照片了——大多数人的照片存储在智能手机、笔记本电脑或云上。

    暗室

    即使现在,我们也会遇到(点击鼠标的时候)模糊、像素化和模糊的图片。我对此深表愧疚,很多人都在努力呈现出完美的图片。这正是深度学习和自动编码器的用武之地。

    下面将介绍什么是自动编码器,以及工作原理。然后,我们会给一个实际案例——基于Python中的自动编码器提高图像的分辨率。

    必备条件:熟悉Keras,基于神经网络和卷积层的图像分类。如果你需要回顾这些概念,可以参考以下:

    • 神经网络概论(免费课程)

      https://courses.analyticsvidhya.com/courses/Introduction-to-Neural-Networks?utm_source=blog&utm_medium=what-is-autoencoder-enhance-image-resolution

    • 建立你的第一个图像分类模型

      https://www.analyticsvidhya.com/blog/2019/01/build-image-classification-model-10-minutes/?utm_source=blog&utm_medium=what-is-autoencoder-enhance-image-resolution

    目录

    一、什么是自动编码器

    二、关于图像去噪自编码器

    三、问题描述-使用自动编码器提高图像分辨率

    四、使用Python实现自动编码器

     

    一、什么是自动编码器

    Pulkit Sharma在文章中给出了如下定义:

    “自动编码器本质上是学习输入数据低维特征表示的神经网络结构。”

    自动编码器由两个相连的网络组成:编码器和解码器。编码器的目的是获取一个输入(x)并产生一个特征映射(z):

     

    这个特征映射(z)的大小或长度通常小于x。为什么是这样呢?

    因为我们只希望z捕获可以描述输入数据的有意义的变化因子,因此z的形状通常小于x。

    现在,问题是我们如何获得这个特征表示(z)?我们如何训练这个模型?为此,我们可以在提取的特征之上添加一个解码器网络,然后训练模型:

     

    二、关于图像去噪自编码器

    我们将在本文中解决的问题与图像去噪自动编码器的功能有关。下面我们详细介绍下如何利用自动编码器消除图像中的噪声。

    假设我们有一组手写数字图像,其中一些已经损坏。 以下是一些带有噪点(损坏)的图像:

    从图像中去除这种噪声被称为图像去噪问题。所需的输出是干净的图像,其中大部分噪声被去除,如下所示:

    但是自动编码器如何从图像中去除这种噪声呢?

    正如我们在上一节中已经看到的,自动编码器试图重建输入数据。因此,如果我们把损坏的图像作为输入,自动编码器将尝试重建噪声图像。

    那么,我们该怎么办呢?改变结构?答案是否定的!

    这里需要的是一个小调整。我们可以通过使用原始图像和重构图像来计算损耗,而不是使用输入和重构输出来计算损耗。下图说明了我的观点:

    图像去噪自编码器

    现在我们已经熟悉了去噪自动编码器的功能,下面我们回到期望使用自动编码器解决的问题。

     

    三、问题描述-使用自动编码器提高图像分辨率

    对这个问题相信你不会陌生。我们大多数人遇到模糊图像都很郁闷,都希望图片能清晰些。下面我们将使用自动编码器解决该问题!

    假设我们有一组低分辨率的人脸图像。我们的任务是提高这些图像的分辨率。可以借助Photoshop等照片编辑工具来完成此操作。但是,当手头有成千上万张图像时,我们需要一种更智能的方法来执行此任务。

    以下是一些示例图像及其原始图像:


    四、使用Python实现自动编码器

    让我们打开我们的Juyter Notebook并导入所需的库:

     

    • 下载数据集

    我们的研究基于流行的“Labeled Faces in the Wild”数据集。它设计用于研究无约束人脸识别问题。然而,在这里我们的目标不是人脸识别,而是建立一个模型来提高图像分辨率。

    让我们下载和提取数据集:

    # download dataset
    ! wget http://vis-www.cs.umass.edu/lfw/lfw.tgz
    # extract dataset
    ! tar -xvzf lfw.tgz
    

    此数据集将被提取到多个文件夹中。因此,捕获所有图像的文件路径是很重要的。我们可以借助glob库轻松地做到这一点。

    #capture paths to imagesface_images = glob.glob('lfw/**/*.jpg')
    

     

    • 加载和预处理图像

    图像的原始大小是250×250像素。然而,在一般配置的系统上处理这些图像需要消耗相当多的计算资源。因此,我们需要裁剪所有图像的尺寸。

     

    • 模型的训练数据准备

    接下来,我们将数据集(图像)分成两组——训练和验证。我们将使用训练集来训练我们的模型,并用验证集来评估模型的性能:

    让我们来看看数据集中的图像:

     

    这个案例的思想和去噪自动编码器非常相似。

    我们将对输入图像做一些修改,并使用原始图像计算损失。作为一个提高分辨率的任务,我们降低原始图像的分辨率,并将其输入到模型中。

    如下是处理后的输入图片:

    我们将使用下面的函数来降低所有图像的分辨率,并创建一组单独的低分辨率图像。

    • 准备输入图像

    降低所有图像的分辨率,包括训练集和验证集。

    • 模型创建

    模型的结构定义如下:

    可以根据需要修改该结构。你可以改变层的数量,改变层的类型,使用正则化,以及其他很多参数。当下我们继续使用这个结构。

    模型结构可视化对于调试(如果出现错误)很有帮助。在Keras中很容易实现,仅需执行<model name>.summary( )函数即可:

    autoencoder.summary()
    

    我们最终可以训练我们的模型:

     

    • 预测(增强图像)

    predictions = autoencoder.predict(val_x_px)
    

    后记

    本教程讲解了自动编码器,我们基于图像去噪的思路实现了提高图像分辨率。我们可以将其扩展到其他很多地方。

    例如,我们也可以使用这种技术来提高低分辨率视频的质量。 因此,即使没有给图像打上标签,我们也可以处理图像数据并解决一些实际问题。如果您还有其他基于无监督学习的图像处理案例或技术,请在下面的评论部分中共享它。

    原文标题:

    What are Autoencoders? Learn How to Enhance a Blurred Image using an Autoencoder!

    原文链接:

    https://www.analyticsvidhya.com/blog/2020/02/what-is-autoencoder-enhance-image-resolution/

    【end】
    
    ◆精彩推荐◆
    
    「AI应用技术大师课」是CSDN发起的“百万人学AI”倡议下的重要组成部分,4月份AI大师课以线上技术峰会的形式推出,来自微软、硅谷TigerGraph、北邮等产学界大咖就图计算+机器学习,语音技术、新基建+AI、AI+医疗等主题展开分享,扫描下方二维码免费报名,限时再送299元「2020AI开发者万人大会」门票一张。推荐阅读
    
    百万人学AI:CSDN重磅共建人工智能技术新生态1分钟售出5万张票!电影节抢票技术揭秘暴风集团仅剩10余人;搜狗告百度输入法侵权案再驳回;Linux 5.6发布 | 极客头条马云为什么救援世界?BTC重现“自由落体”式暴跌,原来是受这几个因素影响?一文教你如何使用 MongoDB 和 HATEOAS 创建 REST Web 服务你点的每个“在看”,我都认真当成了AI
    
    展开全文
  • 深度学习:自动编码器基础和类型

    千次阅读 2018-12-21 14:37:34
    本文转载自《机器之心》,原文链接:...Mobibit 创始人兼 CEO Pramod Chandrayan 近日在 codeburst.io 上发文对自动编码器的基础知识和类型进行了介绍并给出了代码实例。机器之心对本文进行了...

    本文转载自《机器之心》,原文链接:https://mp.weixin.qq.com/s/QuDa__mi1NX1wOxo5Ki94A ,如有侵权请联系删除。

    很显然,深度学习即将对我们的社会产生重大显著的影响。Mobibit 创始人兼 CEO Pramod Chandrayan 近日在 codeburst.io 上发文对自动编码器的基础知识和类型进行了介绍并给出了代码实例。机器之心对本文进行了编译。
    在这里插入图片描述

    继续我之前的文章《深度学习:什么&为什么?》(https://goo.gl/Ka3YoF),今天我们将进一步了解深度学习的架构类型,并详细讨论自动编码器。

    当人类大脑与深度学习机器合作时:
    在这里插入图片描述

    在我们开始揭秘深度网络之前,让我们先定义一下深度学习。根据我的理解:

    深度学习是一种先进的机器学习技术,其中存在多个彼此通信的抽象层,每一层都与前一层深度相连,并根据前一层馈送的输出进行决策。」

    Investopedia 将深度学习定义成:

    深度学习是人工智能(AI)领域中机器学习中的一个子集,其有网络状的结构,可以从非结构化或无标记的数据中以无监督的方式学习。也被称为深度神经学习或深度神经网络。」

    今天我们将深入解读无监督预训练网络(Unsupervised Pertained Networks)的工作方式。

    一、UPN:无监督预训练网络

    这种无监督学习网络可以进一步分类成

    • 自动编码器
    • 深度信念网络(DBN)
    • 生成对抗网络(GAN)

    自动编码器是一种有三层的神经网络:输入层、隐藏层(编码层)和解码层。该网络的目的是重构其输入,使其隐藏层学习到该输入的良好表征。

    自动编码器神经网络是一种无监督机器学习算法,其应用了反向传播,可将目标值设置成与输入值相等。自动编码器的训练目标是将输入复制到输出。在内部,它有一个描述用于表征其输入的代码的隐藏层。
    在这里插入图片描述

    自动编码器的目标是学习函数 h(x)≈x。换句话说,它要学习一个近似的恒等函数,使得输出 x^ 近似等于输入 x。自动编码器属于神经网络家族,但它们也和 PCA(主成分分析)紧密相关。

    关于自动编码器的一些关键事实:

    • 它是一种类似于 PCA 的无监督机器学习算法
    • 它要最小化和 PCA 一样的目标函数
    • 它是一种神经网络
    • 这种神经网络的目标输出就是其输入

    尽管自动编码器与 PCA 很相似,但自动编码器比 PCA 灵活得多。在编码过程中,自动编码器既能表征线性变换,也能表征非线性变换;而 PCA 只能执行线性变换。因为自动编码器的网络表征形式,所以可将其作为层用于构建深度学习网络。

    自动编码器的类型:

    1. 去噪自动编码器
    2. 稀疏自动编码器
    3. 变分自动编码器(VAE)
    4. 收缩自动编码器(CAE/contractive autoencoder)

    1.1、A. 去噪自动编码器

    这是最基本的一种自动编码器,它会随机地部分采用受损的输入来解决恒等函数风险,使得自动编码器必须进行恢复或去噪。

    这项技术可用于得到输入的良好表征。良好的表征是指可以从受损的输入稳健地获得的表征,该表征可被用于恢复其对应的无噪声输入。

    去噪自动编码器背后的思想很简单。为了迫使隐藏层发现更加稳健的特征并且为了防止其只是学习其中的恒等关系,我们在训练自动编码器时会让其从受损的版本中重建输入。

    应用在输入上的噪声量以百分比的形式呈现。一般来说,30% 或 0.3 就很好,但如果你的数据非常少,你可能就需要考虑增加更多噪声。

    1.2、堆叠的去噪自动编码器(SDA):
    在这里插入图片描述

    这是一种在层上使用了无监督预训练机制的去噪自编码器,其中当一层被预训练用于在之前层的输入上执行特征选择和特征提取后,后面会跟上一个监督式的微调(fine-tuning)阶段。SDA 只是将很多个去噪自动编码器融合在了一起。一旦前面 k 层训练完成,我们就可以训练第 k+1 层,因为我们现在可以根据下面的层计算代码或隐含表征。

    一旦所有层都预训练完成,网络就会进入一个被称为微调的阶段。在这里我们会为微调使用监督学习机制,以最小化被监督任务上的预测误差。然后,我们以训练多层感知器的方式训练整个网络。在这个阶段,我们仅考虑每个自动编码器的编码部分。这个阶段是有监督的,自此以后我们就在训练中使用目标类别了。

    1.3、使用代码示例解释 SDA

    这一节源自 deeplearning.net(对于想要理解深度学习的人来说,这个网站提供了很好的参考),其中使用案例对堆叠的去噪自动编码器进行了很好的解释。

    我们可以以两种方式看待堆叠的去噪自动编码器:一是自动编码器列表,二是多层感知器(MLP)。在预训练过程中,我们使用了第一种方式,即我们将我们的模型看作是一组自动编码器列表,并分开训练每个自动编码器。在第二个训练阶段,我们使用第二种方式。这两种方式是有联系的,因为:

    • 自动编码器和 MLP 的 sigmoid 层共享参数;
    • MLP 的中间层计算出的隐含表征被用作自动编码器的输入。
    class SdA(object):
       """Stacked denoising auto-encoder class (SdA)
       A stacked denoising autoencoder model is obtained by stacking several
       dAs. The hidden layer of the dA at layer `i` becomes the input of
       the dA at layer `i+1`. The first layer dA gets as input the input of
       the SdA, and the hidden layer of the last dA represents the output.
       Note that after pretraining, the SdA is dealt with as a normal MLP,
       the dAs are only used to initialize the weights.
       """
       def __init__(
           self,
           numpy_rng,
           theano_rng=None,
           n_ins=784,
           hidden_layers_sizes=[500, 500],
           n_outs=10,
           corruption_levels=[0.1, 0.1]
       ):
           """ This class is made to support a variable number of layers.
           :type numpy_rng: numpy.random.RandomState
           :param numpy_rng: numpy random number generator used to draw initial
                       weights
           :type theano_rng: theano.tensor.shared_randomstreams.RandomStreams
           :param theano_rng: Theano random generator; if None is given one is
                              generated based on a seed drawn from `rng`
           :type n_ins: int
           :param n_ins: dimension of the input to the sdA
           :type hidden_layers_sizes: list of ints
           :param hidden_layers_sizes: intermediate layers size, must contain
                                  at least one value
           :type n_outs: int
           :param n_outs: dimension of the output of the network
           :type corruption_levels: list of float
           :param corruption_levels: amount of corruption to use for each
                                    layer
             """
           self.sigmoid_layers = []
           self.dA_layers = []
           self.params = []
           self.n_layers = len(hidden_layers_sizes)
           assert self.n_layers > 0
           if not theano_rng:
           theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
           # allocate symbolic variables for the data
           self.x = T.matrix('x')   # the data is presented as rasterized images
           self.y = T.ivector('y')  # the labels are presented as 1D vector of
                                    # [int] labels
    

    self.sigmoid_layers 将会存储 MLP 形式的 sigmoid 层,而 self.dA_layers 将会存储与该 MLP 层关联的去噪自动编码器。接下来,我们构建 n_layers sigmoid 层和 n_layers 去噪自动编码器,其中 n_layers 是我们的模型的深度。我们使用了多层感知器中引入的 HiddenLayer 类,但有一项修改:我们将 tanh 非线性替换成了 logistic 函数

    在这里插入图片描述

    我们链接了 sigmoid 层来构建一个 MLP,而且我们在构建自动编码器时使得每个自动编码器的编码部分都与其对应的 sigmoid 层共享权重矩阵和偏置。

    
    for i in range(self.n_layers):
               # construct the sigmoidal layer
               # the size of the input is either the number of hidden units of
               # the layer below or the input size if we are on the first layer
               if i == 0:
                   input_size = n_ins
               else:
                   input_size = hidden_layers_sizes[i - 1]
               # the input to this layer is either the activation of the hidden
               # layer below or the input of the SdA if you are on the first
               # layer
               if i == 0:
                   layer_input = self.x
               else:
                   layer_input = self.sigmoid_layers[-1].output
               sigmoid_layer = HiddenLayer(rng=numpy_rng,input=layer_input,n_in=input_size,n_out=hidden_layers_sizes[i],activation=T.nnet.sigmoid)
               # add the layer to our list of layers
               self.sigmoid_layers.append(sigmoid_layer)
               # its arguably a philosophical question...
               # but we are going to only declare that the parameters of the
               # sigmoid_layers are parameters of the StackedDAA
               # the visible biases in the dA are parameters of those
               # dA, but not the SdA
               self.params.extend(sigmoid_layer.params)
               # Construct a denoising autoencoder that shared weights with this
               # layer
               dA_layer = dA(numpy_rng=numpy_rng,theano_rng=theano_rng,input=layer_input,n_visible=input_size,n_hidden=hidden_layers_sizes[i],W=sigmoid_layer.W,bhid=sigmoid_layer.b)
               self.dA_layers.append(dA_layer)
    

    现在我们只需要在这个 sigmoid 层上添加一个 logistic 层即可,这样我们就有了一个 MLP。我们将使用 LogisticRegression 类,这个类是在使用 logistic 回归分类 MNIST 数字时引入的。

    # We now need to add a logistic layer on top of the MLP
           self.logLayer = LogisticRegression(
               input=self.sigmoid_layers[-1].output,
               n_in=hidden_layers_sizes[-1],
               n_out=n_outs
           )
           self.params.extend(self.logLayer.params)
           # construct a function that implements one step of finetunining
           # compute the cost for second phase of training,
           # defined as the negative log likelihood
           self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
           # compute the gradients with respect to the model parameters
           # symbolic variable that points to the number of errors made on the
           # minibatch given by self.x and self.y
           self.errors = self.logLayer.errors(self.y)
    

    SdA 类也提供了一种为其层中的去噪自动编码器生成训练函数的方法。它们会作为一个列表返回,其中元素 i 是一个函数——该函数实现了训练对应于第 i 层的 dA 的步骤。

    def pretraining_functions(self, train_set_x, batch_size):
           ''' Generates a list of functions, each of them implementing one
           step in trainnig the dA corresponding to the layer with same index.
           The function will require as input the minibatch index, and to train
           a dA you just need to iterate, calling the corresponding function on
           all minibatch indexes.
           :type train_set_x: theano.tensor.TensorType
           :param train_set_x: Shared variable that contains all datapoints used
                               for training the dA
           :type batch_size: int
           :param batch_size: size of a [mini]batch
           :type learning_rate: float
           :param learning_rate: learning rate used during training for any of
                                 the dA layers
           '''
           # index to a [mini]batch
           index = T.lscalar('index')  # index to a minibatch
    

    为了修改训练过程中的受损水平或学习率,我们将它们与 Theano 变量联系了起来。

    corruption_level = T.scalar('corruption')  # % of corruption to use
           learning_rate = T.scalar('lr')  # learning rate to use
           # begining of a batch, given `index`
           batch_begin = index * batch_size
           # ending of a batch given `index`
           batch_end = batch_begin + batch_size
           pretrain_fns = []
           for dA in self.dA_layers:
               # get the cost and the updates list
               cost, updates = dA.get_cost_updates(corruption_level,learning_rate)
               # compile the theano function
               fn = theano.function(
                   inputs=[
                       index,
                       theano.In(corruption_level, value=0.2),
                       theano.In(learning_rate, value=0.1)
                   ],
                   outputs=cost,
                   updates=updates,
                   givens={
                       self.x: train_set_x[batch_begin: batch_end]
                   }
               )
               # append `fn` to the list of functions
               pretrain_fns.append(fn)
           return pretrain_fns
    

    现在任意 pretrain_fns[i] 函数都可以使用索引参数了,可选的有 corruption(受损水平)或 lr(学习率)。注意这些参数名是在它们被构建时赋予 Theano 变量的名字,而不是 Python 变量(learning_rate 或 corruption_level)的名字。在使用 Theano 时一定要记住这一点。我们用同样的方式构建了用于构建微调过程中所需函数的方法(train_fn、valid_score 和 test_score)。

    def build_finetune_functions(self, datasets, batch_size, learning_rate):
           '''Generates a function `train` that implements one step of
           finetuning, a function `validate` that computes the error on
           a batch from the validation set, and a function `test` that
           computes the error on a batch from the testing set
           :type datasets: list of pairs of theano.tensor.TensorType
           :param datasets: It is a list that contain all the datasets;
                            the has to contain three pairs, `train`,
                            `valid`, `test` in this order, where each pair
                            is formed of two Theano variables, one for the
                            datapoints, the other for the labels
           :type batch_size: int
           :param batch_size: size of a minibatch
           :type learning_rate: float
           :param learning_rate: learning rate used during finetune stage
           '''
           (train_set_x, train_set_y) = datasets[0]
           (valid_set_x, valid_set_y) = datasets[1]
           (test_set_x, test_set_y) = datasets[2]
           # compute number of minibatches for training, validation and testing
           n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
           n_valid_batches //= batch_size
           n_test_batches = test_set_x.get_value(borrow=True).shape[0]
           n_test_batches //= batch_size
           index = T.lscalar('index')  # index to a [mini]batch
           # compute the gradients with respect to the model parameters
           gparams = T.grad(self.finetune_cost, self.params)
           # compute list of fine-tuning updates
           updates = [
               (param, param - gparam * learning_rate)
               for param, gparam in zip(self.params, gparams)
           ]
           train_fn = theano.function(
               inputs=[index],
               outputs=self.finetune_cost,
               updates=updates,
               givens={
                  self.x: train_set_x[
                       index * batch_size: (index + 1) * batch_size
                   ],
                   self.y: train_set_y[
                       index * batch_size: (index + 1) * batch_size
                   ]
               },
               name='train'
           )
           test_score_i = theano.function(
               [index],
               self.errors,
               givens={
                   self.x: test_set_x[
                       index * batch_size: (index + 1) * batch_size
                   ],
                   self.y: test_set_y[
                       index * batch_size: (index + 1) * batch_size
                   ]
               },
               name='test'
           )
           valid_score_i = theano.function(
               [index],
               self.errors,
               givens={
                   self.x: valid_set_x[
                       index * batch_size: (index + 1) * batch_size
                   ],
                   self.y: valid_set_y[
                       index * batch_size: (index + 1) * batch_size
                   ]
               },
               name='valid'
           )
           # Create a function that scans the entire validation set
           def valid_score():
               return [valid_score_i(i) for i in range(n_valid_batches)]
           # Create a function that scans the entire test set
           def test_score():
               return [test_score_i(i) for i in range(n_test_batches)]
           return train_fn, valid_score, test_score
    

    注意,valid_score 和 test_score 并不是 Theano 函数,而是分别在整个验证集和整个测试集上循环的 Python 函数,可以在这些集合上产生一个损失列表。

    总结

    下面给出的几行代码就构建了一个堆叠的去噪自动编码器:

    numpy_rng = numpy.random.RandomState(89677)
       print('... building the model')
       # construct the stacked denoising autoencoder class
       sda = SdA(
           numpy_rng=numpy_rng,
           n_ins=28 * 28,
           hidden_layers_sizes=[1000, 1000, 1000],
           n_outs=10
       )
    

    该网络的训练分两个阶段:逐层的预训练,之后是微调。

    对于预训练阶段,我们将在网络的所有层上进行循环。对于每个层,我们都将使用编译过的实现 SGD 步骤的函数,以优化权重,从而降低该层的重构成本。这个函数将根据 pretraining_epochs 在训练集上执行固定数量的 epoch。

    #########################
       # PRETRAINING THE MODEL #
       #########################
       print('... getting the pretraining functions')
       pretraining_fns = sda.pretraining_functions(train_set_x=train_set_x,batch_size=batch_size)
       print('... pre-training the model')
       start_time = timeit.default_timer()
       ## Pre-train layer-wise
       corruption_levels = [.1, .2, .3]
       for i in range(sda.n_layers):
           # go through pretraining epochs
           for epoch in range(pretraining_epochs):
               # go through the training set
               c = []
               for batch_index in range(n_train_batches):
                   c.append(pretraining_fns[i](index=batch_index,
                            corruption=corruption_levels[i],
                            lr=pretrain_lr))
               print('Pre-training layer %i, epoch %d, cost %f' % (i, epoch, numpy.mean(c, dtype='float64')))
       end_time = timeit.default_timer()
       print(('The pretraining code for file ' +
              os.path.split(__file__)[1] +
              ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr)
    

    这里的微调循环和多层感知器中的微调过程很相似。唯一的区别是它使用了 build_finetune_functions 给出的函数。

    执行代码

    用户可以通过调用以下 Python CLI 来运行该代码:

    python code/SdA.py
    

    默认情况下,该代码会为每一层运行 15 次预训练 epoch,其批大小为 1。第一层的受损水平为 0.1,第二层为 0.2,第三层为 0.3。预训练的学习率为 0.001,微调学习率为 0.1。预训练耗时 585.01 分钟,每 epoch 平均 13 分钟。微调经历了 36 epoch,耗时 444.2 分钟,每 epoch 平均 12.34 分钟。最后的验证分数是 1.39%,测试分数是 1.3%。这些结果是在配置了 Intel Xeon E5430 @ 2.66GHz CPU 的机器上得到的,它有单线程的 GotoBLAS

    展开全文
  • 编码器

    千次阅读 多人点赞 2019-07-04 16:49:57
    编码器是一种机电装备, 可以用来测量机械运动或者目标位置。 大多数编码器都使用光学传感器来提供脉冲序列形式的电信号, 这些信号可以依次转换成运动、方向或位置信息。 编码器依运动方式可分为旋转编码器或是线性...

    编码器是一种机电装备, 可以用来测量机械运动或者目标位置。 大多数编码器都使用光学传感器来提供脉冲序列形式的电信号, 这些信号可以依次转换成运动、方向或位置信息。
    编码器依运动方式可分为旋转编码器或是线性编码器;按照读出方式编码器可以分为接触式和非接触式两种;按照工作原理编码器可分为增量式和绝对式两类。旋转编码器可以将旋转位置或旋转量转换成模拟(如模拟正交信号)或是数字(如USB、32位并行信号或是数字正交信号等)的电子信号, 一般会装在旋转对象上,如马达轴。
    旋转编码器是将轴或轴的角位置或运动转换为模拟或数字代码的装置。旋转编码器有两种类型:
    增量编码器:增量式旋转编码器仅在电机旋转时输出脉冲。 要使用增量编码器确定轴位置,您必须知道起始位置并使用外部电路来计算输出脉冲数。
    绝对编码器:绝对旋转编码器输出对应于旋转角度的数字代码。无需计算脉冲来了解电机轴的位置。您只需要读取编码器的数字输出。
    线性编码器是与编码位置的刻度相关联的传感器,传感器或读头。传感器读取刻度并将位置转换为模拟或数字信号,并转换为数字读数。运动取决于位置随时间的变化。
    旋转编码器可以用来测量轴的旋转运动。下图1显示了旋转编码器的基本组成部分, 包括一个发光二极管(LED)、一个码盘以及码盘背面的一个光传感器。这个码盘安置在旋转轴上,上面按一定编码形式排列着不透光和透光的扇形区域。当码盘转动时,不透光扇区能够挡光线, 而透光扇区则允许光线透过。 这样就产生了方波脉冲, 可以编译成相应的位置或运动信息。
    编码器每转通常分为100到6000个扇区。这就表明,100个扇区的编码器可以提供3.6度的精度,而6000个扇区的编码器则可以提供0.06度的精度。
    在这里插入图片描述
    图1 光电编码器的基本组成
    以上是编码器的基本知识。接下来讲一下和正交编码有关的一些知识。话不多说,先上图。增量编码器的正交输出如图2所示。
    在这里插入图片描述
    图2 增量编码器的正交输出
    正交编码是一种增量信号(增量信号如下所述)。增量编码器转动后即可产生两种方波输出A和B;这些信号共同构成了增量编码器的正交输出。对于多数编码器而言,这些方波A和B均失相90度。通过观察A和B输出不断变化的状态,编码器的方向得以确定。有两个通道:通道A和通道B。
    当通道A的阅读器经过编码器盘上的亮区时,它会在通道A上生成方波脉冲。编码器轮或阅读器上的区域稍微偏移,因此通道B的阅读器将检测90°的图案,通过读取脉冲数和哪个通道在另一个之前(称为“前导”),编码器接口可以判断编码器旋转了多远,以及在哪个方向上。某些编码器还有第三个通道称为索引通道,每完成一次旋转就发送一次脉冲。这允许编码器知道其实际位置而不是其相对位置,如绝对编码器,而不会产生太多的额外成本。您可以检查编码器的数据表,看它是否有索引通道。如图3所示,为典型编码器方波输出。图中,A前导于B为顺时针旋转,B前导于A为顺时针旋转。
    在这里插入图片描述
    图3 典型编码器方波输出
    然而,要确定编码器的行程距离或其旋转速度,则需要提供更多信息。要计算这些信息,就务必要了解编码器的分辨率。可以将分辨率想象成编码器的粒度,或者简单点说,就是每转可将编码器这个大饼分成多少块。
    每转脉冲数(PPR)
    PPR(或每转脉冲数)这一术语表示编码器的分辨率。PPR描述了编码器每转的方波输出A或B上出现的高脉冲数。一旦获知分辨率,就能将其用于计算各脉冲和周期相当于多少几何角度。如图4所示。
    在这里插入图片描述
    图4 编码器的分辨率
    编码类型
    编码器总共有三种基本的编码类型:X1、 X2 和 X4。
    X1 编码
    如图5,显示了一个正交周期及其相应的X1编码类型下的计数值的加减数目。当通道A引导通道B时,增量发生在通道A的上升沿。当通道B引导通道A时,减量发生在通道A的下降沿。
    在这里插入图片描述
    图5 X1编码
    X2编码
    X2编码与上述过程类似,只是计数器在A通道的每个边沿计数是增加还是减少,取决于由哪个通道引导哪个通道。计数器的数值每个周期都会增加2个或减少2个,如图6所示。
    在这里插入图片描述
    图6 X2编码
    X4编码
    X4编码模式下,计数器同样也在通道A和B的每个沿上发生增加或者减少。 计数器的数目是增加还是减少,取决于哪个通道引导哪个通道。计数器的数目在每个周期都会增加4个或减少4个,如图7所示。
    在这里插入图片描述
    图7 X4编码
    每转计数(CPR)
    CPR最常代表每转计数,并且是指存在于A和B两个输出之间的正交解码状态的数量。在A和B两个输出于高电平和低电平之间进行切换时,会出现2位的信息,表示4种不同的状态。术语正交解码描述了同时使用输出A和B计数每个状态变化的方法。结果是每个脉冲或周期的计数量的4倍。因此,编码器的CPR就是编码器的PPR乘以4。还要注意的是,有些编码器制造商采用CPR这一缩略语表示每转循环数(每转周期数)。每转循环数表示任何一个编码器输出的完整电气周期或用时,且该值等于每转脉冲数。鉴于每转计数和每转循环数均采用CPR这一相同缩略语,因而必须仔细理解分辨率的定义方式。图8为常见产品波形图。
    在这里插入图片描述
    图8 常见产品波形图
    公式:
    1、编码器 CPR 频率与电机速度(RPM) 之间的关系由下式给出:
    f=(周期/转)*(转/秒)/1000=kHz
    转速=每分钟转数
    CPR =每转周期数
    2、距离转换:
    (PPR) /(2 * pi *轴半径) =每英寸脉冲数
    (每英寸脉冲数 ^-1 =每脉冲英寸数

    展开全文
  • 文章目录一、自编码器(Autoencoder, AE)自编码器的结构和思想结构思想自编码器的作用与类型作用类型二、Tensorflower代码实现普通自编码器多层自编码器卷积自编码器稀疏自编码器 一、自编码器(Autoencoder, AE) ...

    一、自编码器(Autoencoder, AE)

    自编码器的结构和思想

    结构

    • 自编码器是一种无监督的数据维度压缩数据特征表达方法。
    • 自编码器是神经网络的一种,经过训练后能尝试将输入复制到输出。自编码器由编码器和解码器组成,如下图所示:
    • 自编码器指的是试图让输出和输入一样的神经网络。
    • 他们通过将输入压缩成一个隐藏空间表示来进行工作,然后通过这种表示重构输出。
      1. 编码器:自编码器的前半部分,功能在于把输入变成一个隐藏的空间表示。 它可以用一个编码函数h=f(x)h = f(x)表示。
      2. 解码器:这部分旨在从隐藏空间的表示重构输入。 它可以用解码函数r=g(h)r = g(h)表示。

    思想

    • 如果AE的唯一目的是将输入复制到输出中,那么它们将毫无用处。
    • 实际上,我们希望通过训练AE将输入复制到输出中,隐藏表示h将具有有用的属性
    • 从自编码器获得有用特征的一种方法是将h限制为小于x的维度,在这种情况下,自编码器是不完整的。通过训练不完整的表示,我们强制自编码器学习训练数据的最显著特征。
    • 如果自编码器的容量过大,自编码器可以出色地完成赋值任务而没有从数据的分布抽取到任何有用的信息。如果隐藏表示的维度与输入相同,或者隐藏表示维度大于输入维度的情况下,也会发生这种情况。
    • 在这些情况下,即使线性编码器和线性解码器也可以将输入复制到输出,而无需了解有关数据分配的任何有用信息。
    • 理想情况下,自编码器可以成功地训练任何体系结构,根据要分配的复杂度来选择编码器和解码器的代码维数和容量。

    自编码器的作用与类型

    作用

    • 数据去噪
    • 数据降维
    • 通过适当的维度和稀疏性约束,自编码器可以学习比PCA或其他基本技术更有趣的数据投影。

    类型

    1.普通自编码器
    2.多层自编码器
    3.卷积自编码器
    4.稀疏自编码器

    二、Tensorflower代码实现

    普通自编码器

    • 普通自编码器是三层网络,即具有一个隐藏层的神经网络。
    • 输入和输出是相同的。
    • 激活函数可以选择sigmoid或者relu
    from keras.layers import Dense, Input, Activation
    input_size = 256
    hidden_size = 32
    output_size = 256
    x = Input(shape=(input_size,))
    
    # Encoder
    h = Dense(hidden_size, activation='sigmoid')(x)  
    
    # Decoder
    r = Dense(output_size, activation='sigmoid')(h)
    
    autoencoder = Model(input=x, output=r)
    autoencoder.compile(optimizer='adam', loss='mse')
    autoencoder.fit(input_data, input_data, batch_size=128, epochs=10000, verbose=2)
    

    多层自编码器

    • 如果一个隐藏层不够用,可以将自编码器扩展到更多的隐藏层。
    • 我们的实现使用3个隐藏层,而不是一个。
    • 任何隐藏层都可以作为特征表示,但将使网络结构对称并使用最中间的隐藏层。
    from keras.layers import Dense, Input, Activation
    input_size = 256
    hidden_size = 32
    output_size = 256
    x = Input(shape=(input_size,))
    
    # Encoder
    hidden_1 = Dense(hidden_size, activation='sigmoid')(x)
    h = Dense(code_size, activation='sigmoid')(hidden_1)
    
    # Decoder
    hidden_2 = Dense(hidden_size, activation='relu')(h)
    r = Dense(input_size, activation='sigmoid')(hidden_2)
    
    autoencoder = Model(input=x, output=r)
    autoencoder.compile(optimizer='adam', loss='mse')
    autoencoder.fit(input_data, input_data, batch_size=128, epochs=10000, verbose=2)
    

    卷积自编码器

    • 使用图像(3D矢量)而不是平坦的1维矢量。
    • 对输入图像进行下采样以提供较小尺寸的隐藏表示并强制自编码器学习图像的压缩版本。
    x = Input(shape=(28, 28,1)) 
    
    # Encoder
    conv1_1 = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
    pool1 = MaxPooling2D((2, 2), padding='same')(conv1_1)
    conv1_2 = Conv2D(8, (3, 3), activation='relu', padding='same')(pool1)
    pool2 = MaxPooling2D((2, 2), padding='same')(conv1_2)
    conv1_3 = Conv2D(8, (3, 3), activation='relu', padding='same')(pool2)
    h = MaxPooling2D((2, 2), padding='same')(conv1_3)
    
    
    # Decoder
    conv2_1 = Conv2D(8, (3, 3), activation='relu', padding='same')(h)
    up1 = UpSampling2D((2, 2))(conv2_1)
    conv2_2 = Conv2D(8, (3, 3), activation='relu', padding='same')(up1)
    up2 = UpSampling2D((2, 2))(conv2_2)
    conv2_3 = Conv2D(16, (3, 3), activation='relu')(up2)
    up3 = UpSampling2D((2, 2))(conv2_3)
    r = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(up3)
    
    autoencoder = Model(input=x, output=r)
    autoencoder.compile(optimizer='adam', loss='mse')
    

    稀疏自编码器

    • 稀疏自编码器通常用于学习分类等其他任务的特征。
    • 稀疏自编码器必须响应数据集独特统计特征,而不仅仅是作为标识函数。 通过这种方式,用稀疏性惩罚来执行复制任务的训练可以产生有用的特征模型。
    • 我们可以限制自编码器重构的另一种方式是对损失函数施加约束
    • 例如,我们可以在损失函数中添加一个修正术语。 这样做会使我们的自编码器学习数据的稀疏表示,,在正则项中,我们添加了一个L1激活函数正则器,它将在优化阶段对损失函数应用一个惩罚。 在结果上,与正常普通自编码器相比,该表示现在更稀松。
    from keras.layers import Dense, Input, Activation
    input_size = 256
    hidden_size = 32
    output_size = 256
    x = Input(shape=(input_size,))
    
    # Encoder
    h = Dense(hidden_size, activation='sigmoid', activity_regularizer=regularizers.l1(10e-6))(x)
    
    # Decoder
    r = Dense(output_size, activation='sigmoid')(h)
    
    autoencoder = Model(input=x, output=r)
    autoencoder.compile(optimizer='adam', loss='mse')
    autoencoder.fit(input_data, input_data, batch_size=128, epochs=10000, verbose=2)
    
    展开全文
  • 正交编码器

    千次阅读 2019-09-04 15:24:52
    正交编码器 正交编码器通过两个脉冲信号进行位置测量。该信号可称为信号A(通道A)和信号B...M系列、C系列和NI-TIO设备上的计数器支持对X1、X2、X4三种类型的正交编码器进行解码: 对于X1解码信号A在信号B之前,计数...
  • start = time() from keras.models import Sequential from keras.layers import Dense, Dropout,Input from keras.layers import Embedding from keras.layers import Conv1D, GlobalAverage...keras各种自编码代码
  • STM32 TIM 编码器模式采集编码器信号

    千次阅读 2019-10-26 10:22:25
    通常的说法是1000线的编码器,即转一圈会产生1000个方波脉冲,马盘上刻了1000个栅格,中间被镂了1000个空,举个例子,未免显得有点啰嗦,下面直奔主题,至于什么是编码器还是搜索引擎说的明明白白。 增量编码器通常有...
  • 编码器介绍和应用

    千次阅读 2019-08-09 15:29:14
    1. 什么是编码器? 简而言之,编码器是一种提供反馈的传感设备。编码器将运动转换为电信号,该信号可由运动控制系统中的某种类型的控制装置读取,例如计数器或PLC。 编码器发送反馈信号,可用于确定位置,计数,速度...
  • 编码器类型主要有增量型
  • 编码器(常见的三种编码器

    千次阅读 2020-03-13 19:46:34
    什么是编码 编码器 三种编码器 一 这种编码器存在的问题是两个输入为1是与只有I3为1时的编码重叠。下面优先编码器能解决 二 i3的级别最高 i0最低 虽然解决了第一类编码器的问题但还是有编码重叠的问题 第三种...
  • 编码器的工作原理

    万次阅读 2019-11-12 09:03:37
    最近公司项目用到了编码器 选用的编码器 为360脉冲 为了方便其一圈发360个脉冲 ,当然精度只有一度 ,如果为了高精度可以选用其他类型的 首先简述一下编码器的工作原理 编码器可按以下方式来分类。 1、按码盘的...
  • 数电三:编码器和译码器

    千次阅读 2018-12-18 19:45:18
    编码器类型 二进制编码器 用 n 位二进制数码对 2n 个输入信号进行编码的电路 优先编码器 (即 Priority Encoder) 允许同时输入数个编码信号,并只对其中优先权最高的信号进行编码输出...
  • STM32——编码器测速原理及STM32编码器模式

    千次阅读 多人点赞 2021-01-19 22:12:53
    本问讲解了编码器测速原理及STM32编码器模式,文末有STM32编码器模式例程。
  • 编码器基础知识大扫盲

    千次阅读 2021-02-22 12:20:07
    如何测量旋转量和旋转速度? 在我们的日常生活中,周围有各种精密仪器和电子设备。...那么什么是编码器呢? 什么是编码器编码器是对旋转角度和线性位移进行编码的传感器。 检测旋转的编码器称为旋转编码器,检
  • 编码器与解码器

    千次阅读 2019-11-25 23:20:39
    Netty中的编码器、解码器
  • 编码器什么玩意呢,它可是一个好玩的东西,做小车测速必不可少的玩意,下面,我将从编码器的原理讲起,一直到用stm32的编码器接口模式,测出电机转速与方向。 1.编码器 图1 编码器示意图  图1为编码器的示意...
  • 编码器和译码器(数电实验报告)

    千次阅读 2020-11-28 22:34:16
    编码器和译码器 一、 实验目的 掌握用逻辑门实现编码器的方法 掌握中规模集成电路编码器和译码器的工作原理即逻辑功能 掌握 74LS138 用作数据分配器的方法 熟悉编码器和译码器的级联方法 能够利用译码器进行组合...
  • 旋转编码器与PIC单片机接口

    千次阅读 2019-01-04 16:42:00
    旋转编码器与PIC单片机接口 旋转编码器 是一种输入装置,其帮助用户与系统进行交互。它起来更像是一个无线电电位器旋转编码器是一种输入设备, 可...在本文中,我们将了解不同类型的旋转编码器及其工作原理。我...
  • 编码器从输出数据类型上分,可以分为增量式编码器和绝对式编码器。   从编码器检测原理上来分,还可以分为光学式、磁式、感应式、电容式。常见的是光电编码器(光学式)和霍尔编码器(磁式)。 2.编码器原理
  • STM32f4日记5之AB相编码器测速实验(TIM定时器的编码器模式使用) 板子:stm32f407zgt6正点原子迷你版 电机参数:减速比 1:90 线数:1170(1390)* // 鉴于目前网上的教学形态各异,很多带有迷惑、误导性质,所以写...
  • 光电编码器简介

    千次阅读 2017-03-07 20:40:42
    利用光栅的衍射可以根据需要把光信号转换为电...根据产生脉冲的方式不同,光电编码器可以分为增量式、绝对式、混合式三种类型; (1) 增量式编码器 增量式编码器的输出信号是A,B,Z三组方波脉冲。增量式编码器的组成结
  • ODrive应用 #6 编码器

    千次阅读 2019-12-03 12:43:16
    ODrive支持的所有编码器类型都需要进行某种编码器校准。 这需要以下条件: 选择一种编码器并将其安装到电动机 选择编码器通讯接口 (e.g., AB, ABI or SPI) 将编码器通信接口连接到ODrive 加载正确的odrive固件...
  • 神经网络中自编码器Autoencoder

    万次阅读 2018-11-02 17:19:46
    什么是编码器(Autoencoder) 自动编码器是一种数据的压缩算法,其中数据的压缩和解压缩函数是数据相关的、有损的、从样本中自动学习的。在大部分提到自动编码器的场合,压缩和解压缩的函数是通过神经网络实现的...
  • STM32编码器接口,以及应用编程

    千次阅读 2017-12-19 21:26:23
    Ⅰ关于编码器编码器的种类有很多,什么增量式编码器、绝对值编码器,有轴或者无轴编码器,电压输出、推拉输出、集电极开路输出等等。但不管什么类型编码器,其目的都类似,得到转动...
  • 编码器分类:

    千次阅读 2018-05-07 14:21:24
    按工作原理:光电式、磁电式和触点电刷式 按码盘的刻孔方式:增量式和绝对式两类 由于博主接触面还不是很广,一共就用过两个种类的编码器,都是属于光电的 差分编码器:一般由8根线连接 信号线分别为 A+ A- B+ B- ...
  • 使用Arduino 连接旋转编码器

    千次阅读 2019-03-21 15:31:07
    1. 所需的材料 旋转编码器(KY-040) Arduino UNO开发板 字符型图形点阵液晶1602 电位器10k 面包板 ...有许多类型编码器,每个编码器都有自己的工作机制,稍后我们将了解这些类型,但现在让...
  • 编码器(AutoEncoder)入门及TensorFlow实现

    万次阅读 多人点赞 2018-03-03 23:01:19
    编码器(Autoencoder,AE),是一种利用反向传播算法使得输出值等于输入值的神经网络,它先将输入压缩成潜在空间表征,然后通过这种表征来重构输出。自编码器由两部分组成:编码器(encoder):这部分能将输入压缩成...
  • 编码器使用教程与测速原理

    千次阅读 2018-11-06 18:19:02
    编码器从输出数据类型上 分,可以分为增量式编码器和绝对式编码器。 从编码器检测原理上来分,还可以分为光学式、磁式、感应式、电容式。常 见的是光电编码器(光学式)和霍尔编码器(磁式)。 光电编码器是一种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 542,187
精华内容 216,874
关键字:

怎样看编码器是什么类型