菜鸟学tensorflow.1

outline

`安装环境

`tensorflow原理简述

`定义网络结构、启动网络计算

`使用Variable定义模型参数，如何训练模型

`如何测试

只是自己的简要概括，最好对神经网络、机器学习略有了解。tensorflow的中文文档新手入门真的做的还不错，建议大家结合理论，码一码代码，上手很快的。

`安装环境

ubuntu 16.04，pycharm IDE、python 2.7

pycharm有教育账户的，学生可以免费使用。IDE集成了terminal、python console、调试、在命令行中还能ctrl+c/v粘贴复制，真的好用。另外集成了virtual environment，可以切换使用python2.7、python3.x，有兴趣的可以了解一下。

CPU版本

pip install tensorflow # Python 2.7; CPU support (no GPU support)

当然你也可以用清华源

pip install -i Simple Index tensorflow

#note

使用virtual environment的方法

file-new project-选择解释器的边上有个设置可以创建虚拟环境，选择相应的解释器就能创建，另外在这个project中的terminal会默认使用这个虚拟环境，形如：

(tensorflow) ceo1207@ceo1207:

另外装jupyter（就是常说的python notebook）体验也很好，可以像python console中一样交互式的编程，还能保存代码

apt-get install python-dev
python -m pip install jupyter

使用时，输入 jupyter notebook 即可在浏览器中使用python

`tensorflow原理简述

（看不懂不要紧，看完下面的再来看一遍就会了）网络结构使用Graph表示，Graph由operation（节点）组成，op接受输入产生输出，输入输出使用张量（tensor）表示，所以这个框架叫tensorflow，张量数据的流动的意思。

定义graph不会产生计算，真正的计算使用Session（会话）驱动，可以使用会话传入数据，获取输入以及训练和测试网络。

#note:计算优化

为了用python实现高效的数值计算，我们通常会使用函数库，比如NumPy，会把类似矩阵乘法这样的复杂运算使用其他外部语言实现。不幸的是，从外部计算切换回Python的每一个操作，仍然是一个很大的开销。如果你用GPU来进行外部计算，这样的开销会更大。用分布式的计算方式，也会花费更多的资源用来传输数据。

TensorFlow也把复杂的计算放在python之外完成，但是为了避免前面说的那些开销，它做了进一步完善。Tensorflow不单独地运行单一的复杂计算，而是让我们可以先用图描述一系列可交互的计算操作，然后全部一起在Python之外运行。

`定义网络结构、启动网络计算

graph定义网络结构，添加节点（计算单元）。但是graph只是定义结构和数据，真正的计算需要会话启动。

节点构造器，接收输入tensor，返回op的输出。最简单的是常量节点，可以作为整个网络的输入。也可以是一些计算操作，比如矩阵相加、相乘。直接上代码，看看就明白了。

import numpy as np
import tensorflow as tf
# define input, create operation, result(tensor) return
input1 = tf.constant(3)
input2 = tf.constant(2)
input3 = tf.constant(5)
# define operations
add = tf.add(input3,input2)
mul = tf.mul(input1,add)

with tf.Session() as sess:
    # use the default graph
    result = sess.run([mul,add])
    print result

输入也可以使用占位符，用于在会话时，灵活的添加自定义的输入。

import numpy as np
import tensorflow as tf

input1 = tf.placeholder(tf.types.float32)
input2 = tf.placeholder(tf.types.float32)
mul = tf.mul(input1, input2)
data1 = [1,2,3]
data2 = [2,4,6]
with tf.Session() as sess:
    print sess.run([mul], feed_dict={input1:data1,input2:data2})

关于数据的fetch和feed，上面两段代码都用到了其实。

Fetch，使用run获取

with tf.Session():
  result = sess.run([mul, intermed])
  print result

需要获取的多个 tensor 值，在 op 的一次运行中一起获得（而不是逐个去获取 tensor）

feed，在会话中插入数据，使用placeholder

import numpy as np
import tensorflow as tf

input1 = tf.placeholder(tf.types.float32)
input2 = tf.placeholder(tf.types.float32)
mul = tf.mul(input1, input2)
data1 = [1,2,3]
data2 = [2,4,6]
with tf.Session() as sess:
    print sess.run([mul], feed_dict={input1:data1,input2:data2})

`使用Variable定义模型参数、如何训练模型

到这一步，请你确保具备以下能力，给你具体的公式和输入，可以使用tensorflow，控制数据的输入，利用会话驱动运算获得最后的输出，甚至是任意中间步骤的结果。

但是常用的神经网络、机器学习的模型都是有模型参数的，模型参数是需要训练的。参数如何输入？当然我们可以把它们当做是另外的输入（使用占位符），但TensorFlow有一个更好的方法来表示它们：Variable。

Variable你可以理解为一个可变的tensor，事后，框架会根据你设置的训练方法自动更新他的值。

#note:

模型的多种输入：常量、占位符、Variable

有了可变的tensor（Variable），如何训练他们？

看懂下面的部分，先了解一下什么是softmax regression

如下，regression解决的是分类问题，对于多分类问题，使用softmax层得到归一化的多分类的概率分布。

概率分布：（这个词，其实不容易解释）多分类问题下，一个随机事件，在各个分类上的概率分布，就是所谓的概率分布。概率分布的特点，各个分类的概率之和为1.

好吧，不了解你就硬着头皮往下看吧，没什么关系。

首先定义优化的目标，即确定loss function。

多分类问题采用交叉熵作为loss，形如：

cross_entropy = -tf.reduce_sum(y_*tf.log(y))

再确定优化的方法，可以使用常用的梯度下降方法

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

设置步长为0.01，优化目标是cross_entropy

好了，可以看mnist的实战代码了，可以在tensorflow github上看，这里贴一下

"""A very simple MNIST classifier.
See extensive documentation at
https://www.tensorflow.org/get_started/mnist/beginners
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import sys

from tensorflow.examples.tutorials.mnist import input_data

import tensorflow as tf

FLAGS = None


def main(_):
  # Import data
  mnist = input_data.read_data_sets(FLAGS.data_dir)

  # Create the model
  x = tf.placeholder(tf.float32, [None, 784])
  W = tf.Variable(tf.zeros([784, 10]))
  b = tf.Variable(tf.zeros([10]))
  y = tf.matmul(x, W) + b

  # Define loss and optimizer
  y_ = tf.placeholder(tf.int64, [None])

  # The raw formulation of cross-entropy,
  #
  #   tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.nn.softmax(y)),
  #                                 reduction_indices=[1]))
  #
  # can be numerically unstable.
  #
  # So here we use tf.losses.sparse_softmax_cross_entropy on the raw
  # outputs of 'y', and then average across the batch.
  cross_entropy = tf.losses.sparse_softmax_cross_entropy(labels=y_, logits=y)
  train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

  sess = tf.InteractiveSession()
  tf.global_variables_initializer().run()
  # Train
  for _ in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

  # Test trained model
  correct_prediction = tf.equal(tf.argmax(y, 1), y_)
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  print(sess.run(
      accuracy, feed_dict={
          x: mnist.test.images,
          y_: mnist.test.labels
      }))


if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--data_dir',
      type=str,
      default='/tmp/tensorflow/mnist/input_data',
      help='Directory for storing input data')
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

`如何测试

最后说一下如何测试，其实上面的代码以及中文文档里已经说的蛮好了。

好吧，下一篇，深入mnist（读作m-nist），明儿见