Tensorflow

1.什么是Tensorflow?

Tensor(张量)意味着 N 维数组，Flow(流)意味着基于数据流图的计算，TensorFlow即为张量从图的一端流动到另一端。

它支持CNN（卷积神经网络）、RNN（循环神经网络）和LSTM（长短期记忆网络）算法，是目前在 Image，NLP 最流行的深度神经网络模型。

推荐一个网址，神经网络游乐场，很明白的了解具体的训练流程，得到最佳的结果

http://playground.tensorflow.org/

2.Tensorflow的优点

• 第一，基于Python，写的很快并且具有可读性。
• 第二，在CPU或GPU系统上的都可运行。pip install tensorflow
• 第三，代码编译效率较高。
• 第四，社区发展的非常迅速并且活跃。
• 第五，能够生成显示网络拓扑结构和性能的可视化图。

3.Tensorflow的原理

TensorFlow是用数据流图(data flow graphs)技术来进行数值计算的。

数据流图是描述有向图中的数值计算过程。

有向图中，节点通常代表数学运算，边表示节点之间的某种联系，它负责传输多维数据(Tensors)。

4.Tensorflow的使用

import warnings
warnings.filterwarnings('ignore')
import numpy as np
import tensorflow as tf

#常量的计算
nd1=np.random.randint(0,10,size=5)
s=tf.reduce_sum(nd1,name='sum')
sess=tf.Session()
sess.run(s)

# 求平均值
m=tf.reduce_mean(nd1.astype(np.float16))
# 使用with会自动关闭
with tf.Session() as sess:
    print(sess.run(m))

# 返回值是操作
c=tf.constant('Hello Tensorflow')
c2=tf.constant(1024)
c3=tf.constant(512)
a=tf.add(c2,c3)
b=c3-c2
d=tf.abs(b)
m=tf.multiply(10,8)
# 除法直接返回结果
n=tf.divide(1024,100)
h=tf.divide(b,d)
# sess.run(c) c必须是tensor操作
with tf.Session() as sess:
    print(sess.run(c))
    print(sess.run(c2))
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(d))
    print(sess.run(m))
    print(n)
    print(sess.run(h))

# 矩阵操作
a=np.random.randint(0,10,size=(2,3))
b=np.random.randint(0,10,size=(3,4))
# 矩阵的点乘
c=tf.matmul(a,b)
with tf.Session() as sess:
    print(sess.run(c))

# 变量的计算
# 求解方程时，系数和截距都是变量
# 声明变量
v=tf.Variable(initial_value=0,dtype=np.float16)
v2=tf.Variable(initial_value=3.14,dtype=tf.float16)
with tf.Session() as sess:
    # 变量必须进行初始化
    sess.run(tf.global_variables_initializer())
    result=sess.run([v,v2])
    print(result)
    # 将变量更新一下，重新赋值，必须运行之后才会修改
    assign=tf.assign(v,2.718)
    sess.run(assign)
    #相当于求v2-2
    sess.run(tf.assign_sub(v2,2))
    print(sess.run([v,v2]))

# 占位符
# 占位符的作用
‘’‘一方面用TensorFlow写网络的时候，训练前我们往往不知道x和y的具体大小，但在写前项传播时又不得不先在计算图中定义这么一个节点，因为其他变量会依赖它。此时，我们就可以先在网络中给这些变量留（占）一个位置，等到训练的时候根据batch的尺寸就能确定x,y的大小了。
另一方面我们迄今为止所做的计算一直很乏味：没有机会获得输入，所以它们总是输出相同的东西。一个实用的应用可能涉及构建这样一个计算图：它接受输入，以某种（一致）方式处理它，并返回一个输出。最直接的方法是使用占位符。占位符是一种用于接受外部输入的节点。
‘’‘

A=tf.placeholder(dtype=tf.float32,shape=(None,4),name='A')
B=tf.placeholder(dtype=np.float32,shape=(4,None),name='B')
C=tf.matmul(A,B)
with tf.Session() as sess:
    # 占位时使用的None，赋值时可以随意构建形状，只要匹配就可以
    b=sess.run(tf.random_normal(shape=[4,5]))
    ret=sess.run(C,feed_dict={A:np.random.randint(0,5,size=(3,4)),B:b})
    print(ret)

5.Tensorlow完成线性回归

import warnings
warnings.filterwarnings('ignore')
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.linear_model import LinearRegression
import tensorflow as tf

# 构造数据
X=np.linspace(2,12,50).reshape(-1,1)
w=np.random.randint(1,6,size=1)[0]
b=np.random.randint(-5,5,size=1)[0]
y=X*w+b+np.random.randn(50,1)*0.7
plt.scatter(X,y)

# 用线性回归模型来计算
linear=LinearRegression()
linear.fit(X,y)
print(linear.coef_,linear.intercept_)

#用tensorflow来计算
# 1.定义占位符，变量
# 线性回归理论基础是最小二乘法
X_train=tf.placeholder(dtype=tf.float32,shape=[50,1],name='data')
y_train=tf.placeholder(dtype=tf.float32,shape=[50,1],name='target')
w_=tf.Variable(initial_value=tf.random_normal(shape=[1,1]),name='weight')
b_=tf.Variable(initial_value=tf.random_normal(shape=[1]),name='bias')

# 2.构造方程（线性方程，矩阵乘法）
# 构建方程 f(x)=Xw+b
y_pred=tf.multiply(X_train,w_)+b_
# shape=(50,1)

# 3.最小二乘法（平均最小二乘法）
# 二乘法(y_pred-y_train)**2 返回的结果是一个列表，列表没有办法比较大小
# 平均最小二乘法，数值，mean
cost=tf.reduce_mean(tf.pow(y_pred-y_train,2))

# 4.梯度下降优化
# 优化，cost越小越好
# 梯度下降优化
opt=tf.train.GradientDescentOptimizer(0.01).minimize(cost)

# 5.会话进行训练（for循环）
with tf.Session() as sess:
    # w,b,变量初始化
    sess.run(tf.global_variables_initializer())
    for i in range(1000):
        opt_,cost_=sess.run([opt,cost],feed_dict={y_train:y,X_train:X})
        print('执行次数是：%d,损失函数值是：%0.4f'%(i+1,cost_))
        # for 循环结束，训练结束
        # 获取斜率和截距
    W,B=sess.run([w_,b_])
    print('经过1000次的训练，tensorflow返回的线性方程的斜率是：%0.3f,截距是：%0.3f'%(W,B))

# 6.可视化
plt.scatter(X,y)
x=np.linspace(2,12,100)
plt.plot(x,W[0]*x+B,color='green')