机器学习-Tensorflow

一下子看完这个网址不用跳跳跳点点点系列
学习链接：莫烦tensorflow

---

为什么选Tensorflow

什么是TensorFlow?
TensorFlow是Google开发的一款神经网络的Python外部的结构包, 也是一个采用数据流图来进行数值计算的开源软件库.TensorFlow 让我们可以先绘制计算结构图, 也可以称是一系列可人机交互的计算操作, 然后把编辑好的Python文件 转换成 更高效的C++, 并在后端进行计算.
为什么要使用TensorFlow?
TensorFlow 无可厚非地能被认定为 神经网络中最好用的库之一. 它擅长的任务就是训练深度神经网络.通过使用TensorFlow我们就可以快速的入门神经网络, 大大降低了深度学习（也就是深度神经网络）的开发成本和开发难度. TensorFlow 的开源性, 让所有人都能使用并且维护, 巩固它. 使它能迅速更新, 提升.
BUG？
貌似Tensorflow有bug，虽然谷歌开发人员在尽力修改。。bug主要集中在他的选参数上面~

Tensorflow 安装

安装之前，推荐两个在线使用tensorflow的软件：
https://colab.research.google.com/
我的配置为win10, python3.6.4, ana

image.png
估摸着TensorFlow 的安装包目前windows版本还不支持 Python 3.6 ，于是到https://pypi.python.org/pypi/tensorflow/1.1.0rc2下载了whl文件，结果：
image.png
换成pip3还是不行：
image.png
看了网上的很多解决方案，好像还是安装Anaconda稍微显得简单一点。
安装好Anaconda后，我想检验一下，结果：
image.png
用'path'一看，环境变量没配：
image.png
由于安装的时候这一栏这么提示：
image.png
所以选择手动添加path。
添加3个变量：
F:\Anaconda3
F:\Anaconda3\Scripts
F:\Anaconda3\Library\bin
重启命令行：
image.png
成功！
由于我安装的最新版本的Anaconda,适用于python3.7,所以我还要设成3.6
输入命令：'conda install python=3.6'
安装结束后，输入：'anaconda search -t conda tensorflow'，搜索当前可用版本
选择一个版本输入：'anaconda show （对应名称）' ，查询安装命令
输入跳出的安装命令安装

---

Tensorflow基础架构

TensorFlow是采用数据流图（data　flow　graphs）来计算。
首先创建数据流流图，然后将数据（以张量——tensor的形式存在）放在数据流中计算。
节点（nodes）表示数学操作，线（edges）表示节点间相互联系的多维数组，即张量（tensor）。训练模型时，tensor会不断从数据流图中的一个结点流(flow)到另一个节点。即是tensor~~flow
张量
0阶：一个数值，比如'[1]'
1阶：向量，比如'[1,2,3]'
2阶：矩阵，比如'[[1,2], [1,2]]'
以此类推...感觉就是n阶矩阵...

如何搭建结构

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

# 搭建模型
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))

# 传播误差
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

#训练
init = tf.global_variables_initializer()  #初始化之前定义的所有Variable

sess = tf.Session()
sess.run(init)

for step in range(201):
    sess.run(train)
    if step % 20 == 0:
        print(step.sess.run(weights), sess.run(biases))

Session
目的：控制、输出文件执行的语句
运行'session.run()'可以获得运算结果

import tensorflow as tf

#创建两个矩阵
matrix = tf.constant([[3,3]])
matrix = tf.constant([[2],[2]])
product = tf.matmul(matrix1, matrix2) #输出矩阵相乘结果

#因为 product 不是直接计算的步骤
#所以我们会要使用 Session 来激活 product 并得到计算结果.

#方法1
sess = tf.Session()
result = sess.run(product)
print("method1:",result)
sess.close()

#方法2
with tf.Session() as sess:
    result2 = sess.run(product)
    print("method2:",result2)

Placeholder
目的：占位符，暂时存储变量。
如果想要从外部传入data, 那就需要用tf.placeholder(), 然后以这种形式传输数据 sess.run(***, feed_dict={input: **})

import tensorflow as tf

#定义两个输入
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

#做乘法运算，并输出为output
output = tf.multiply(input1, input2)

with tf.Session() as sess:
    print(sess.run(output, feed_dict={input1:[7.], input2:[2.]}))

激励函数
目的：矩阵相乘是线性相乘，激励函数可以将线性转化为非线性，事实上就是套一个非线性函数。

添加层 add_layer
目的：定义 添加层函数 可以添加一个神经层

import tensorflow as tf

#四个参数：输入值、输入的大小、输出的大小和激励函数
#设定默认的激励函数是None
def add_layer(inputs, in_size, out_size, activation_function=None):
    #weights为一个in_size行, out_size列的随机变量矩阵
    weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    #定义Wx_plus_b, 即神经网络未激活的值
    Wx_plus_b = tf.matmul(inputs, weights) + biases

    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

建造神经网络

import tensorflow as tf
import numpy as n

#添加一个神经层函数
def add_layer(inputs, 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(inputs, Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return output

#导入数据
x_data = np.linspace(-1, 1, 300, dtype=np.float32)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise

#利用占位符tf.placeholder()定义我们所需的神经网络的输入
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

#构建网络
#输入层1个、隐藏层10个、输出层1个的神经网络

#定义隐藏层
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu) #tf.nn.relu是自带的激励函数
#定义输出层
prediction = add_layer(l1, 10, 1, activation_function=None)
#计算prediction和真实值的均方差
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),reduction_indices=[1]))

train_step = tf.train.GradientDencentOptimizer(0.1).minimize(loss)

init = tf.global_variables_initializer()

sess = tf.Session()
sess.run(init)#在tensorflow中，只有session.run()才会执行我们定义的运算。

#训练
for i in range(1000):
    sess.run(train_step, feed_dict={xs:x_data,ys:y_data})
    #每隔50次训练刷新一次图形，用红色、宽度为5的线来显示我们的预测数据和输入之间的关系，并暂停0.1s
    if i%50 == 0:
        try:
            ax.lines.remove(lines[0])
        except Exception:
            pass
        prediction_value = sess.run(prediction, feed_dict={xs: x_data})
        # plot the prediction
        lines = ax.plot(x_data, prediction_value, 'r-', lw=5)
        plt.pause(0.1)

加速神经网络
*方法1：Stochastic Gradient Descent (SGD) 随机梯度下降：随机也就是只取可以近似所有的样本的一个例子，这样大大减少了时间。（有点像TransE算法中的负采样）
*方法2：Momentum 更新方法
由于SGD很随机，其更新十分不稳定。因此momentum在更新的时候在一定程度上保留之前更新的方向，同时利用当前batch的梯度微调最终的更新方向。这样一来，可以在一定程度上增加稳定性，从而学习地更快，并且还有一定摆脱局部最优的能力。
其实也就是说，假如我上次走的路是对的，那么我接着往前走，并且微调一下前进的方向，向着更准确的方向进行。
*方法三：AdaGrad 更新方法：使得每一个参数更新都会有自己与众不同的学习率。
*方法四：RMSProp 更新方法：momentum+adagrad
*方法五：Adam 更新方法：Adam 算法根据损失函数对每个参数的梯度的一阶矩估计和二阶矩估计动态调整针对于每个参数的学习速率。Adam 也是基于梯度下降的方法，但是每次迭代参数的学习步长都有一个确定的范围，不会因为很大的梯度导致很大的学习步长，参数的值比较稳定。

用Tensorboard可视化神经网络

注：与 tensorboard 兼容的浏览器是 “Google Chrome”
这部分不想学了。

高阶内容

Classification 分类学习

from tensorflow.examples.tutorials.mnist import input_data

#准备数据（MNIST库，MNIST库是手写体数字库, 需要翻墙）
#数据中包含55000张训练图片，每张图片的分辨率是28×28
#所以我们的训练网络输入应该是28×28=784个像素数据
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#添加一个神经层函数
def add_layer(inputs, 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(inputs, Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return output

#搭建网络
xs = tf.placeholder(tf.float32, [None,784])
ys = tf.placeholder(tf.float32,[None,10])

#输入数据是784个特征，输出数据是10个特征，激励采用softmax函数
prediction = add_layer(xs, 784, 10, activation_function=tf.nn.softmax)

#loss函数（即最优化目标函数）选用交叉熵函数。
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), reduction_indices=[1])) # loss

#train方法（最优化算法）采用梯度下降法
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
sess = tf.Session()
sess.run(tf.global_variables_initializer())

#训练
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys})
#每训练50次输出一下预测精度
if i % 50 == 0:
    print(compute_accuracy(mnist.test.images, mnist.test.labels))

过拟合
解释：做物理实验的时候不是要描点画线嘛，通常最后是一条直线。但是数据经过网络后变成了弯弯曲曲的曲线，虽然过每一个点，但是并不正确。这种情况就是过拟合。