TensorFlow基础

目录

一、TensorFlow安装

二、TensorFlow入门

1、TensorFlow基本概念

2、TensorFlow基本操作

三、TensorFlow实现线性回归算法

1、TensorFlow实现单变量线性回归

2、TensorFlow实现线性回归并绘图

四、TensorFlow实现神经网络

1、TensorFlow实现神经网络向前传播算法

2、TensorFlow训练神经网络模型

五、TensoFlow部分函数


一、TensorFlow安装

1、Windows安装TensorFlow

CPU版本:管理员方式打开命令提示符,输入命令:pip install tensorflow

GPU版本:管理员方式打开命令提示符,输入命令:pip install tensorflow-gpu

2、Linux和MacOS安装TensorFlow

CPU版本:Python 2.7用户:pip install tensorflow ; Python3.3+用户:pip3 install tensorflow

GPU版本:Python 2.7用户:pip install tensorflow-gpu ;Python3.3+用户:pip3 install tensorflow-gpu

二、Tensorflow入门

1、TensorFlow基本概念

TensorFlow使用Graph来描述计算任务,图中的节点被称之为op。一个op可以接受0或多个tensor作为输入,也可产生0或多个tensor作为输出。任何一个Graph要想运行,都必须借助上下文Session。通过Session启动Graph,并将Graph中的op分发到CPU或GPU上,借助Session提供执行这些op。op被执行后,将产生的tensor返回。借助Session提供的feed和fetch操作,我们可以为op赋值或者获取数据。计算过程中,通过变量(Variable)来维护计算状态。

类型

描述

用途

Session

会话

图必须在称之为“会话”的上下文中执行。会话将图的op分发到诸如CPU或者GPU上计算

Graph

描述计算过程

必须在Session中启动

tensor

数据(张量)

数据类型之一,代表多维数组

op

操作

图中的节点被称之为op,一个op获得0或者多个Tensor,执行计算,产生0或者多个Tensor

Variable

变量

数据类型之一,运行过程中可以被改变,用于维护状态

feed

赋值

为op的tensor赋值

fetch

取值

从op的tensor中取值

Constant

常量

数据类型之一,不可变

2、TensorFlow基本操作

(1)TensorFlow支持通过tf.Graph函数来生成新的计算图

g1=tf.Graph()
with g1.as_default(): #在计算图g1中定义变量’v',并设置初始值为0
v=tf.get_variable('v',initializer=tf.zeros_initializer([1]))

 (2)创建图和启动图

创建一个图并在Session中执行(TensorFlow实现一个简单的矩阵乘法)

import tensorflow as tf #引入TensorFlow包
v1=tf.constant([[2,3]]) #创建一个常量v1,它是一个1行2列的矩阵
v2=tf.constant([[2],[3]]) #创建一个常量v2,它是一个2行1列的矩阵
#创建一个矩阵乘法,创建乘法后,是不会立即执行的,要在会话中执行
product=tf.matmul(v1,v2)
sess=tf.Session() #定义一个会话
result=sess.run(product) #运算乘法,得到结果
print(result) #打印结果 #结果为 [[13]]
sess.close() #关闭会话

(3)创建一个变量,并用for循环对变量进行赋值操作

TensorFlow使用Variables来维护图执行过程中的状态信息

import tensorflow as tf #引入TensorFlow包

num=tf.Variable(0,name='count') #创建一个变量num,初始化为0
new_value=tf.add(num,10) #创建一个加法操作,把当前数字加10
op=tf.assign(num,new_value) #创建一个赋值操作,把new_value赋值给num
#使用Python的上下文管理器机制,在运行完毕后,会话会自动关闭
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer()) #初始化变量
    print(sess.run(num)) #打印最初的num值
    for i in range(5): #创建一个for循环,每次给num+10,并打印出来
        sess.run(op)
        print(sess.run(num))
#结果如下:
'''
0
10
20
30
40
50
'''

(4)通过feed设置placeholder的值

import tensorflow as tf
input1=tf.placeholder(tf.float32) #创建一个变量占位符input1
input2=tf.placeholder(tf.float32) #创建一个变量占位符input2
#创建一个乘法操作,把input1和input2相乘
new_value=tf.multiply(input1,input2)
#创建会话,使用此方法,在运行完毕后,会话自动关闭
with tf.Session() as sess:
    #打印new_value的值,在运算时,用feed设置两个输入的值
    print(sess.run(new_value,feed_dict={input1:[23.0],input2:[11.0]})) #结果为253.0

(5)通过Fetch在会话中同时设置多个op

import tensorflow as tf
input1=tf.constant(3.0) #设置三个常量
input2=tf.constant(2.0)
input3=tf.constant(5.0)
add=tf.add(input2,input3) #加法操作
mul=tf.multiply(input1,add) #乘法操作
with tf.Session() as sess:
    result=sess.run([mul,add]) #在sess的运算中可以取回多个tensor
    print(result)   #结果为[21.0, 7.0]

三、TensorFlow实现线性回归算法

1、TensorFlow实现单变量线性回归

import tensorflow as tf
import numpy as np

#随机生成训练集
x_data=np.random.rand(100) #使用numpy生成100随机点
y_data=x_data*0.1+0.2
#构造一个线性模型
b=tf.Variable(0.) #设置参数变量并初始化为0
k=tf.Variable(0.)
y=k*x_data+b
#二次代价函数(损失函数)
loss=tf.reduce_mean(tf.square(y_data-y))
#定义一个梯度下降法来进行训练的优化器
optimizer=tf.train.GradientDescentOptimizer(0.2) #0.2表示学习率
#最小化代价函数
train=optimizer.minimize(loss)
init=tf.global_variables_initializer() #初始化变量
with tf.Session() as sess:
    sess.run(init) #在会话里运行初始化变量
    for step in range(201): #迭代训练200次
        sess.run(train)
        if step%20==0: #每迭代20次输出k和b的值
            print(step,sess.run([k,b]))

结果为:

2、TensorFlow实现线性回归并绘图

#TensorFlow实现线性回归算法
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

#使用numpy生成200个随机点
x_data=np.linspace(-0.5,0.5,200)[:,np.newaxis]
noise=np.random.normal(0,0.02,x_data.shape)
y_data=np.square(x_data)+noise
#定义两个placeholder存放输入数据
x=tf.placeholder(tf.float32,[None,1])
y=tf.placeholder(tf.float32,[None,1])
#定义神经网络中间层
Weights_L1=tf.Variable(tf.random_normal([1,10]))
biases_L1=tf.Variable(tf.zeros([1,10]))    #加入偏置项
Wx_plus_b_L1=tf.matmul(x,Weights_L1)+biases_L1
L1=tf.nn.tanh(Wx_plus_b_L1)   #加入激活函数
#定义神经网络输出层
Weights_L2=tf.Variable(tf.random_normal([10,1]))
biases_L2=tf.Variable(tf.zeros([1,1]))  #加入偏置项
Wx_plus_b_L2=tf.matmul(L1,Weights_L2)+biases_L2
prediction=tf.nn.tanh(Wx_plus_b_L2)   #加入激活函数
#定义损失函数(均方差函数)
loss=tf.reduce_mean(tf.square(y-prediction))
#定义反向传播算法(使用梯度下降算法训练)
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)
with tf.Session() as sess:
    #变量初始化
    sess.run(tf.global_variables_initializer())
    #训练2000次
    for i in range(2000):
        sess.run(train_step,feed_dict={x:x_data,y:y_data})
    #获得预测值
    prediction_value=sess.run(prediction,feed_dict={x:x_data})
    #画图
    plt.figure()
    plt.scatter(x_data,y_data)   #散点是真实值
    plt.plot(x_data,prediction_value,'r-',lw=5)   #曲线是预测值
    plt.show()

结果为:

四、TensorFlow实现神经网络

1、TensorFlow实现神经网络向前传播算法

import tensorflow as tf

#声明w1、w2两个变量
#通过seed参数设定了随机种子,可以保证每次运行得到的结果一样
#生成一个2*3的矩阵,矩阵中的元素是均值为0,标准差为1的随机数
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
'''
#将输入的特征向量定义为一个常量
x=tf.constant([[0.7,0.9]]) #x是一个1*2的矩阵
'''
#定义placeholder存放输入数据
x=tf.placeholder(tf.float32,shape=(3,2),name='x_input') #3行2列的样例数据
#通过前向传播算法获得神经网络的输出
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)
with tf.Session() as sess:
    init_op=tf.global_variables_initializer() #初始化所有的变量
    sess.run(init_op)
    print(sess.run(y,feed_dict={x:[[0.7,0.9],[0.1,0.4],[0.5,0.8]]}))
结果为:
'''
[[3.957578 ]
[1.1537654]
[3.1674924]]
'''

2、TensorFlow训练神经网络模型

(1)TensorFlow训练神经网络模型的步骤

  • 定义神经网络的结构和向前传播的输出结果
  • 定义损失函数以及选择反向传播优化的算法
  • 生成会话(tf.Session),并且在训练数据上反复运行反向传播优化算法

(2)TensorFlow训练神经网络解决二分类问题

import tensorflow as tf
import numpy as np    #通过NumPy工具包生成模拟数据
 
batch_size=8     #定义训练数据batch的大小
#定义神经网络的参数
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1)) 
#定义placeholder存放输入数据
#在shape的一个维度上使用None可以方便使用不大的batch大小
x_data=tf.placeholder(tf.float32,shape=(None,2),name='x-input')
y_data=tf.placeholder(tf.float32,shape=(None,1),name='y-input')
#定义神经网络向前传播过程
a=tf.matmul(x_data,w1)
y=tf.matmul(a,w2)
#定义损失函数和反向传播算法
cross_entropy=-tf.reduce_mean(y_data*tf.log(tf.clip_by_value(y,1e-10,1.0)))
train_step=tf.train.AdadeltaOptimizer(0.001).minimize(cross_entropy)
#通过随机数生成一个模拟数据集
rdm=np.random.RandomState(1)
dataset_size=128
X=rdm.rand(dataset_size,2)
#定义规则来给出样本的标签。
Y=[[int(x1+x2<1)] for (x1,x2) in X]
#创建一个会话来运行TensorFlow程序
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer()) #初始化变量
    print("训练之前的神经网络参数值:")
    print(sess.run(w1))  #输出训练之前神经网络参数的值
    print(sess.run(w2))
    #设置训练5000次
    for i in range(5000):
        start=(i*batch_size)%dataset_size #每次选取batch_size个样本进行训练
        end=min(start+batch_size,dataset_size)
        #通过选取的样本训练神经网络并更新参数
        sess.run(train_step,feed_dict={x_data:X[start:end],y_data:Y[start:end]})
        #每隔一段时间计算在所有数据上的交叉熵并输出
        if i%1000==0:
            total_cross_entropy=sess.run(cross_entropy,feed_dict={x_data:X,y_data:Y})
            print("After %d training steps,cross entropy on all data is %g" %(i,total_cross_entropy))
    #输出训练5000次之后的神经网络参数值
    print("训练之后的神经网络参数值:")
    print(sess.run(w1))
    print(sess.run(w2))

结果为:

(3)详解交叉熵损失函数

cross_entropy=-tf.reduce_mean(y_data*tf.log(tf.clip_by_value(y,1e-10,1.0)))

 tf.clip_by_value()函数

#tf.clip_by_value()函数可以将一个张量中的数值限制在一个范围之内,这样可以避免一些运算错误
v1=tf.constant([[1.0,2.0,3.0],[4.0,5.0,6.0]])
with tf.Session() as sess:
    print(sess.run(tf.clip_by_value(v1,2.5,4.5)))
#如上,小于2.5的数都被换成了2.5,大于4.5的数都被换成了4.5
#tf.clip_by_value()函数可以保证在进行log运算时不会出现log0这样的错误或者大于1的概率

#输出结果为:
[[2.5 2.5 3. ]
[4. 4.5 4.5]]

tf.log()函数

#tf.log()函数完成张量中所有元素依次求对数的功能
v2=tf.constant([1.0,2.0,3.0])
with tf.Session() as sess:
    print(sess.run(tf.log(v2)))
#输出结果为:[0. 0.6931472 1.0986123]

"*"操作:在实现交叉熵的代码中,直接将两个矩阵通过"*"操作相乘,这个操作不是矩阵的乘法,而是元素之间的直接相乘;矩阵乘法需要使用tf.matmul()函数来完成。

cross_entropy=tf.nn.softmax_cross_entropy_with_logits(y,y_data)

#交叉熵一般会与softmax回归一起使用,TensorFlow对这两个功能进行了统一封装
#通过以下代码实现使用softmax回归之后的交叉熵损失函数
cross_entropy=tf.nn.softmax_cross_entropy_with_logits(y,y_data)
#其中y代表了原始神经网络的输出结果,y_data是标准答案

tf.nn.sparse_softmax_cross_entropy_with_logits(y,y_data)

#在只有一个正确答案的分类问题中,TensorFlow提供了如下函数来进一步加速计算过程
tf.nn.sparse_softmax_cross_entropy_with_logits(y,y_data)

五、TensoFlow部分函数

 

 

 

 

 

资料:1、Tensorflow游乐场    2、TensorFlow 中文社区

 

 

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页