Tensorflow学习笔记（一）（铺垫神经网络）附代码

1. tf安装及神经网络示例

TensorFlow安装教程
网上也有很多安装教程，请自行搜索安装！
首先说一下tf（tensorflow简写）中graph和session的关系:
TensorFlow是一种“符号式编程框架”，首先要构造一个图（graph），然后在会话（Session）上根据这个图做真实的运算（op）。打个比方，graph就像多条生产线，session就像生产者。生产线具有一系列的加工步骤（加减乘除等运算），生产者把原料投进去，就能得到产品。不同生产者都可以使用这条生产线，只要他们的加工步骤是一样的就行。同样的，一个graph可以供多个session使用，而一个session不一定需要使用graph的全部，可以只使用其中的一部分。
graph即tf.Graph()，session即tf.Session()，是两个完全独立的概念。

graph定义了计算方式，是一些加减乘除等运算的组合。它本身不会进行任何计算，也不保存任何中间计算结果。
session用来运行一个graph，或者运行graph的一部分。它类似于一个执行者，给graph灌入输入数据，得到输出，并保存中间的计算结果。同时它也给graph分配计算资源（如内存、显卡等）。

下图是用tensorflow制作大盘鸡和红烧肉的过程，以此为例来说明graph和session的区别：
左图中绿色矩形为数据，黄色圆圈为中间结果，红色圆圈为最终结果，这是一个完整的制作大盘鸡和红烧肉的graph（相当于是一个菜谱），图中每一个独立单元都可以看成是一个op（操作，包括数据）。在tensorflow中只有graph是没法得到结果的，这就像只有菜谱不可能得到红烧肉是一个道理。于是就有了tf.Session(），他根据graph制定的步骤，将graph变成现实。
tf.Session(）就相当于一个厨师长，他下面有很多办事的人（Session()下的各种方法），其中有一个非常厉害厨师叫tf.Session.run()，他不仅会烧菜，还会杀猪、酿酒、制作酱料等一系列工作，比如：
我的酱料 = sess.run(酱料)：run收到制作“酱料”的命令，于是他看了下graph，需要“酵母”和“大豆”来制作酱料，最终他把酱料制作好了（这里酵母和大豆是graph定义好的，但也可以根据自己的喜好来换）。
我的料酒 = sess.run(料酒，feed_dic={米:泰国籼米})：run又收到要制作“料酒”的命令，而且不用graph规定的“米”来做，需要用“泰国籼米”，没关系，run跑去买了泰国籼米，又把料酒给做了。
我的红烧肉 = sess.run(红烧肉)：傍晚，run又收到了做一份完整红烧肉的命令，这下他有的忙了，必须将整个流程走一遍，才能完成个任务。
我的大盘鸡 = sess.run(大盘鸡): 后来，run又收到做大盘鸡的任务，这是一个独立的任务，跟红烧肉没有半点关系，但不影响，他只要按照步骤照做就可以了。
转载于：点击前往

下面是tensorflow的处理结构，大致流程是：
首先输入数据input，经过运算得到结果，将这个结果与实际数据进行比对，中间的差距就是loss值，通过一些优化方法不断优化这个模型的参数，即W,b，逐渐使得loss值最小，不断反复训练模型。

下面的代码是通过参数训练得到函数y=0.1x+0.3：

import tensorflow as tf
import numpy as np

x_data = np.random.rand(100).astype(np.float32)
y_data = x_data *0.1 + 0.3

#create tensorflow structure start
Weights = tf.Variable(tf.random_uniform([1],-1.0,1.0))
biases = tf.Variable(tf.zeros([1]))
#待训练函数
y = Weights*x_data + biases
#计算丢失值
loss = tf.reduce_mean(tf.square(y - y_data))
#优化函数 ，减少loss值
optimizer = tf.train.GradientDescentOptimizer(0.5)
#图的结构
train = optimizer.minimize(loss)
#初始化tf中的变量，即图结构
init = tf.global_variables_initializer()
#create tensorflow structure  end

sess = tf.Session()
#激活图的结构，通过session
sess.run(init)   #very important

for step in range(500):
    sess.run(train)
    #训练50次后看一下训练结果
    if step % 50 == 0:
        print(step,sess.run(Weights),sess.run(biases))

代码大致流程：
1.y_data的值是已知的正确值，Weights和biases是待确定的两个变量，最开始他们是随机的，通过他们带入x_data后会得到一个预估值y，loss是y和y_data的差距，也称丢失值，optimizer是优化器。
2.在每次循环中，首先通过计算得到一个y，然后计算y-y_data，即丢失值loss，接着根据优化函数optimizer不断使loss减少，根据优化函数调整Weights和biases两个参数。多次循环之后，Weights和biases便趋于正确值。下面是运行结果：

可以看到，Weights趋于0.1，,biases趋于0.3.

2. Variable变量

tf.Variable(1，name = ‘X’)：创建x的变量，值为0
tf.assign(A, new_number): 这个函数的功能主要是把A的值变为new_number
在有Variable创建变量时，必须先用sessio.run(tf.global_variables_initializer())初始化，之后变量才能在run（）中被激活。
代码：

import tensorflow as tf

state = tf.Variable(1)
state_ = tf.assign(state, 10)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(state))
    print(sess.run(state_))
    print(sess.run(state))
    # 结果：
    #     1
    #     10
    #     10

3. placeholder占位符

顾名思义，就是告诉内存，这个地方我将会存放一个什么样的数，先提前把位置留好。
tf.placeholder(dtype=tf.float32, shape=None)：类型为float32，形状为none的变量

import tensorflow as tf
#先定义占位符，以及计算过程
x1 = tf.placeholder(dtype=tf.float32, shape=None)
y1 = tf.placeholder(dtype=tf.float32, shape=None)
z1 = x1 + y1

x2 = tf.placeholder(dtype=tf.float32, shape=[2, 1])
y2 = tf.placeholder(dtype=tf.float32, shape=[1, 2])
z2 = tf.matmul(x2, y2)

with tf.Session() as sess:
    # 以字典形式往占位符中传输数据
    z1_value = sess.run(z1, feed_dict={x1: 1, y1: 2})
    print(z1_value)
    # when run multiple operations
    z1_value, z2_value = sess.run(
        [z1, z2],       # run them together
        feed_dict={
            x1: 1, y1: 2,
            x2: [[2], [2]], y2: [[3, 3]]
        })
    print(z1_value)
    print(z2_value)
    # 结果：
    #     3.0
    #     3.0
    #     [[6. 6.]
    #      [6. 6.]]

注：往占位符中传输数据时，是以字典的形式！

4. 激励函数

将千变万化的数据压缩在某个区间，或将数据放入自己想要的函数规定中，常见的激励函数有以下：
激励函数必须是可以微分的，只有这样，在神经网络误差反向传递时才能很好地将误差传递回去！

下面是利用tf框架编写的代码，寻找离散点的拟合函数

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np

tf.set_random_seed(1)
np.random.seed(1)

# fake data
x = np.linspace(-1, 1, 100)[:, np.newaxis]          # shape (100, 1)
noise = np.random.normal(0, 0.1, size=x.shape)
y = np.power(x, 2) + noise                          # shape (100, 1) + some noise

# plot data
plt.scatter(x, y)
plt.show()

tf_x = tf.placeholder(tf.float32, x.shape)     # input x
tf_y = tf.placeholder(tf.float32, y.shape)     # input y

# neural network layers
l1 = tf.layers.dense(tf_x, 10, tf.nn.relu)          # hidden layer
output = tf.layers.dense(l1, 1)                     # output layer

loss = tf.losses.mean_squared_error(tf_y, output)   # compute cost
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.5)
train_op = optimizer.minimize(loss)

sess = tf.Session()                                 # control training and others
sess.run(tf.global_variables_initializer())         # initialize var in graph

plt.ion()   # something about plotting

for step in range(1000):
    # train and net output
    _, l, pred = sess.run([train_op, loss, output], {tf_x: x, tf_y: y})
    if step % 5 == 0:
        # plot and show learning process
        plt.cla()
        plt.scatter(x, y)
        plt.plot(x, pred, 'r-', lw=5)
        plt.text(0.5, 0, 'Loss=%.4f' % l, fontdict={'size': 20, 'color': 'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()

其中，隐藏层的底层代码大致如下，但官方的优化更多，运算更快：

def add_layer(input , in_size , out_size , activation_function = None):
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size] + [0.1]))
    Wx_plus_b = tf.matmul(input,Weights) + biases
    if activation_function is None :
        output = Wx_plus_b
    else :
        output = activation_function(Wx_plus_b)
    return  output