Win10：tensorflow学习笔记（4）

最新推荐文章于 2019-06-29 22:25:47 发布

Big_quant

最新推荐文章于 2019-06-29 22:25:47 发布

阅读量514

点赞数

分类专栏：深度学习 tensorflow学习与实践文章标签： Win10 深度学习 tensorflow

本文链接：https://blog.csdn.net/lvsehaiyang1993/article/details/80542957

版权

深度学习同时被 2 个专栏收录

60 篇文章 7 订阅

订阅专栏

tensorflow学习与实践

13 篇文章 5 订阅

订阅专栏

前言

学以致用，以学促用。输出检验，完整闭环。
经过前段时间的努力，已经在电脑上搭好了深度学习系统，接下来就要开始跑程序了，将AI落地了。
安装win10下tensforlow 可以参照之前的例子：win10+gpu安装
在使用gpu版本中一些特别的问题，可以参照这篇：win10+tensorflow+gpu
在运行过程中遇到的一些错误，可以参照这篇:：tensorflow 错误
tensorflow的一些基础概念，可以参见这篇：tensorflow学习笔记（1）
tensorflow的发展故事，可以参见这篇：tensorfow学习笔记（2）
tensorflow的第一个上手应用，可以参见这篇：tensoeflow学习笔记（3）

怕什么真理无穷，进一寸有一寸的欢喜——胡适

前言
Tensorflow实现自编码器（autoencoder）
- 1自编码器（AutoEncoder）
数据载入

Tensorflow实现自编码器（autoencoder）

hello-world项目已经实现，现在可以开始进行下一阶段了。
基本的神经元实现后，接下来将是一很基本但很有用的网络吧。

1自编码器（AutoEncoder）

传统机器学习任务很大程度上依赖于特征工程，比如说体重和身高的比值，直径和周长的比值，要想提取到合适的特征，需要工程师对领域背景有很深的认知与了解。而深度学习则可以解决人工难以提取有效的特征的问题，它可以缓解机器学习模型对特征的依赖。也因此深度学习在早期被认为是一种无监督的特征学习，模仿了人脑对特征逐层抽象提取的过程。
这里面有两点很重要：

无监督学习，不需要对数据进行标注，事实上标注好的数据集，是非常宝贵的资源，深度学习，学习到的是数据内容组织形式的学习，提取的是频繁出现的特征。
逐层抽象，特征是需要不断抽象的，就像我们对概念的学习，总是从简单的开始。

举个例子，你是怎么认出一个人的？
光从图片上去看，是看不出结果的，所以你对图片上的东西进行分类，这是鼻子，这是耳朵，这是嘴巴，这整体是我的小伙伴。
基本概念讲到这里，下面引入自编码器。

1.1自编码器起源

在之前研究稀疏编码（sparse coding）时，学者们收集了大量黑白风景照，并从中提取了许多16像素*16像素的图像碎片。在对图像碎片研究后，发现几乎所有的图像碎片都可以由64种正交的边组合得到，在对其他数据进行研究的时候也发现了。而这就是特征的稀疏表达，使用少量的基本特征组合拼装得到更高些抽象层的特征。
通常我们也需要多层的神经网络，对每一层神经网络来说，前一层的输出都是未加工的像素，而这一层则是对像素进行加工组织成更高阶的特征（即前面提到的将边组合成图像碎片）。
这里写图片描述
特征边。

1.2自编码器

无监督自编码器，使用自身的高阶特征编码自己。自编码器是一种特殊的神经网络，它的输入和输出是一致的，它借助稀疏编码的思想，目标是使用稀疏的一些高阶特征重新组合来重构自己。因此，它的特点是非常明显：第一，期望输入/输出一致；第二，希望使用高阶特征来重构自己，而不只是复制像素点。
Hinton教授在SCIENCE发表文章，讲解了使用自编码器对数据进行降维的方法。Hinton还提出了基于深度信念网络（DBN）可使用无监督的逐层训练的贪心算法，为训练很深的网络结构提供了一个可行的方案：
我们可能很难直接训练极深的网络，但是可以用无监督的逐层训练提取特征，将网络的权重初始化到一个比较好的位置，辅助后面的监督训练。
无监督的逐层训练，其思想和自编码器（autoencoder）非常相似。后者的目标是让神经网络的输出能和原始输入一致，相当于学习一个恒等式x=y，如图4-3所示。自编码器的输入节点和输出节点是一致的，但如果只是单纯地逐个复制输入节点则没有意义，像前面提到的，自编码器通常希望使用少量稀疏的高阶特征来重构输入，所以我们可以加入几种限制：

如果限制中间隐含层节点的数量，则可以实现降维，学习到最重要的特征。如果再加一个l1正则化约束，那学习到的就更是最主要最重要的特征了。
如果给数据加入噪声，那么就是Denoising Autoencoder，去噪自编码器，将学习到更主要的特征

对于噪声的设置也是一个trick，不同的噪声有不同的优点，需要具体体会。

1.3DBN(深度信念网络)

如果自编码器的隐含层只有一层，那么其原理类似于主成分分析（PCA）。hinton提出的DBN模型有多个隐含层，每个隐含层都是限制性玻尔兹曼机（RBM，一种具有特殊连接分布的神经网络）。
DBN训练时，需要先对每两层间进行无监督的预训练，这个过程就相当于一个多层的自编码器，可以将整个网络的权重初始化到一个理想的分布。最后，通过反向传播算法调整模型权重，这个步骤会使用经过标注的信息来做监督性的分类训练。当年DBN给训练深层深层的神经网络带来了可能性，它能解决网络过深带来的梯度弥散（gradient vanishment）问题，让训练变得容易。简单地说，HInton的思路就是先用自编码器的方法进行无监督的预训练，提取特征并初始化权重，然后使用标注信息进行监督式的训练。当然自编码器的作用不仅局限于给监督训练做预训练，直接使用自编码器进行特征提取和分析也是可以的。现实中数据最多的还是未标注的数据，因此自编码器拥有许多用武之地。

1.4自编码器实现

下面我们就开始实现最具代表性的去噪自编码器。去噪自编码器的使用范围最广也最通用。而其它几种自编码器，读者可以对代码加以修改自行实现，其中无噪声的自编码器只需要去掉噪声，并保证隐含层节点小于输入层节点：Masking Noise的自编码器只需要将高斯噪声改为随机遮挡噪声；variationl autoencoder 则相对复杂，VAE对中间分布的节点由强假设，拥有额外的损失项，且会使用特殊的SGVB算法进行训练。目前VAE还在生成模型中发挥了很大的作用。
####1.4.1导入常用库
首先导入数值处理，numpy库，接着导入scikit-learn的preprocessing 模块，最后依旧是mnist数据集

import numpy as np import sklearn.preprocessing as prep import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data

1.4.2参数初始化方法

参数的初始化对于神经网络的训练至关重要，这次实验我们选择xavier initialization方法，该方法会根据某一层网络的输入，输出节点数量自动调整最合适的分布。具体可以参见yoshua benigo的那篇论文。

def xavier_init(fan_in,fan_out,constant=1): low=-constant*np.sqrt(6.0/(fan_in+fan_out)) high=constant*np.sqrt(6.0/(fan_in+fan_out)) return tf.random_uniform((fan_in,fan_out), minval=low,maxval=high, dtype=tf.float32 )

1.4.3定义自编码器类

构建函数，构建函数包含这样几个输入，n_input,n_hidden,transfer_function,optimizer,scale,这个自编码器只做了一个隐含层。

#the an autoencoder class AdditiveGaussianNoiseAutoencoder(object): def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus, optimizer=tf.train.AdamOptimizer(),scale=0.1): self.n_input=n_input self.n_hidden=n_hidden self.transfer=transfer_function self.scale=tf.placeholder(tf.float32) self.training_scale=scale network_weights=self._initialize_weights() self.weights=network_weights

然后是定义网络结构，我们为输入创建一个维度为n_input的placeholder。然后建立一个能提取特征的隐含层，最后再把提取的结果输出去。

##the structure of network
        self.x=tf.placeholder(tf.float32,[None,self.n_input])
        self.hidden=self.transfer(tf.add(tf.matmul(
                self.x+scale*tf.random_normal((n_input,)),self.weights['w1']),
        self.weights['b1']))
        self.reconstruction=tf.add(tf.matmul(self.hidden,
                                             self.weights['w2']),
        self.weights['b2'])

接下来定义自编码器额损失函数，这里直接使用平方误差（Squared error）作为cost，即tf.subtract计算输出于输入之差，再使用tf.pow求差的平方，最后使用tf.reduce_sum求和即可得到平方误差。最后创建session，并初始化自编码器的全部模型参数。

# the definition of cost function self.cost=0.5*tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction,self.x) ,2.0)) self.optimizer=optimizer.minimize(self.cost) init=tf.global_variables_initializer() self.sess=tf.Session() self.sess.run(init)

下面来看一下参数初始化函数——initialize_weights,先创建一个名为all_weights的字典dict，然后将w1，b1，w2，b2全部存入其中，最后返回all_weights.

##initialization parameters def _initialize_weights(self): all_weights=dict() all_weights['w1']=tf.Variable(xavier_init(self.n_input, self.n_hidden)) all_weights['b1']=tf.Variable(tf.zeros([self.n_hidden], dtype=tf.float32)) all_weights['w2']=tf.Variable(tf.zeros([self.n_hidden,self.n_input], dtype=tf.float32 )) all_weights['b2']=tf.Variable(tf.zeros([self.n_input],dtype=tf.float32 )) return all_weights

下面我们定义计算损失cost及执行一步训练的函数partial_fit.


> ##calculate the cost and ons step train
>     def partial_fit(self,X):
>         cost,opt=self.sess.run((self.cost,self.optimizer),
>                                feed_dict={self.x:X,self.scale:self.training_scale})
>         return cost

我们也需要一个只求损失的函数

   >     ##only cost
>     def calc_total_cost(self,X):
>         return self.sess.run(self.cost,feed_dict={self.x:X,self.scale:self.training_scale
>                 })
>

定义一个transform函数，返回自编码器的输出结果。提供一个接口，返回抽象后的特征。

>     ##transform function
>     def transform(self,X):
>         return self.sess.run(self.hidden,feed_dict={self.x:X,self.scale:self.training_scale
>                 })

再定义generate函数，它将隐含层的输出结果作为输入，通过之后的重建层将提取到的高阶特征复原为原始数据。

>  def generate(self,hidden=None):
>         if hidden is None:
>             hidden=np.random.normal(size=self.weights["b1"])
>         return self.sess.run(self.reconstruction,feed_dict={self.hidden:hidden})

接下来再定义reconstruct函数，他将整体运行一次复原过程，包括提取高阶特征和通过高阶特征复原数据，既包括transform和generate两块。

##reconstruct function
def reconstruct(self,X):
return self.sess.run(self.reconstruction,feed_dict={self.x:X,self.scale:self.training_scale
})
获得隐含层的权重w1
##getWeights function get the hidden layer w1
def getWeights(self):
return self.sess.run(self.weights[‘w1’])
获取隐含层的偏置系数b1
##getBiases function get the hidden b1
def getBiases(self):
return self.sess.run(self.weights[‘b1’])
实现完成，现在测试性能：

1.5性能测试

数据载入

mnist=input_data.read_data_sets('MNIST_data',one_hot=True)
#数据标准化
def standard_scale(X_train,X_test):
    preprocessor=prep.StandardScaler().fit(X_train)
    X_train=preprocessor.transform(X_train)
    X_test=preprocessor.transform(X_test)
    return X_train,X_test
    随机获取训练集
##define a function to get random block data def get_random_block_from_data(data,batch_size):
    start_index=np.random.randint(0,len(data)-batch_size)
    return data[start_index:(start_index+batch_size)]
    #开始训练
## let's go 
X_train,X_test=standard_scale(mnist.train.images,mnist.test.images)
#参数初始化
##definition of parameters 
n_samples=int(mnist.train.num_examples) training_epochs=20 batch_size=128 display_step=1
#实例化一个autoencoder
#generate a instance of agn 
autoencoder=AdditiveGaussianNoiseAutoencoder(n_input=784,
                                             n_hidden=200,
                                             transfer_function=tf.nn.softplus,
                                             optimizer=tf.train.AdamOptimizer(learning_rate=0.001),
                                             scale=0.01
                                             ) for epoch in range(training_epochs):
    avg_cost=0;
    total_batch=int(n_samples/batch_size)
    for i in range(total_batch):
        batch_xs=get_random_block_from_data(X_train,batch_size)
        cost=autoencoder.partial_fit(batch_xs)
        avg_cost+=cost/n_samples*batch_size

    if epoch % display_step==0:
         print("Epoch:",'%04d'%(epoch+1),"cost=",
               "{:.9f}".format(avg_cost))
          print("Total cost:"+str(autoencoder.calc_total_cost(X_test)))

测试结果：

Epoch: 0001 cost= 19257.268114773
Epoch: 0002 cost= 12260.724660227
Epoch: 0003 cost= 10765.586961364
Epoch: 0004 cost= 9036.303831250
Epoch: 0005 cost= 10057.622447727
Epoch: 0006 cost= 9045.839046591
Epoch: 0007 cost= 10273.095478409
Epoch: 0008 cost= 8417.097377841
Epoch: 0009 cost= 9292.796898295
Epoch: 0010 cost= 9096.705695455
Epoch: 0011 cost= 8969.315593750
Epoch: 0012 cost= 8124.126701705
Epoch: 0013 cost= 8896.797426136
Epoch: 0014 cost= 7948.233773864
Epoch: 0015 cost= 8706.865909091
Epoch: 0016 cost= 8403.629502841
Epoch: 0017 cost= 8873.035804545
Epoch: 0018 cost= 7940.911138068
Epoch: 0019 cost= 7758.856397159
Epoch: 0020 cost= 7933.486597159
Total cost:680984.0

参考：tensorflow实战

Big_quant

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Win10：tensorflow学习笔记（4）

前言学以致用，以学促用。输出检验，完整闭环。怕什么真理无穷，进一寸有一寸的欢喜——胡适目录：前言Tensorflow实现自编码器（autoencoder）和多层感知机（multi-layer perception）1自编码器（AutoEncoder）1.1自编码器起源1.2自编码器1.3DBN(深度信念网络)1.4自编码器实现Tens...
复制链接

扫一扫