码迷,mamicode.com
首页 > 其他好文 > 详细

TensorFlow实战--阅读笔记part2

时间:2017-09-08 12:03:52      阅读:415      评论:0      收藏:0      [点我收藏+]

标签:不同   href   部分   active   anaconda   交互式   nbsp   scale   0.00   

一、Tensorflow编译安装

推荐使用Anaconda作为python环境,可以避免大量的兼容性问题

tensorflow安装过程

以在服务器上安装为例(linux)  

1.在anaconda官网上下载与自己机器对应的版本 下载.sh形式的文件

2.在anaconda下载目录中输入以下路径(下载的文件名可能不同)

$ bash Anaconda-4.2.0-Linux-x86_64.sh

3. 安装tensorflow-cpu版本  如果要安装gpu,请跳到第4步

推荐安装编译好的release版本,装起来比较简单  也就是直接用网上的已经编译好的.whl文件

$ pip install --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.0.0rc0-cp35-cp35m-linux_x86_64.whl

后面的网址可以到网上找相应的版本进行替换

4. 安装tensorflow-gpu版本

需要预先安装显卡驱动,CUDA和cuDNN

CUDA的安装包里一般集成了显卡驱动,直接在官网下载  CUDA下载   下载.run文件

注意:安装之前先看下网上已经编译好的tensorflow-gpu支持的CUDA和cuDNN的具体版本再安装,这样之后就不会出现不兼容的问题

安装CUDA:

$ chmod u+x cuda_8.0.44_linux.run
$ sudo ./cuda_8.0.44_linux.run

在安装过程中根据提示可以自己设置安装路径,一般可以选择不安装CUDA samples,因为只是通过tensorflow调用cuda,并不需要写cuda代码

安装cuDNN:

官网下载.tgz压缩包, 并到下载路径,输入命令

$ sudo tar -xzvf cudnn-8.0-linux-x64-v5.1.tgz

通常是要把cuDNN的文件里的内容全部复制到cuda-8.0的相应目录下

设置系统环境中CUDA路径:

$ vim ~/.bashrc
在文件底部加入
export LD_LIBRARY_PATH=/usr/local/cuda08.0/lib64:/usr/local/cuda-8.0/extras/CUPTI/lib64:$LD_LIBRARY_PATH
export CUDA_HOME=/usr/local/cuda-8.0
export PATH=/usr/local/cuda-8.0/bin:$PATH
保存退出
$source ~/.bashrc

安装tensorflow-gpu:

同样推荐安装编译好的release版本,一步到位

pip install --upgrade https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.0.0rc0-cp35-cp35m-linux_x86_64.whl

 

 

二、Tensorflow实现softmax regression识别手写数字

1. 下载MNIST数据:

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)

MNIST数据集是28x28像素的图像,这里为了简便,拉伸成一个784维的特征

共有55000张训练图片,所以训练数据特征是一个55000x784的tensor 

label是55000x10的tensor, 每一个样本的label是相应的one-hot表示

2. 分类模型选择softmax regression的算法,常用于多分类任务

对于后面的CNN和RNN,如果是分类模型,最后一层同样是softmax regression,用于对每个类别进行估算概率

  技术分享

每个类别都有自己的一套W和b, b表示数据本身的一些倾向,比如大部分数字都是0,那么0对应的bias会很大

import tensorflow as tf
sess = tf.InteractiveSession()  #将这个session注册为默认的session
x = tf.placeholder(tf.float32,[None,784])  #输入数据
W = tf.Variable(tf.zeros(784,10]))
b = tf.Variable(tf.zeros([10])

y = tf.nn.softmax(tf.matmul(x,W)+b)

tf.nn包含了大量神经网络组件,tensorflow最厉害的地方不是定义公式,而是将forward和backword的内容都自动实现(无论是CPU或者GPU),只要接下来定义好loss,训练时将会自动求导并进行梯度下降,完成对softmax regression模型参数的自动学习

3.定义loss function

 对于多分类问题,通常使用cross-entropy作为loss function

y_ = tf.placeholder(tf.float32,[None,10])  #输入正确的label
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

这里的*是element-wise乘法,只是选出正确标签位置的相应预测概率, reduction_indices=[1]是按行加和,最后再reduce_mean对所有样本的loss做平均

 4.定义优化算法进行自动求解

train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

全局初始化参数:

tf.global_variables_initializer().run()

只要定义了variables,就一定要有这么一句,位置就放在所有变量定义之后

5.进行迭代训练

这里每次都随机从训练集中抽取100条样本高层一个mini-batch,并feed给placeholder,然后调用train_step对这些样本进行训练

 

for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    train_step.run({x:batch_xs, y_:batch_ys})

 

完成了训练,就可以对模型的准确率进行验证

correct_prediction= tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
print(accuracy.eval({x:mnist.test.images,y_:mnist.test.labels}))

tf.argmax是寻找一个向量中最大值的序号,1表示是按行找每行最大值的下标    

tf.equal则是判断预测的数字类别是否就是正确的类别,返回的是True,False矩阵

tf.cast是把True,False投射到实数上,比如True表示1,False表示0

然后tf.reduce_mean是计算所有样本中预测正确样本所占的比例

其实上面correct_prediction和accuracy都是定义的计算图中的两个节点,并没有实际计算它们的输出结果

所以第三行代码accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels})才是真正的运行计算图

注意这里是因为使用了交互式的接口sess = tf.InteractiveSession()

所以这里可以用node.run(feed_dict={})运行节点,node.eval(feed_dict={})计算输出值     其他方法的话需要用sess.run(node,feed_dict={})

以上的这个简单的算法可以达到92%的精确度,所以说神经网络的效果很惊人

 

设计神经网络流程:

  1. 定义算法公式,也就是神经网络forward时的计算
  2. 定义loss,选定优化器,并制定优化器优化loss
  3. 迭代地对数据进行训练
  4. 在测试集或验证集上对准确率进行评测

定义的各个公式其实就是计算图,在执行这行代码时,计算还没实际发生,只有等调用run方法,并feed数据时计算才真正执行

比如cross_entropy,train_step,accuracy等都是计算图中的节点,不是数据结构,只有通过run方法执行这些节点才能得到计算结果

 

三、Tensorflow实现自编码器

深度学习是一种无监督的特征学习,模仿了人脑的对特征逐层抽象提取的过程

早年学者研究稀疏编码时,收集了大量黑白风景照,并提取了许多16x16的图像碎片,他们发现几乎所有图像碎片都可以有64种正交边组合得到,而且组合一张图像碎片所需要的边的数量是很少的,即稀疏的。同样声音也存在这种现象,绝大多数声音可以有一些基本结构线性组合得到,这其实就是特征的稀疏表达,使用少量的基本特征组合拼接得到更高层抽象的特征。多层神经网络中前一层的输出都是未加工的项数,后一层则是对像素进行加工组织成更高阶的特征(即前面提到的将边组合成图像碎片)

  技术分享

 

自编码器AutoEncoder

对于没有标注的数据,可以使用无监督的自编码器来提取特征

自编码器也是一种神经网络,它的输入和输出是一致的,借助稀疏编码的思想,目标是使用稀疏的一些高阶特征重新组合来重构自己

特点:

  1. 期望输入/输出一致
  2. 希望使用高阶特征来重构自己,而不是复制像素点

技术分享

 

Tensorflow实现自编码器

 实现的是去噪自编码器,给输入加上高斯加性噪声,希望输出原数据

用scikit-learn中的preprocessing模块对数据进行预处理

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

 参数初始化方法xavier initialization,根据某一层网络中的输入输出节点数量自动调整为最合适的分布,满足0均值,方差为2/(Nin+Nout),分布可以为均匀分布或者高斯分布

下面代码设置的均匀分布,可以用公式计算方差D(x) = (max-min)^2/12 = 2/(Nin+Nout)

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)

 

下面定义一个去噪自编码器的class

class AdditiveGaussianNoiseAutoencoder(object):
    def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus,
        optimizer=tf.train.AdamOptimizer(),scale=0.1):
        # initialize the parameters
        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

        # define the network architecture
        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])

        # define loss function
        self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(
            self.reconstruction,self.x),2.0))
        self.optimizer = optimizer.minimize(self.cost)

        # run the session
        init = tf.global_variables_initializer()
        self.sess = tf.Session()
        self.sess.run(init)

    # define initialization function
    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))
        # reconstruction layer has no activate function, so can initialized by zero
        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

    # define a train step with a batch
    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 

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

    # output the hidden state of the data
    def transform(self,X):
        return self.sess.run(self.hidden,feed_dict={self.x:X,
            self.scale:self.training_scale})

    # reconstruct data by the hidden state
    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})

    # transform + generate input original data, output reconstructed data
    def reconstruct(self,X):
        return self.sess.run(self.reconstruction,feed_dict={self.x:X,self.scale:self.training_scale})

    def getWeights(self):
        return self.sess.run(self.weights[w1])

    def getBiases(self):
        return self.sess.run(self.weights[b1])

 

去噪自编码器的class定义如上,其中包括神经网络的设计,权重的初始化以及常用的成员函数

接下来用定义好的AGN自编码器在MNIST数据集上进行一些测试看数据复原的效果如何

mnist = input_data.read_data_sets(MNIST_data,one_hot=True)

# preprocess the data as 0-mean 1-std distribution
# train and test should use the same scaler
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 no return sampling function with a batch
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)]

X_train,X_test = standard_scale(mnist.train.images,mnist.test.images)

 

     以上定义了两个函数,一个是用来标准化数据的函数,将数据标准化到0均值,标准差为1的分布

第二个函数就是获取一个随机的batch_size大小block的数据,下面是实例测试:

# define parameters
n_samples = int(mnist.train.num_examples)
training_epochs = 20
batch_size = 128
display_step = 1
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):
        bach_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)))

 

运行结果如下:

技术分享

可以看到通过迭代,loss逐渐降低,说明还原效果逐渐变好

总结:

自编码器作为一种无监督学习的方法,它与其他无监督学习的主要不同在于,它不是对数据进行聚类,而是提取其中最有用,最频繁出现的额高阶特征,根据这些高阶特征重构数据。

 

三、Tensorflow实现多层感知机

有理论研究表明,为了拟合复杂函数需要的隐含节点的数目,基本上随着隐含层的书领真多呈指数下降趋势,也就是说层数越多,神经网络所需要的隐含节点可以越少,这也是深度学习的特点之一,层数越深,概念越抽象,需要背诵的知识点(神经网络隐含节点)就越少。

过拟合意味着泛化性能不好,模型只是记忆了当前数据的特征,不具备推广能力,通过dropout的方式可以防止过拟合,随机丢弃层中的节点,表示丢弃了某些特征,也是一种bagging的思想,我们可以理解为每次丢弃节点数据都是对特征的一种采样。相当于我们训练了一个ensemble的神经网络模型,对每个样本都做特征采样。

参数难以调试也是一个大问题,有理论表示,神经网络可能有很多个局部最优解都可以达到比较好的分类效果,而全局最优反而容易是过拟合的解

对SGD,一开始我们希望学习速率大一些,可以加速收敛,但是训练的后期又希望学习速率可以小一点,这里可以比较稳定地落入一个局部最优解,不同的机器学习问题所需要的学习速率也不太好设置,需要反复调试,因此就有像Adagrad,Adam,Adadelta等自适应的方法可以减轻调试参数的负担 

tensorflow实例

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf 
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
sess = tf.InteractiveSession()

in_units = 784
h1_units = 300
W1 = tf.Variable(tf.truncated_normal([in_units,h1_units],stddev=0.1))
b1 = tf.Variable(tf.zeros([h1_units]))
W2 = tf.Variable(tf.zeros([h1_units,10]))
b2 = tf.Variable(tf.zeros([10]))

x = tf.placeholder(tf.float32,[None,in_units])
keep_prob = tf.placeholder(tf.float32)

 

下面定义网络结构,比之前的softmax模型多了一个隐含层

# define network structure
hidden1 = tf.nn.relu(tf.matmul(x,W1)+b1)
hidden1_drop = tf.nn.dropout(hidden1,keep_prob)
y = tf.nn.softmax(tf.matmul(hidden1_drop,W2)+b2)

#define loss
y_ = tf.placeholder(tf.float32,[None,10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y),reduction_indices=[1]))
train_step = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy)

 

在训练的时候,输入dropout参数,keep_prob表示保留结点的占比,其余置0

注意在测试过程中不要进行dropout,所以keep_prob设为1

tf.global_variables_initializer().run()
for i in range(3000):
    batch_xs,batch_ys = mnist.train.next_batch(100)
    train_step.run({x:batch_xs,y_:batch_ys,keep_prob:0.75})

correct_prediction= tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
print(accuracy.eval({x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0}))

 

测试结果:

技术分享

仅仅是加了一层隐含层,精确度就由92%到98%,课件多层神经网络的效果有多显著,同时也使用了一些trick来进行辅助,比如dropout,adagrad,relu等,但是起决定性作用的还是隐含层本身,它能对特征进行抽象和转化

没有隐含层的softmax regression只能直接从图像的额像素点推断是哪个数字,而没有特征抽象的过程。多层神经网络依靠隐含层,这可以组合出高阶特征,比如横线,竖线,圆圈等,之后可以将这些高阶特征或者说组件再组合成数字,就能实现精准地匹配和分类。隐含层输出的高阶特征经常是可以复用额,所以每一类的判别,概率输出都共享这些高阶特征,而不是个字连接独立的高阶特征 

TensorFlow实战--阅读笔记part2

标签:不同   href   部分   active   anaconda   交互式   nbsp   scale   0.00   

原文地址:http://www.cnblogs.com/lainey/p/7477646.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!