搜索历史

清空
搜索热词
      0
      • 聊天消息
      • 系统消息
      • 评论与回复
      查看更多
      查看更多
      查看更多
      登录后你可以
      • 下载海量资料
      • 学习在线课程
      • 观看技术视频
      • 写文章/发帖/加入社区
      创作中心
      发布
      创作活动

      完善资料让更多小伙伴认识你，还能领取20积分哦，立即完善>

      3天内不再提示

      自编码器 AE（AutoEncoder）程序

      jf_96884364 • 来源：代码的路 • 作者：代码的路 • 2023-01-11 17:29 • 次阅读

      原文链接

      1.程序讲解

      （1）香草编码器

      在这种自编码器的最简单结构中，只有三个网络层，即只有一个隐藏层的神经网络。它的输入和输出是相同的，可通过使用Adam优化器和均方误差损失函数，来学习如何重构输入。

      在这里，如果 隐含层维数（64）小于输入维数（784 ），则称这个编码器是有损的。通过这个约束，来迫使神经网络来学习数据的压缩表征。

      input_size = 784
hidden_size = 64
output_size = 784

x = Input(shape=(input_size,))

# Encoder
h = Dense(hidden_size, activation='relu')(x)

# Decoder
r = Dense(output_size, activation='sigmoid')(h)

autoencoder = Model(input=x, output=r)
autoencoder.compile(optimizer='adam', loss='mse')

      Dense ：Keras Dense层，keras.layers.core.Dense( units, activation=None）

      units, #代表该层的输出维度

      activation=None, #激活函数.但是默认 liner

      Activation ：激活层对一个层的输出施加激活函数

      model.compile() ：Model模型方法之一：compile

      optimizer ：优化器，为预定义优化器名或优化器对象，参考优化器

      loss ：损失函数，为预定义损失函数名或一个目标函数，参考损失函数

      adam ：adaptive moment estimation，是对RMSProp优化器的更新。利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。优点：每一次迭代学习率都有一个明确的范围,使得参数变化很平稳。

      mse ：mean_squared_error，均方误差

      （2）多层自编码器

      如果一个隐含层还不够，显然可以将自动编码器的隐含层数目进一步提高。

      在这里，实现中使用了3个隐含层，而不是只有一个。 任意一个隐含层都可以作为特征表征 ，但是为了使网络对称，我们使用了最中间的网络层。

      input_size = 784
hidden_size = 128
code_size = 64

x = Input(shape=(input_size,))

# Encoder
hidden_1 = Dense(hidden_size, activation='relu')(x)
h = Dense(code_size, activation='relu')(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')

      （3）卷积自编码器

      除了全连接层，自编码器也能应用到卷积层，原理是一样的，但是 要使用3D矢量（如图像）而不是展平后的一维矢量 。对输入图像进行 下采样 ，以提供较小维度的潜在表征，来迫使自编码器从压缩后的数据进行学习。

      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')

      conv2d ：Conv2D(filters, kernel_size, strides=(1, 1), padding='valid'）

      filters：卷积核的数目（即输出的维度）。

      kernel_size：卷积核的宽度和长度，单个整数或由两个整数构成的list/tuple。如为单个整数，则表示在各个空间维度的相同长度。

      strides：卷积的步长，单个整数或由两个整数构成的list/tuple。如为单个整数，则表示在各个空间维度的相同步长。任何不为1的strides均与任何不为1的dilation_rate均不兼容。

      padding：补0策略，有“valid”, “same” 两种。“valid”代表只进行有效的卷积，即对边界数据不处理。“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同。

      MaxPooling2D ：2D输入的最大池化层。MaxPooling2D(pool_size=(2, 2), strides=None, border_mode='valid')

      pool_size：pool_size：长为2的整数tuple，代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半。

      strides：长为2的整数tuple，或者None，步长值。

      padding:字符串，“valid”或者”same”。

      UpSampling2D ：上采样。UpSampling2D(size=(2, 2))

      size：整数tuple，分别为行和列上采样因子。

      （4）正则自编码器

      除了施加一个比输入维度小的隐含层，一些其他方法也可用来约束自编码器重构，如正则自编码器。

      正则自编码器不需要使用浅层的编码器和解码器以及小的编码维数来限制模型容量，而是使用损失函数来鼓励模型学习其他特性（除了将输入复制到输出）。这些特性包括稀疏表征、小导数表征、以及对噪声或输入缺失的鲁棒性。

      即使模型容量大到足以学习一个无意义的恒等函数，非线性且过完备的正则自编码器仍然能够从数据中学到一些关于数据分布的有用信息。

      在实际应用中，常用到两种正则自编码器，分别是稀疏自编码器和 降噪自编码器 。

      （5）稀疏自编码器

      一般用来学习特征，以便用于像分类这样的任务。稀疏正则化的自编码器必须反映训练数据集的独特统计特征，而不是简单地充当恒等函数。以这种方式训练，执行附带稀疏惩罚的复现任务可以得到能学习有用特征的模型。

      还有一种用来约束自动编码器重构的方法，是对其损失函数施加约束。比如，可对 损失函数添加一个正则化约束 ，这样能使自编码器学习到数据的稀疏表征。

      要注意，在隐含层中，我们还加入了 L1正则化，作为优化阶段中损失函数的惩罚项 。与香草自编码器相比，这样操作后的数据表征更为稀疏。

      input_size = 784
hidden_size = 64
output_size = 784

x = Input(shape=(input_size,))

# Encoder
h = Dense(hidden_size, activation='relu', activity_regularizer=regularizers.l1(10e-5))(x)
#施加在输出上的L1正则项

# Decoder
r = Dense(output_size, activation='sigmoid')(h)

autoencoder = Model(input=x, output=r)
autoencoder.compile(optimizer='adam', loss='mse')

      activity_regularizer ：施加在输出上的正则项，为ActivityRegularizer对象

      l1(l=0.01) ：L1正则项，正则项通常用于对模型的训练施加某种约束，L1正则项即L1范数约束，该约束会使被约束矩阵/向量更稀疏。

      （6）降噪自编码器

      这里不是通过对损失函数施加惩罚项，而是 通过改变损失函数的重构误差项来学习一些有用信息 。

      向训练数据加入噪声，并使自编码器学会去除这种噪声来获得没有被噪声污染过的真实输入。因此，这就迫使编码器学习提取最重要的特征并学习输入数据中更加鲁棒的表征，这也是它的泛化能力比一般编码器强的原因。

      这种结构可以通过梯度下降算法来训练。

      x = Input(shape=(28, 28, 1))

# Encoder
conv1_1 = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
pool1 = MaxPooling2D((2, 2), padding='same')(conv1_1)
conv1_2 = Conv2D(32, (3, 3), activation='relu', padding='same')(pool1)
h = MaxPooling2D((2, 2), padding='same')(conv1_2)

# Decoder
conv2_1 = Conv2D(32, (3, 3), activation='relu', padding='same')(h)
up1 = UpSampling2D((2, 2))(conv2_1)
conv2_2 = Conv2D(32, (3, 3), activation='relu', padding='same')(up1)
up2 = UpSampling2D((2, 2))(conv2_2)
r = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(up2)

autoencoder = Model(input=x, output=r)
autoencoder.compile(optimizer='adam', loss='mse')

      2.程序实例：

      （1）单层自编码器

      from keras.layers import Input, Dense
from keras.models import Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
 
(x_train, _), (x_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:])))
print(x_train.shape)
print(x_test.shape)
 
 #单层自编码器
encoding_dim = 32
input_img = Input(shape=(784,))
 
encoded = Dense(encoding_dim, activation='relu')(input_img)
decoded = Dense(784, activation='sigmoid')(encoded)
 
autoencoder = Model(inputs=input_img, outputs=decoded)
encoder = Model(inputs=input_img, outputs=encoded)
 
encoded_input = Input(shape=(encoding_dim,))
decoder_layer = autoencoder.layers[-1]
 
decoder = Model(inputs=encoded_input, outputs=decoder_layer(encoded_input))
 
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
 
autoencoder.fit(x_train, x_train, epochs=50, batch_size=256, 
                shuffle=True, validation_data=(x_test, x_test))
 
encoded_imgs = encoder.predict(x_test)
decoded_imgs = decoder.predict(encoded_imgs)
 
 #输出图像
n = 10  # how many digits we will display
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()

      （2）卷积自编码器

      from keras.layers import Input, Convolution2D, MaxPooling2D, UpSampling2D
from keras.models import Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
from keras.callbacks import TensorBoard

(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
noise_factor = 0.5
x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape) 
x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape) 
x_train_noisy = np.clip(x_train_noisy, 0., 1.)
x_test_noisy = np.clip(x_test_noisy, 0., 1.)
print(x_train.shape)
print(x_test.shape)


#卷积自编码器
input_img = Input(shape=(28, 28, 1))
 
x = Convolution2D(16, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Convolution2D(8, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Convolution2D(8, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
 
x = Convolution2D(8, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(8, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(16, (3, 3), activation='relu')(x)
x = UpSampling2D((2, 2))(x)
decoded = Convolution2D(1, (3, 3), activation='sigmoid', padding='same')(x)
 
autoencoder = Model(inputs=input_img, outputs=decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
 
# 打开一个终端并启动TensorBoard，终端中输入 tensorboard --logdir=/autoencoder
autoencoder.fit(x_train, x_train, epochs=50, batch_size=256,
                shuffle=True, validation_data=(x_test, x_test),
                callbacks=[TensorBoard(log_dir='autoencoder')])
 
decoded_imgs = autoencoder.predict(x_test)


#输出图像
n = 10  # how many digits we will display
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()

      （3）深度自编码器

      from keras.layers import Input, Dense
from keras.models import Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

(x_train, _), (x_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:])))
print(x_train.shape)
print(x_test.shape)



#深度自编码器
input_img = Input(shape=(784,))
encoded = Dense(128, activation='relu')(input_img)
encoded = Dense(64, activation='relu')(encoded)
decoded_input = Dense(32, activation='relu')(encoded)
 
decoded = Dense(64, activation='relu')(decoded_input)
decoded = Dense(128, activation='relu')(decoded)
decoded = Dense(784, activation='sigmoid')(encoded)
 
autoencoder = Model(inputs=input_img, outputs=decoded)
encoder = Model(inputs=input_img, outputs=decoded_input)
 
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
 
autoencoder.fit(x_train, x_train, epochs=50, batch_size=256, 
                shuffle=True, validation_data=(x_test, x_test))
 
encoded_imgs = encoder.predict(x_test)
decoded_imgs = autoencoder.predict(x_test)



#输出图像
n = 10  # how many digits we will display
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()

      （4）降噪自编码器

      from keras.layers import Input, Convolution2D, MaxPooling2D, UpSampling2D
from keras.models import Model
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
from keras.callbacks import TensorBoard
 
(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
noise_factor = 0.5
x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape) 
x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape) 
x_train_noisy = np.clip(x_train_noisy, 0., 1.)
x_test_noisy = np.clip(x_test_noisy, 0., 1.)
print(x_train.shape)
print(x_test.shape)
 
input_img = Input(shape=(28, 28, 1))
 
x = Convolution2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Convolution2D(32, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
 
x = Convolution2D(32, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Convolution2D(1, (3, 3), activation='sigmoid', padding='same')(x)
 
autoencoder = Model(inputs=input_img, outputs=decoded)
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
 
# 打开一个终端并启动TensorBoard，终端中输入 tensorboard --logdir=/autoencoder
autoencoder.fit(x_train_noisy, x_train, epochs=10, batch_size=256,
                shuffle=True, validation_data=(x_test_noisy, x_test),
                callbacks=[TensorBoard(log_dir='autoencoder', write_graph=False)])
 
decoded_imgs = autoencoder.predict(x_test_noisy)
 
n = 10
plt.figure(figsize=(30, 6))
for i in range(n):
    ax = plt.subplot(3, 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(3, n, i + 1 + n)
    plt.imshow(x_test_noisy[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
 
    ax = plt.subplot(3, n, i + 1 + 2*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()

      学习更多编程知识，请关注我的公众号：

      代码的路

      声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。 举报投诉
      • 编码器
        编码器
        +关注

        关注

        41

        文章

        3364

        浏览量

        131569
      • 神经网络
        神经网络
        +关注

        关注

        42

        文章

        4575

        浏览量

        98775
      • 编程
        编程
        +关注

        关注

        88

        文章

        3441

        浏览量

        92421
      • 程序
        程序
        +关注

        关注

        114

        文章

        3631

        浏览量

        79554
      • AutoEncoder
        AutoEncoder
        +关注

        关注

        0

        文章

        2

        浏览量

        629
      收藏 人收藏

        评论

        相关推荐

        基于变分自编码器的异常小区检测

        用于训练变分自编码器模型，测试集用于评估模型检测准确性。　　在样本不平衡的情况下，通过设定不同的重构误差门限，分别统计AE和VAE所检测出的异常小区数，验证检测准确率，如表1和表2所示。显然，本文所用
        发表于 12-03 15:06

        编码器,编码器是什么意思

        编码器,编码器是什么意思 编码器 编码器（encoder）是将信号
        发表于 03-08 15:04 •2894次阅读

        是什么让变分自编码器成为如此成功的多媒体生成工具呢？

        标准自编码器能学习生成紧凑的数据表达并重建输入数据，然而除了像去噪自编码器等为数不多的应用外，它的应用却极其有限。其根本原因在于自编码器将输入转换为隐含空间中的表达并不是连续的，使得其中的插值和扰动难以完成。
        的头像 发表于 04-19 16:48 •1.3w次阅读
        是什么让变分<b class='flag-5'>自编码器</b>成为如此成功的多媒体生成工具呢？

        自编码器是什么?有什么用

        自动编码器是一种无监督的神经网络模型，它可以学习到输入数据的隐含特征，这称为编码(coding)，同时用学习到的新特征可以重构出原始输入数据，称之为解码(decoding)。
        的头像 发表于 08-02 16:47 •1.7w次阅读

        自编码器介绍

        自编码器若仅要求X≈Y，且对隐藏神经元进行稀疏约束，从而使大部分节点值为0或接近0的无效值，便得到稀疏自动编码算法。一般情况下，隐含层的神经元数应少于输入X的个数，因为此时才能保证这个网络结构的价值。
        发表于 06-11 15:07 •4688次阅读

        稀疏自编码器及TensorFlow实现详解

        　稀疏自编码器（又称稀疏自动编码机）中，重构误差中添加了一个稀疏惩罚，用来限定任何时刻的隐藏层中并不是所有单元都被激活。如果 m 是输入模式的总数，那么可以定义一个参数 ρ_hat，用来表示每个隐藏层单元的行为（平均激活多少次）。
        发表于 06-11 16:45 •3632次阅读
        稀疏<b class='flag-5'>自编码器</b>及TensorFlow实现详解

        基于栈式降噪稀疏自编码器的ELM算法

        极限学习机（ELM）随机选择网络输入权重和隐层偏置，存在网络结构复杂和鲁棒性较弱的不足。为此提出基于栈式降噪稀疏自编码器（ SDSAE）的巸LM算法。利用 SDSAE稀疏网络的优势，挖掘目标数据
        发表于 03-22 11:40 •7次下载
        基于栈式降噪稀疏<b class='flag-5'>自编码器</b>的ELM算法

        基于变分自编码器的海面舰船轨迹预测算法

        海面舰船的轨迹预测对预测精度和实时性具有较高要求，而舰船轨迹数据特征的高复杂度特性，导致传统预测算法精度低、耗时长，难以达到良好的预测效果。为此，提出一种基于变分自编码器的海面舰船轨迹预测
        发表于 03-30 09:53 •5次下载
        基于变分<b class='flag-5'>自编码器</b>的海面舰船轨迹预测算法

        自编码器基础理论与实现方法、应用综述

        自编码器是深度学习中的一种非常重要的无监督学习方法，能够从大量无标签的数据中自动学习，得到蕴含在数据中的有效特征。因此，自编码方法近年来受到了广泛的关注，已成功应用于很多领域，例如数据分类、模式识别
        发表于 03-31 11:24 •8次下载
        <b class='flag-5'>自编码器</b>基础理论与实现方法、应用综述

        可实现骨骼运动重定向的通用双向循环自编码器

        针对面向关节坐标表示的骨骼运动数据重定向网络缺乏通用性的问题，提出一种能够实现源骨骼到多种骨骼运动重定向的通用双向循环自编码器。该自编码器由基于关节坐标表示的运动数据以重建误差为损失函数训练
        发表于 04-21 10:38 •2次下载
        可实现骨骼运动重定向的通用双向循环<b class='flag-5'>自编码器</b>

        一种基于变分自编码器的人脸图像修复方法

        基于卷积神经网络的人脸图像修复技术在刑事侦破、文物保护及影视特效等领域有着重要的应用。但现有方法存在着图像修复结果不够清晰以及结果多样化不足等缺点，为此，提出了一种基于变分自编码器的人脸图像修复
        发表于 04-21 10:51 •10次下载
        一种基于变分<b class='flag-5'>自编码器</b>的人脸图像修复方法

        晶圆表面的二维主成分分析卷积自编码器

        由于半导体制造过程的高度复杂性和动态性，各种过程故障通常导致晶圆表面出现各种缺陷模式。为了有效地识别晶圆表面缺陷模式从而及时地诊断和控制故障源，提出一种深度神经网络模型维主成分分析卷积自编码器
        发表于 04-29 13:51 •6次下载
        晶圆表面的二维主成分分析卷积<b class='flag-5'>自编码器</b>

        自编码器神经网络应用及实验综述

        自编码器是深度学习中的一种非常重要的无监督学习方法，能够从大量无标签的数据中自动学习，得到蕴含在数据中的有效特征。因此，自编码方法近年来受到了广泛的关注，已成功应用于很多领域，例如数据分类、模式识别
        发表于 06-07 16:38 •7次下载

        堆叠降噪自动编码器（SDAE）

        自动编码器（Auto-Encoder，AE） 自编码器（autoencoder）是神经网络的一种，经过训练后能尝试将输入复制到输出。自编码器
        的头像 发表于 01-11 17:04 •5112次阅读
        堆叠降噪自动<b class='flag-5'>编码器</b>（SDAE）

        编码器好坏怎么判断,编码器原理

        （Autoencoder），它是一种无监督学习的神经网络模型。自动编码器由两部分组成：编码器和解码器。编码器负责将输入数据转换为低维表示，解码器则将低维表示映射回原始输入空间。这种结构
        的头像 发表于 01-23 10:58 •654次阅读
        华秋（原“华强聚丰”）：
        电子发烧友
        华秋开发
        华秋电路(原"华强PCB")
        华秋商城(原"华强芯城")
        华秋智造
        My ElecFans
        APP
        网站地图
        设计技术
        可编程逻辑
        电源/新能源
        MEMS/传感技术
        测量仪表
        嵌入式技术
        制造/封装
        模拟技术
        RF/无线
        接口/总线/驱动
        处理器/DSP
        EDA/IC设计
        存储技术
        光电显示
        EMC/EMI设计
        连接器
        行业应用
        LEDs
        汽车电子
        音视频及家电
        通信网络
        医疗电子
        人工智能
        虚拟现实
        可穿戴设备
        机器人
        安全设备/系统
        军用/航空电子
        移动通信
        工业控制
        便携设备
        触控感测
        物联网
        智能电网
        区块链
        新科技
        特色内容
        专栏推荐
        学院
        设计资源
        设计技术
        电子百科
        电子视频
        元器件知识
        工具箱
        VIP会员
        最新技术文章
        社区
        小组
        论坛
        问答
        评测试用
        企业服务
        产品
        资料
        文章
        方案
        企业
        供应链服务
        硬件开发
        华秋电路
        华秋商城
        华秋智造
        nextPCB
        BOM配单
        媒体服务
        网站广告
        在线研讨会
        活动策划
        新闻发布
        新品发布
        小测验
        设计大赛
        华秋
        关于我们
        投资关系
        新闻动态
        加入我们
        联系我们
        举报投诉
        社交网络
        微博
        移动端
        发烧友APP
        硬声APP
        WAP
        联系我们
        广告合作
        王婉珠：wangwanzhu@elecfans.com
        内容合作
        黄晶晶：huangjingjing@elecfans.com
        内容合作（海外）
        张迎辉：mikezhang@elecfans.com
        供应链服务 PCB/IC/PCBA
        江良华：lanhu@huaqiu.com
        投资合作
        曾海银：zenghaiyin@huaqiu.com
        社区合作
        刘勇：liuyong@huaqiu.com
        华秋发烧友
        电子工程师社区
        华秋电路
        1-32层PCB打样·中小批量
        华秋商城
        元器件现货·全球代购·SmartBOM
        华秋智造
        SMT贴片·PCBA加工
        NextPCB
        PCB Manufacturer

        版权所有 © 湖南华秋数字科技有限公司

        电子发烧友 （电路图） 湘公网安备43011202000918 电信与信息服务业务经营许可证：合字B2-20210191 工商网监认证工商网监 湘ICP备 2023018690 号