精华内容
下载资源
问答
  • 机器学习之神经网络(四)多分类之手写数字识别
    2019-07-22 11:20:32

    题目要求

    1.按要求完成下面的各项需求。
    已知一个多特征的数据集,该数据集有5000个样本,每个样本有400个特征,储存在X.txt中,样本的label储存在Y.txt中,label从0-9分成10类。
    请使用神经网络模型完成该数据集的分类。具体要求如下:
    完成数据集的读取,洗牌,并将数据集合理分割成训练集和测试集
    实现激活函数及其导数
    实现代价函数
    实现梯度下降并记录代价函数
    完成模型的训练,并计算在训练集上的准确率
    画出代价函数曲线
    在测试集上完成了预测,并计算在测试集上的准确率

    评分要求

    1.完成数据集的读取(8分)
    2.将数据集洗牌(6分),合理分割成训练集和测试集(6分)
    3.合理选取神经网络模型结构(8分),并对神经网络权重theta进行初始化(8分)
    4.实现激活函数及其导数(16分)
    -实现激活函数(sigmoid)8分
    -实现激活函数导数8分
    5.实现梯度下降并记录代价函数(24分)
    -实现正向传播算法8分
    -实现反向传播算法8分
    -记录代价函数8分
    6.完成模型的训练,并计算在训练集上的准确率(8分)
    7.画出代价函数曲线(8分)
    8.在测试集上完成了预测,并计算在测试集上的准确率(8分)

    题目分析

    这是典型的使用神经网络算法解决多分类问题,所以需要使用one-hot编码将y标签0-9的十种结果进行编码。
    首先要确定神经网络的层数框架(这里由于特征数过大,所有神经元个数也不能太少,最少选两层隐藏层,可以更多,所以我的网络结构是两层隐藏层,神经元个数是400,100)
    另外需要注意的是,这一组数据在特征缩放时要使用0-1缩放,不建议使用标准化。
    最后在统计准确率的时候需要将真实值的最大值下标和预测值的最大值下标进行比较,以这样的方式来进行准确率的计算.

    代码如下

    """
        构建一个两层隐层的神经网络 神经元个数400,100,10个输出
    """
    import numpy as np
    from sklearn.preprocessing import OneHotEncoder
    from matplotlib import pyplot as plt
    
    # 设置中文字体和负号正确显示
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    # 读取数据  1.完成数据集的读取(8分)
    X = np.loadtxt(r'X.txt',delimiter=',')
    y = np.loadtxt(r'Y11.txt',delimiter=',')
    
    
    # 数据预处理
    def preprocess(X,y):
        # 特征缩放之归一化
        X_min = np.min(X)
        X_max = np.max(X)
        X = (X - X_min) / (X_max - X_min)
        # 数据初始化
        X = np.c_[np.ones(len(X)),X]
        y = np.c_[y]
        # 将数据集洗牌(6分)
        # 确定随机种子
        np.random.seed(3)
        m = len(X)
        # 生成随机序列
        o = np.random.permutation(m)
        # 洗牌
        X = X[o]
        y = y[o]
        # 数据切割
        d = int(0.7 * m)
        X_train,X_test = np.split(X,[d])
        y_train,y_test = np.split(y,[d])
        # 数据处理完毕 返回处理好的数据
        return X_train,X_test,y_train,y_test
    
    
    # 调用数据处理函数,获得处理好的数据
    X_train, X_test, y_train, y_test = preprocess(X,y)
    
    # 将y进行独热编码
    oh = OneHotEncoder(categories='auto')
    y_train = oh.fit_transform(y_train,y_train.ravel()).toarray()
    y_test = oh.fit_transform(y_test,y_test.ravel()).toarray()
    
    
    # 定义激活函数4.实现激活函数及其导数(16分)
    def g(z,deriv=False):
        if deriv:
            return z * (1 - z)
        return 1.0 / (1 + np.exp(-z))
    
    
    # 定义模型
    def model(X,theta1,theta2,theta3):
        z2 = np.dot(X,theta1)
        a2 = g(z2)
        z3 = np.dot(a2,theta2)
        a3 = g(z3)
        z4 = np.dot(z3,theta3)
        a4 = g(z4)
        return a2,a3,a4
    
    
    # 定义代价函数
    def costFunction(h,y):
        m = len(h)
        # J = (-1/m) * np.sum(y * np.log(h) + (1-y) * np.log(1-h))
        J = (1/(2 * m)) * np.sum(np.square(h - y))
        return J
    
    
    # 定义BP算法
    def BP(a1,a2,a3,a4,y,theta1,theta2,theta3,alpha):
        # 第一部分,求取delta
        delta4 = a4 - y
        delta3 = np.dot(delta4,theta3.T) * g(a3,True)
        delta2 = np.dot(delta3,theta2.T) * g(a2,True)
        # 第二部分,求取deltatheta
        m = len(y)
        deltatheta3 = (1/m) * np.dot(a3.T,delta4)
        deltatheta2 = (1/m) * np.dot(a2.T,delta3)
        deltatheta1 = (1/m) * np.dot(a1.T,delta2)
        # 第三部分更新theta
        theta3 -= alpha * deltatheta3
        theta2 -= alpha * deltatheta2
        theta1 -= alpha * deltatheta1
        # 更新完毕返回更新好的数据
        return theta1,theta2,theta3
    
    
    # 定义梯度下降函数
    def gradeDesc(X,y,alpha=0.15,iter_max=1000,hidden_layer_size=(400,100)):
        # 数据准备
        # 获取数据维度
        m,n = X.shape
        k = y.shape[1]
        # 初始化代价值
        J_history = np.zeros(iter_max)
        # 初始化theta
        theta1 = 2 * np.random.random((n,hidden_layer_size[0])) - 1
        theta2 = 2 * np.random.random((hidden_layer_size[0],hidden_layer_size[1])) - 1
        theta3 = 2 * np.random.random((hidden_layer_size[1],k)) - 1
        # 执行梯度下降
        for i in range(iter_max):
            # 调用模型获得预测值
            a2,a3,a4 = model(X,theta1,theta2,theta3)
            # 调用代价函数记录代价
            J_history[i] = costFunction(a4,y)
            # 执行反向传播算法 更新theta
            theta1,theta2,theta3 = BP(X,a2,a3,a4,y,theta1,theta2,theta3,alpha)
        # 模型训练完毕 返回训练好的参数
        return J_history,theta1,theta2,theta3
    
    
    # 调用梯度下降函数获得训练好的参数
    J_history,theta1,theta2,theta3 = gradeDesc(X_train,y_train)
    # 调用模型函数,获得训练集的预测值
    a2_train_h,a3_train_h,a4_train_h = model(X_train,theta1,theta2,theta3)
    # 调用模型函数,获得测试集的预测值
    a2_test_h,a3_test_h,a4_test_h = model(X_test,theta1,theta2,theta3)
    
    
    # 定义准确率函数
    def score(h,y):
        l = len(h)
        count = 0
        for i in range(l):
            if np.argmax(h[i]) == np.argmax(y[i]):
                count += 1
        return count / l
    
    
    # 调用准确率函数获得预测准确率
    print('训练集的准确率是:',score(a4_train_h,y_train))
    print('测试集的准确率是:',score(a4_test_h,y_test))
    
    # 画图部分
    plt.title('代价函数曲线图')
    plt.plot(J_history)
    plt.show()
    
    
    更多相关内容
  • encoder_op = encoder(X) decoder_op = decoder(encoder_op) p_y_true = X p_y_pred = decoder_op p_loss = tf.reduce_mean(tf.square(p_y_true - p_y_pred)) p_optimizer = tf.train.RMSPropOptimizer...

           RBM和autocode都可以用来进行神经网络的预训练(pre_train),这种训练是无监督的,也可以说是自监督的(个人理解),AE的实现原理是构建一个对称的网络,似的输入和输出结果尽可能的一致,但是一般的中间隐藏层的维度是低于输入维度的(稀疏编码),从而达到降维的效果,使得低纬度数据能有效的表达高维数据的基本特征。当然这种编码不限于DNN网络,还可以是自编码的CNN网络。一般的网络形式X->H->X',H代表中间层,可以是一层或者多层(奇数层),最中间层就是稀疏编码得到的特征层。

          一般的在神经网络的训练中,AE是作为预训练的角色出现的,例如,我们要对mnist数据集进行2分类,此时我们的DNN的网络结构为X->H1->H2->2,我们为了防止在训练过程中由于初始化不合理而使得,反向传播算法进入局部最优值,我们可以构建一个网络  X->H1->H2->H1->X' 进行网络训练,loss function我们可以定义为Loss=(X-X1)e2/2,然后进行反向传播。事实上这也是一个简单的生成模型。在达到一定的要求后,我们将X->H1->H2的权值和bias值,作为X->H1->H2->10的初始化。

    以下是自编码的分类模型和生成模型。

    参考:https://www.jianshu.com/p/0331f5342cff

        

    import os
    from PIL import Image
    import numpy as np
    import tensorflow as tf
    import matplotlib.pyplot as plt
    import argparse
    
    parser = argparse.ArgumentParser()
    parser.add_argument('-type', default='1', help='''0: Show the function of AutoEncoder.
    												1: AutoEncoder is used to classify mnist.''')
    args = parser.parse_args()
    
    TRAIN_DATA_DIR = 'F:/DL/autoencoder-master/autoencoder-master/mnist/mnist/mnist_train/'
    TEST_DATA_DIR = 'F:/DL/autoencoder-master/autoencoder-master/mnist/mnist/mnist_test/'
    
    learning_rate = 0.02
    p_training_epochs = 100
    f_training_epochs = 50
    batch_size = 128
    
    n_input = 784
    n_h1 = 512
    n_h2 = 256
    n_output = 10
    
    
    weights = {
    	'ec_h1': tf.Variable(tf.truncated_normal(shape=[n_input,n_h1],mean=0,stddev=0.1)),
    	'ec_h2': tf.Variable(tf.truncated_normal(shape=[n_h1,n_h2],mean=0,stddev=0.1)),
    	'dc_h1': tf.Variable(tf.truncated_normal(shape=[n_h2,n_h1],mean=0,stddev=0.1)),
    	'dc_h2': tf.Variable(tf.truncated_normal(shape=[n_h1,n_input],mean=0,stddev=0.1)),
    	'fc_w': tf.Variable(tf.truncated_normal(shape=[n_h2,n_output],mean=0,stddev=0.1))
    }
    
    biases = {
    	'ec_b1': tf.Variable(tf.zeros([n_h1])),
    	'ec_b2': tf.Variable(tf.zeros([n_h2])),
    	'dc_b1': tf.Variable(tf.zeros([n_h1])),
    	'dc_b2': tf.Variable(tf.zeros([n_input])),
    	'fc_b': tf.Variable(tf.zeros([n_output]))
    }
    
    def encoder(x):
    	layer1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['ec_h1']), biases['ec_b1']))
    	layer2 = tf.nn.sigmoid(tf.add(tf.matmul(layer1, weights['ec_h2']), biases['ec_b2']))
    	return layer2
    
    
    def decoder(x):
    	layer1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['dc_h1']), biases['dc_b1']))
    	layer2 = tf.nn.sigmoid(tf.add(tf.matmul(layer1, weights['dc_h2']), biases['dc_b2']))
    	return layer2
    
    
    def fullconnection(x):
    	# out_layer = tf.nn.softmax(tf.add(tf.matmul(x, weights['ful_w']), biases['ful_b']))
    	out_layer = tf.nn.softmax(tf.add(tf.matmul(x, weights['fc_w']), biases['fc_b']))
    	return out_layer
    
    
    def getData(dataDir):
    	filelist = os.listdir(dataDir)
    	data = []
    	label = []
    	np.random.shuffle(filelist)
    	for i, imagename in enumerate(filelist):
    		imagename_s = imagename.split('.')
    		if imagename_s[-1] == 'jpg':
    			im = np.array(Image.open(dataDir + imagename))
    			image = np.reshape(im, (n_input))
    			data.append(image)
    			label.append(int(imagename_s[0]))
    	data = np.array(data)
    	data = data / 255.
    	# label = tf.one_hot(indices=label, depth=10, on_value=1, off_value=0)
    	label1 = np.zeros((len(label), 10))
    	label1[np.arange(len(label)), label] = 1
    	return data, label1
    
    
    def autoencode():
    	# pretrain
    	X = tf.placeholder(tf.float32, [None, n_input])
    	encoder_op = encoder(X)
    	decoder_op = decoder(encoder_op)
    	p_y_true = X
    	p_y_pred = decoder_op
    	p_loss = tf.reduce_mean(tf.square(p_y_true - p_y_pred))
    	p_optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(p_loss)
    
    	# fine-tune
    	f_y_true = tf.placeholder('float', [None, 10])
    	f_y_pred = fullconnection(encoder_op)
    	f_loss = -tf.reduce_sum(f_y_true * tf.log(f_y_pred))	# cross_entropy
    	f_optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(f_loss)
    	correct_pred = tf.equal(tf.argmax(f_y_true, 1), tf.argmax(f_y_pred, 1))
    	accuracy = tf.reduce_mean(tf.cast(correct_pred, 'float'))
    
    	train_data, train_label = getData(TRAIN_DATA_DIR)
    	print(train_data.shape)
    	init = tf.global_variables_initializer()
    	with tf.Session() as sess:
    		sess.run(init)
    		total_batch = int(train_data.shape[0] / batch_size)
    
    		# pretrain
    		p_train_pred = np.array([])
    		for epoch in range(p_training_epochs):
    			for i in range(total_batch):
    				batch_xs = train_data[i * batch_size : (i + 1) * batch_size]
    				_, p_l , train_pred = sess.run([p_optimizer, p_loss, p_y_pred], feed_dict={X: batch_xs})
    			print('pretrain---Epoch:' + str(epoch) + ' loss = ' + str(p_l))
    		print('\nPretrain Finished!\n')
    
    		test_data, test_label = getData(TEST_DATA_DIR)
    
    		if args.type == '1':
    			for epoch in range(0, f_training_epochs):
    				for i in range(0, total_batch):
    					# batchsize = 192
    					batch_xs = train_data[i * batch_size : (i + 1) * batch_size]
    					batch_ys = train_label[i * batch_size : (i + 1) * batch_size]
    					_, f_l = sess.run([f_optimizer, f_loss], feed_dict={X: batch_xs, f_y_true: batch_ys})
    				y_pred, ac = sess.run([f_y_pred, accuracy], feed_dict={X: batch_xs, f_y_true: batch_ys})
    				print('finetune---Epoch:' + str(epoch) + ' loss = ' + str(f_l) + ', training accuracy = ' + str(ac))
    			print('\nFinetune Finished!\n')
    			test_accuracy = sess.run([accuracy], feed_dict={X: test_data, f_y_true: test_label})
    			print('test accuracy:' + str(test_accuracy))
    		elif args.type == '0':
    			encode_decode = sess.run(p_y_pred, feed_dict={X: test_data[:20]})
    			f, a = plt.subplots(2, 10, figsize=(10, 2))
    			for i in range(10):
    				a[0][i].imshow(np.reshape(test_data[i], (28, 28)), cmap='gray')
    				a[1][i].imshow(np.reshape(encode_decode[i], (28, 28)), cmap='gray')
    			f.show()
    			plt.draw()
    			plt.show()
    
    if __name__ == '__main__':
    	autoencode()

    图片的第一行为原图,第二行是对应的生成结果,由于网络存在损失,第二行相对模糊一点。

    展开全文
  • from sklearn.datasets import load_digits # sklearn 为我们提供的手写数字数据集 import numpy as np # 数据预处理 digits = load_digits() X_data = digits.data.astype(np.float32) y_data = digits.target.as...

    利用K近邻算法与CNN(卷积神经网络)实现手写数字识别

    from sklearn.datasets import load_digits  # sklearn 为我们提供的手写数字数据集
    import numpy as np
    
    # 数据预处理
    digits = load_digits()
    X_data = digits.data.astype(np.float32)
    y_data = digits.target.astype(np.float32).reshape(-1, 1)
    
    X_data.shape, y_data.shape
    

    在这里插入图片描述

    # 数据的标准化(normalization)是将数据按比例缩放,
    # 使之落入一个小的特定区间。这样去除数据的单位限制,
    # 将其转化为无量纲的纯数值,便于不同单位或量级的指标能够进行比较和加权。
    from sklearn.preprocessing import OneHotEncoder
    from sklearn.preprocessing import MinMaxScaler
    scaler = MinMaxScaler()
    X = scaler.fit_transform(X_data)
    X = X.reshape(-1, 8, 8, 1)
    y = OneHotEncoder(categories='auto').fit_transform(
        y_data).todense()  # one-hot 编码
    
    X.shape, y.shape
    

    在这里插入图片描述

    model = tf.keras.models.Sequential()
    
    #添加第一个卷积层,使用tf.keras.layers.Conv2D()实现
    model.add(tf.keras.layers.Conv2D(
        filters=10,              # 卷积层神经元(卷积核)数目
        kernel_size=[3, 3],      # 卷积核大小
        strides=(1, 1),          # 步长
        padding='same',          # padding策略(vaild 或 same)
        activation=tf.nn.relu,   # 激活函数
        input_shape=(8, 8, 1)    # 指出输入的形状 (samples,rows,cols,channels),只指出后三维,第一维度按 batch_size 自动指定
    ))
    
    #添加池化层,选择最大池化,使用,tf.keras.layers.MaxPool2D()实现
    model.add(tf.keras.layers.MaxPool2D(
        pool_size=[3, 3],      # 池窗口大小
        strides=2,             # 步长
        padding='same'
    ))
    
    #卷积层 + BN归一化层 + 激活层,使用tf.keras.layers.BatchNormalization()实现Batch归一化
    model.add(tf.keras.layers.Conv2D(filters=5, kernel_size=[3, 3], strides=(2, 2), padding='same'))
    model.add(tf.keras.layers.BatchNormalization())
    model.add(tf.keras.layers.Activation('relu'))
    
    #池化层
    model.add(tf.keras.layers.MaxPool2D(pool_size=[3, 3], strides=2, padding='same'))
    
    #展开特征图
    model.add(tf.keras.layers.Reshape(target_shape=(1*1*5,)))
    
    #全连接层
    model.add(tf.keras.layers.Dense(units=50, activation=tf.nn.relu))
    
    #输出层
    model.add(tf.keras.layers.Dense(units=10))
    model.add(tf.keras.layers.Softmax())
    
    #通过model.summary()输出模型各层的参数状况
    model.summary()
    

    在这里插入图片描述

    #配置训练过程
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),    # 设置优化器,这里使用 Adam 优化器,设置学习率为 0.001
        loss=tf.keras.losses.categorical_crossentropy,              # 设置损失函数,这里使用交叉熵损失
        metrics=[tf.keras.metrics.categorical_accuracy]             # 设置评估指标,用于检查 y_ture 中最大值对应的 index 与 y_pred 中最大值对应的 index 是否相等
    )
    
    batch_size = 32  # 设定 batch_size 为 32
    epochs = 50  # 迭代 50 个周期
    model.fit(X, y, epochs=epochs, batch_size=batch_size)
    

    实验结果

    展开全文
  • 一.建立数据集,超参数设置 二.建立Auto-Encoder架构 三.训练 1.训练结果 2.程序

    一.建立数据集,超参数设置
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    二.建立Auto-Encoder架构
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    三.训练
    1.训练结果
    在这里插入图片描述
    在这里插入图片描述
    2.程序
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 多分类——手写数字识别数据集 是在二分类的基础上加上了调库,独热编码操作。 不同处:特征缩放(归一化),准确率(np.argmax) 代码如下: ''' 要求: 手写数字识别数据集,共有10000个样本,分为10类别。 每个样本的特征...
  • 对基于深度神经网络的Auto Encoder用于异常检测的一些思考 from:https://my.oschina.net/u/1778239/blog/1861724 一、前言  现实中,大部分数据都是无标签的,人和动物多数情况下都是通过无监督学习获取概念,...
  • 《Voice Conversion from Non-parallel Corpora Using Variational Auto-encoder》论文学习 文章目录《Voice Conversion from Non-parallel Corpora Using Variational Auto-encoder》论文学习  摘要  1 ...
  • import tensorflow as tf import numpy as np from sklearn.utils import ...from sklearn.preprocessing import OneHotEncoder import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #导入MNIST数据集 mnist = tf...
  • 目录1 Auto-encoder基本概念1.1 基本任务1.2 网络结构1.3 Encoder1.4 Auto-encoder起源1.5 De-noising Auto-encoder2 Auto-encoder的应用与延伸2.1 Feature Disentangle2.2 Discrete Representation2.3 Generator2.4...
  • 作为深度学习的第一个任务呢,一般都会选择手写数字识别作为我们的第一个项目,因为识别起来并不是很困难,而且精度可以达到0.99。下面就正式开始我们的第一个小项目吧。 先来说一下流程: 1. 准备数据集,可以在...
  • 一、Auto-encoder 通过重建输入得到一个低维空间的code 二、Deep Auto-encoder 输入从高维映射到低维再到...在手写数字辨识中,Deep Auto-encoder比PCA重构的结果好,数据映射到低维空间区分度也更高。 三...
  • 编码器(encoder):这部分能将输入压缩成潜在空间表征,可以用编码函数h=f(x)表示。 解码器(decoder):这部分重构来自潜在空间表征的输入,可以用解码函数r=g(h)表示。 因此,整个自编码器可以用函数g(f(x)) = r 来...
  • 第六章:利用PyTorch实现简单与经典的模型全过程:简单二分类、手写字体识别、词向量的实现、自编码器实现。 第七章:利用PyTorch实现复杂模型:翻译机(nlp领域)、生成对抗网络(GAN)、强化学习(RL)、风格迁移...
  • Tensorflow 2 Auto-Encoder

    2021-02-25 14:48:45
    Auto-Encoder 相比较于其他的有监督学习不同,本质上AE是一个无监督学习的过程。那么首先回顾和区分一下有监督学习和无监督学习的不同 这里将有监督学习大致可以分为回归和分类两个大类,虽然回归和分类两者不同...
  • 下面来看一下,对于MNIST手写数字数据集用像素点、PCA、Deep Auto Encoder三种方式分别做tSNE的展现图 右上角为deep auto encoder之后做tSNE,所有的数字都分的很开,效果比较好。 总结一下,PCA和Deep auto ...
  • 而One-hot也代表了分类任务,比如0-9手写体的识别! 例子:VQVAE(Vector Quantized Variational Auto-encoder) Codebook中是一系列向量,是学习出来的数据! 同时也是预定义的向量! 我们需要的就是计算Encoder出...
  • Auto-encoder NN Encoder & NN Decoder 要一起训练。 二 Starting from PCA ...三 Deep Auto-encoder ...当code为二维时,很明显看到Deep Auto-encoder使数字手写识别集分类地更好。 ...
  • Variational Auto-Encoder Example Build a variational auto-encoder (VAE) to generate digit images from a noise distribution with TensorFlow. Author: Aymeric Damien Project: ...
  • 本人仅以 PaddlePaddle 深度学习 101 官网教程为指导,添加个人理解和笔记,仅作为学习练习使用,若有错误,还望批评指教。...识别数字 本教程源代码目录在book/recognize_digits, 初次使用请...
  • 文章目录前言自动编码器介绍自动编码器重建手写数字关于损失函数重建结果这部分实验代码 前言 先来看看实验: 我们使用 MNIST 手写数字,测试通过自动编码器和对抗性自动编码器学习重建恢复效果。 原始图像: 自动...
  • 人工智能 - paddlepaddle飞桨 - 深度学习基础教程 - 数字识别 本教程源代码目录在book/recognize_digits,初次使用请您参考Book文档使用说明。 说明:¶ 硬件环境要求: 本文可支持在CPU、GPU下运行 Docker...
  • Auto-Encoder Example 本文具体数据集与源代码可从我的GitHub地址获取 https://github.com/liuzuoping/Deep_Learning_note 用tensorflow构建一个两层的auto-encoder,把图像压缩到一个低维隐层空间并重构。 Auto-...
  • VAE_MNIST数字图片识别及生成

    千次阅读 2020-06-28 23:01:19
    VAE:Variational Auto-Encoder 自动变分编码器,根据样本生成和样本类似的数据。VAE是无监督学习(样本不需要分类,没有标签的学习),而 半监督学习则是样本需要分类加标签。 对于VAE的理解这篇写得很好: VAE原理...
  • 近年,随着有监督学习的低枝果实被采摘的所剩无几,无监督学习成为了研究热点。VAE(Variational Auto-Encoder,变分自编码器)[1,2] 和 GAN(Generative Adversarial Networks) 等模型,受到越来越多的关
  • 输入:一个28*28的数字图片,经过encoder转化,输出:code(降维后结果) 因为我们不知道code什么样子,所以也就没办法训练encoder,故需要训练decoder(解码器) 2.Decoder解码器 输入:code(低...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 617
精华内容 246
关键字:

auto encoder手写数字识别