机器学习 Tensorflow 基础
简单使用
import tensorflow as tf
a = tf.constant(10)
b = tf.constant(20)
# 定义了一种操作 op
c = tf.add(a, b)
print(c)
with tf.Session() as sess:
ret = sess.run(c)
print(ret)
可以看到出现了很多的警告信息，这是因为 tensorflow 使用的是 pip 安装的，给出的建议是使用源码安装，这样可以提高 cpu 的使用效率，当然也可以设置日志等级来屏蔽警告信息
import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
完整代码如下
import tensorflow as tf
# 关闭警告
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
a = tf.constant(10)
b = tf.constant(20)
# 定义了一种操作 op
c = tf.add(a, b)
print(c)
with tf.Session() as sess:
ret = sess.run(c)
print(ret)
深度学习介绍
深度学习，如深度神经网络、卷积神经网络和递归神经网络已被应用计算机视觉、语音识别、自然语言处理、音频识别与生物信息学等领域并获取了极好的效果。
深度学习框架
认识 TensorFlow
Tensorflow特点
1、真正的可移植性
- 引入各种计算设备的支持包括CPU/GPU/TPU，以及能够很好地运行在移动端，如安卓设备、ios、树莓派等等
2、多语言支持
- Tensorflow 有一个合理的c++使用界面，也有一个易用的python使用界面来构建和执行你的graphs，你可以直接写python/c++程序
3、高度的灵活性与效率
- TensorFlow是一个采用数据流图（data flow graphs），用于数值计算的开源软件库能够灵活进行组装图，执行图。随着开发的进展，Tensorflow的效率不段在提高
4、支持
- TensorFlow 由谷歌提供支持，谷歌投入了大量精力开发 TensorFlow，它希望TensorFlow 成为机器学习研究人员和开发人员的通用语言
Tensorflow的安装（开启gpu支持）
如果您的系统没有 NVIDIA®GPU，请构建并安装CPU版本
Ubuntu:
- 安装CUDA和cuDNN
Mac:
- 安装CUDA和cuDNN
Tensorflow基础
tf 加法运算
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def tf_add():
# 一个常量
a = tf.constant(10)
b = tf.constant(20)
# 定义了一种操作 op
c = tf.add(a, b)
with tf.Session() as sess:
add_result = sess.run(c)
print(add_result)
数据流图
tensorflow 是计算密集型，django 等框架是 IO 密集型
Tensorflow进阶之图
图默认已经注册，一组表示 tf.Operation计算单位的对象和tf.Tensor表示操作之间流动的数据单元的对象
获取调用：
-
tf.get_default_graph()
-
op、sess或者tensor 的graph属性
哪些是 op
图的创建
tf.Graph()
使用新创建的图
g = tf.Graph()
with g.as_default():
a = tf.constant(1.0)
assert c.graph is g
图的简单使用
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def tf_graf():
a = tf.constant(10)
b = tf.constant(20)
g = tf.get_default_graph()
print('默认的图', g)
print('操作对象的图')
print(a.graph)
print(b.graph)
new_g = tf.Graph()
print("手动创建的图: ", new_g)
with new_g.as_default():
# 在这个作用域中, 定义tensor类型的对象的图就是new_g
d = tf.constant(20)
print("=====", d.graph)
if __name__ == '__main__':
tf_graf()
Tensorflow进阶之会话
tf.Session()
- 运行TensorFlow操作图的类，使用默认注册的图（可以指定运行图）
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def tf_graf():
a = tf.constant(10)
b = tf.constant(20)
c = tf.add(a, b)
g = tf.get_default_graph()
print('默认的图', g)
new_g = tf.Graph()
# 创建Session如果不指定图，则默认创建的图对象，也可以指定图对象
with tf.Session(graph=new_g) as sess:
# sess的graph是默认的图对象
print(sess.graph)
# 在这里不能运行 sess.run(c)，因为 c op 是属于默认的图
if __name__ == '__main__':
tf_graf()
会话资源
- 会话可能拥有很多资源，如 tf.Variable，tf.QueueBase和tf.ReaderBase，会话结束后需要进行资源释放
- 通用的使用上下文管理器
sess = tf.Session() sess.run(...) sess.close() 使用上下文管理器 with tf.Session() as sess: sess.run(...)
config=tf.ConfigProto(log_device_placement=True)
交互式：tf.InteractiveSession()
会话的run()方法，运行ops和计算tensor
run(fetches, feed_dict=None,graph=None)
fetches
- 嵌套列表，元组namedtuple，dict或OrderedDict(重载的运算符也能运行)
feed_dict
- 允许调用者覆盖图中指定张量的值,提供给
placeholder使用
返回值异常
RuntimeError：如果它Session处于无效状态（例如已关闭）
TypeError：如果fetches或feed_dict键是不合适的类型
ValueError：如果fetches或feed_dict键无效或引用 Tensor不存在
Tensorflow Feed操作
意义：在程序执行的时候,不确定输入的是什么，提前“占个坑”
语法：placeholder提供占位符，run时候通过feed_dict指定参数
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def sess_run():
"""
会话对象和它的run方法
:return: None
"""
a = tf.constant(10)
b = tf.constant(20, name='bname')
f = tf.constant(30)
# 定义了一种操作 op
c = tf.add(a, b)
# 定义一个占位符对象
plt = tf.placeholder(tf.float32, shape=(2, 2))
print("=======", plt)
print('++++++++++')
print(a.graph)
print('a_op', a.op)
print('b_name', b.name)
print(plt.shape)
print(plt.get_shape)
print('++++++++++')
with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
ret = sess.run([a, b])
# config=tf.ConfigProto(log_device_placement=True), 输出在那个硬件上运行的任务
print(a.eval())# 输出a的值
"""
Device mapping: no known devices.
Add: (Add): /job:localhost/replica:0/task:0/cpu:0
Const_1: (Const): /job:localhost/replica:0/task:0/cpu:0
Const: (Const): /job:localhost/replica:0/task:0/cpu:0
"""
ret = sess.run(plt, feed_dict={plt: [[11.0, 22.0], [33.0, 44.0]]})
print(ret)
return None
if __name__ == '__main__':
sess_run()
"C:\Program Files\Python36\python.exe" D:/数据分析/机器学习/day4/3-代码/test.py ======= Tensor("Placeholder:0", shape=(2, 2), dtype=float32) ++++++++++ <tensorflow.python.framework.ops.Graph object at 0x000000000255FEB8> a_op name: "Const" op: "Const" attr { key: "dtype" value { type: DT_INT32 } } attr { key: "value" value { tensor { dtype: DT_INT32 tensor_shape { } int_val: 10 } } } b_name bname:0 (2, 2) <bound method Tensor.get_shape of <tf.Tensor 'Placeholder:0' shape=(2, 2) dtype=float32>> ++++++++++ Device mapping: no known devices. Add: (Add): /job:localhost/replica:0/task:0/cpu:0 Placeholder: (Placeholder): /job:localhost/replica:0/task:0/cpu:0 Const_1: (Const): /job:localhost/replica:0/task:0/cpu:0 bname: (Const): /job:localhost/replica:0/task:0/cpu:0 Const: (Const): /job:localhost/replica:0/task:0/cpu:0 10 [[11. 22.] [33. 44.]] Process finished with exit code 0
Tensorflow进阶之张量
tf.concat 有tf创建的类型都是张量（一般是多维数组）
张量的阶和数据类型
-
Tensorflow基本的数据格式
-
一个类型化的N维度数组（tf.Tensor）
-
三部分，名字，形状，数据类型
张量的阶
张量的数据类型
张量属性
-
graph 张量所属的默认图
-
op 张量的操作名
-
name 张量的字符串描述
-
shape 张量形状
简单使用
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def tf_session():
# 一个常量
a = tf.constant(10)
b = tf.constant(20)
# 定义了一种操作 op
sum = tf.add(a, b)
with tf.Session() as sess:
print(sum.eval())
print(sum.graph)
print(sum.name)
print(sum.op)
print(sess.run((sum)))
if __name__ == '__main__':
tf_session()
"C:\Program Files\Python36\python.exe" D:/数据分析/机器学习/day4/3-代码/test.py 30 <tensorflow.python.framework.ops.Graph object at 0x00000000025CF9E8> Add:0 name: "Add" op: "Add" input: "Const" input: "Const_1" attr { key: "T" value { type: DT_INT32 } } 30 Process finished with exit code 0
张量修改
TensorFlow中，张量具有静态形状和动态形
状静态形状：创建一个张量,初始状态的形状
-
tf.Tensor.get_shape:获取静态形状
-
tf.Tensor.set_shape():更新Tensor对象的静态形状，通常用于在不能直接推断的情况下
动态形状：一种描述原始张量在执行过程中的一种形状(动态变化)
- tf.reshape:创建一个具有不同动态形状的新张量
要点
-
1、转换静态形状的时候，1-D到1-D，2-D到2-D，不能跨阶数改变形状
-
2、 对于已经固定或者设置静态形状的张量／变量，不能再次设置静态形状
-
3、tf.reshape()动态创建新张量时，元素个数不能不匹配
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def tf_shape():
"""
张量 Tensor 多维的数组
张量包含的属性: 图, op, 名字, 形状
# 表示形状的时候 如果有None 形状待定, 最后在run的时候 指定数据就能够确定张量的形状
# 在形状没有确定之前可以通过set_shape来指定形状
# 在张量的形状已经确定的情况下不能够通过set_shape修改
# 张量的静态形状已经固定 就不能够再被修改, 如果没有固定可以通过set_shape修改形状,但是需要和已知的行或者列对应\
# reshape: 1. 会生成新的对象 2. 动态创建新张量时，元素个数必须得匹配元素的个数 2行3列的数组在修改形状的时候 必须修改为3行两列
:return:
"""
a = tf.constant(10)
print(a.graph)
print(a.op)
print(a.name)
print(a.shape)
b = tf.constant(20, name='bname')
f = tf.constant(30)
# 定义了一种操作 op
c = tf.add(a, b)
# 定义一个占位符对象
plt = tf.placeholder(tf.float32, shape=(2, 3))
# plt = tf.placeholder(tf.float32, shape=(None, 3))
# plt.set_shape([3, 3])
print('++++++++++')
print(plt.get_shape)
print('++++++++++')
# reshape 重新修改形状
# reshape 修改形状的时候会生成新的对象
print(plt.get_shape)
re_plt = tf.reshape(plt, shape=[3, 2])
print(re_plt.get_shape)
with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
ret = sess.run(plt, feed_dict={plt: [[11.0, 22.0, 33.0], [33.0, 44.0,55.0]]})
ret1 = sess.run(re_plt, feed_dict = {re_plt : [[11.0, 22.0], [33.0, 44.0], [66.0,88.0]]})
print(ret)
print(ret1)
if __name__ == '__main__':
tf_shape()
输出结果如下
"C:\Program Files\Python36\python.exe" D:/数据分析/机器学习/day4/3-代码/test.py <tensorflow.python.framework.ops.Graph object at 0x000000000258FEF0> name: "Const" op: "Const" attr { key: "dtype" value { type: DT_INT32 } } attr { key: "value" value { tensor { dtype: DT_INT32 tensor_shape { } int_val: 10 } } } Const:0 () ++++++++++ <bound method Tensor.get_shape of <tf.Tensor 'Placeholder:0' shape=(2, 3) dtype=float32>> ++++++++++ <bound method Tensor.get_shape of <tf.Tensor 'Placeholder:0' shape=(2, 3) dtype=float32>> <bound method Tensor.get_shape of <tf.Tensor 'Reshape:0' shape=(3, 2) dtype=float32>> Device mapping: no known devices. [[11. 22. 33.] [33. 44. 55.]] [[11. 22.] [33. 44.] [66. 88.]] Process finished with exit code 0
张量操作-生成张量
创建一个所有元素为0的张量
import tensorflow as tf a = tf.zeros(shape=(2,3), dtype=tf.float16, name='a') # 在交互模式下开启回话 tf.InteractiveSession() a.eval()
b = tf.zeros_like(a) b.eval()
正态分布
张量操作-张量变换
提供给Tensor运算的数学函数网址
-
算术运算符
-
基本数学函数
-
矩阵运算
-
减少维度的运算(求均值)
-
序列运算
- https://www.tensorflow.org/versions/r1.0/api_guides/python/math_ops
Tensorflow进阶之变量
变量也是一种OP，是一种特殊的张量，能够进行存储持久化，它的值就是张量,默认被训练
变量的创建
tf.Variable(initial_value=None,name=None, trainable=True)
- 创建一个带值initial_value的新变量
assign(value)
- 为变量分配一个新值返回新值
eval(session=None)
- 计算并返回此变量的值
name属性表示变量名字
变量的初始化
tf.global_variables_initializer()
- 添加一个初始化所有变量的op在会话中开启
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def var_demo():
"""
演示变量的基本使用:
定义 tf.Variable() 仅仅完成了变量的定义
初始化 必须将当前图中定义变量 通过global_variables_initializer 收集所有需要初始化的变量 得到一个op对象
初始化: 必须在 会话对象中 运行 初始化的op对象才能够创建变量
作用域
:return: None
"""
# 不能够写成创建或者初始化 而是设置一个变量
# 变量也是张量
a = tf.Variable(initial_value=1.0, name='axxx')
b = tf.Variable(initial_value=1.0, name='bxxx')
# print(a)
# 会返回一个op操作, 该操作会获取到当前图中所有需要被创建的变量
init_op = tf.global_variables_initializer()
print("=====")
print(init_op)
print("=====")
with tf.Session() as sess:
# 在访问a之前 进行初始化的操作, 运行init_op 就可以了
sess.run(init_op)
print(a.eval())
return None
if __name__ == '__main__':
var_demo()
小案例：矩阵相乘演示变量变化的过程
矩阵相乘一个矩阵的行必须等于另外一个列
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def mat():
"""
矩阵相乘
:return: None
"""
# 1行 3列的张量
var1 = tf.Variable(initial_value=[[1, 2, 3]], name="var1")
# 3行 2列 张量
var2 = tf.Variable(initial_value=[[4, 5], [6, 7], [8, 9]], name='var2')
# 定义一个矩阵相乘的操作
mat_op = tf.matmul(var1, var2)
# Attempting to use uninitialized value Variable
# 变量需要被初始化
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
# 运行初始化的op对象
sess.run(init_op)
# 变量初始化之后 可以将变量的变化写入到一个events文件中
tf.summary.FileWriter(logdir='/tmp/log/', graph=sess.graph)
ret = sess.run(mat_op)
print(ret)
return None
if __name__ == '__main__':
mat()
可视化学习Tensorboard
数据序列化-events文件
TensorBoard 通过读取 TensorFlow 的事件文件来运行
- tf.summary.FileWriter('/tmp/tensorflow/summary/test/', graph=)
- 返回filewriter,写入事件文件到指定目录(最好用绝对路径)，以提供给tensorboard使用
开启
tensorboard --logdir=“/tmp/log/”
一般浏览器打开为127.0.0.1:6006
注：修改程序后，再保存一遍会有新的事件文件，打开默认为最新
图中的符号意义
增加变量显示
目的：观察模型的参数、损失值等变量值的变化
1、收集变量
-
tf.summary.scalar(name=’’,tensor) 收集对于损失函数和准确率等单值变量,name为变量的名字，tensor为值
-
tf.summary.histogram(name=‘’,tensor) 收集高维度的变量参数
-
tf.summary.image(name=‘’,tensor) 收集输入的图片张量能显示图片
2、合并变量写入事件文件
-
merged = tf.summary.merge_all()
-
运行合并：summary = sess.run(merged)，每次迭代都需运行
-
添加：FileWriter.add_summary(summary,i),i表示第几次的值
tensorflow变量作用域
tf.variable_scope(<scope_name>)创建指定名字的变量作用域
-
观察变量的name改变
-
嵌套使用变量作用域
-
观察变量的name改变
如果在之前，给变量取相同的name会出现什么样的情况
tensorflow变量作用域的作用
- 让模型代码更加清晰，作用分明
模型保存和加载
-
tf.train.Saver(var_list=None,max_to_keep=5)
-
var_list:指定将要保存和还原的变量。它可以作为一个dict或一个列表传递.
-
max_to_keep：指示要保留的最近检查点文件的最大数量。创建新文件时，会删除较旧的文件。如果无或0，则保留所有检查点文件。默认为5（即保留最新的5个检查点文件。）
例如：saver.save(sess, '/tmp/ckpt/test/model')
saver.restore(sess, '/tmp/ckpt/test/model')
保存文件格式：checkpoint文件
tensorflow实现一个简单的线性回归案例
Tensorflow运算API
矩阵运算
- tf.matmul(x, w)
平方
- tf.square(error)
均值
- tf.reduce_mean(error)
梯度下降API
tf.train.GradientDescentOptimizer(learning_rate)梯度下降优化
-
learning_rate:学习率，一般为 0.01
-
method:
-
return:梯度下降op
案例演示
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def linear():
"""
通过tensorflow来手动实现线性回归
相关的函数: matmul, square, reduce_mean, tf.train.GradientDescentOptimizer(learning_rate)
y = 0.7 * x1 + 0.8
:return: None
"""
# 准备数据 这个自变量的值服从标准的正态分布
# 指定作用域的命名空间
with tf.variable_scope('data'):
x = tf.random_normal(shape=[100, 1], mean=0, stddev=1.0)
# 目标值 权重的矩阵 乘以特征值的矩阵
y = tf.matmul(x, [[0.7]]) + 0.8
with tf.variable_scope('model'):
# 随机的指定权重值weight 和 偏置值 bias, 最终在训练的过程中让随机指定weight 和bias 向 0.7 和 0.8靠近
# weight就应该是一个变量, 变量才能够被训练
weight = tf.Variable(
initial_value=tf.random_normal(shape=[1, 1], mean=0, stddev=1.0), name='weight'
)
bias = tf.Variable(initial_value=0.0, name='bias')
# 获取预测值
y_predict = tf.matmul(x, weight) + bias
with tf.variable_scope("op"):
# 获取均方误差
loss = tf.reduce_mean(tf.square(y - y_predict))
# 定义优化损失的op
# 通过梯度下降优化误差 最小化误差
# learning_rate 学习的速率
train_op = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
# 需要初始化变量
init_op = tf.global_variables_initializer()
# 收集变量的变化
tf.summary.scalar('loss', loss)
tf.summary.scalar('bias', bias)
tf.summary.histogram('weight', weight)
# 合成一个操作对象
merge_op = tf.summary.merge_all()
# 定义模型的保存操作
saver_op = tf.train.Saver()
# 在会话中运行op 优化损失
with tf.Session() as sess:
# 初始化变量
sess.run(init_op)
# 将变量的变化写入到events文件中
file_writer = tf.summary.FileWriter(logdir='./tmp/summary/linear/', graph=sess.graph)
# 执行梯度下降优化损失的操作
# 从之前保存的路径来进行恢复操作
if os.listdir('./tmp/summary/linear/li/'):
print("===================")
saver_op.restore(sess=sess, save_path='./tmp/summary/linear/li/')
for i in range(150):
# 每次迭代都需要运行 需要在循环中执行
summary = sess.run(merge_op)
print("随机得到的权重值为%f, 偏置值为%f" % (weight.eval(), bias.eval()))
sess.run(train_op)
print("随机得到的权重值为%f, 偏置值为%f" % (weight.eval(), bias.eval()))
# 每一次循环都需要记录变化\
# 将合成的变化写入到events文件中
file_writer.add_summary(summary, i)
if i % 10 == 0:
# 每次迭代都需要完成保存的操作
pass
# 迭代结束之后就开始保存变量
saver_op.save(sess=sess, save_path='./tmp/summary/linear/li/')
return None
if __name__ == '__main__':
linear()
tensorboard 查看可视化模型
tensorboard --logdir='/home/python/Desktop/biao/tesorflow_tes/tmp/summary' --host='192.168.1.8'
自定义命令行参数
2、 tf.app.flags.,在flags有一个FLAGS标志，它在程序中可以调用到我们前面具体定义的flag_name
3、通过tf.app.run()启动main(argv)函数
案例演示
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
# 自定义命令行参数
tf.app.flags.DEFINE_string(flag_name='home_path', default_value='./tmp', docstring="默认的路径信息")
tf.app.flags.DEFINE_integer(flag_name='max_step', default_value=30, docstring="最大迭代的次数")
FLAGS = tf.app.flags.FLAGS
def main(argv):
print(argv)
print(FLAGS.home_path)
print(FLAGS.max_step)
if __name__ == '__main__':
tf.app.run()
