Tensorflow1.9编程基础

Tensorflow编程基础一.tensor概念与生成 1.张量是一个数据容器

0维张量:标量
1维张量:向量
2维张量:矩阵
3维张量:彩色图像
4维张量:彩色图像序列(时间/通道/行/列)

2.生成张量

import tensorflow as tf
tf.constant() #创建一个常量tensor，类型可以是Int、floatstring
#value
#dtype
#shape

# In[]
import tensorflow as tf
constant_tensor=tf.constant(value=1.0,dtype=tf.float32,shape=[2,3])
sess =tf.Session()
print(sess.run(constant_tensor))

# In[]
constant_tensor=tf.constant(value=[1.0,1.0,1.0])
sess =tf.Session()
print(sess.run(constant_tensor))
# In[]
constant_tensor=tf.constant(value=[1,1,1],dtype=tf.int32)
sess =tf.Session()
print(sess.run(constant_tensor))



tf.zeros()#创建一个指定dtype类型的全零tensor
# shape
#dtype
# In[]
zero_tensor=tf.zeros(shape=[2,3],dtype=tf.int32)
sess=tf.Session()
print(sess.run(zero_tensor))

3.类型转换

tf.to_double()#将tensor转为double/float64类型
tf.to_float()#将tensor转为float类型
tf.to_int32()#将Tensor转为int32类型
tf.to_int64()#将tensor转为int64类型
tf.cast()#将tensor转为指定类型的数据

# In[]
tf.to_double()#将tensor转为double/float64类型
tf.to_float()#将tensor转为float类型
tf.to_int32()#将Tensor转为int32类型
tf.to_int64()#将tensor转为int64类型
tf.cast()#将tensor转为指定类型的数据

# In[]

tensor_before = tf.constant(value=[1.1,2.2,3.3],dtype=tf.float32)
tensor_after=tf.to_double(tensor_before)
tensor_after_int=tf.to_int32(tensor_before)
tensor_after_float=tf.to_float(tensor_after_int)

sess=tf.Session()
print(sess.run(tensor_before))
print(sess.run(tensor_after))
print(sess.run(tensor_after_int))
print(sess.run(tensor_after_float))

# In[]
# tf.cast
#x
#dtpye
tensor_after=tf.cast(tensor_before,dtype=tf.int32)
print(sess.run(tensor_after))

4.索引和切片

tf.shape()#返回一个tensor的维度
tf.size()#返回一个tensor中元素的个数
tf.slice()#按照指定的下标范围对tensor进行切片
tf.split()#将一个tensor分割成若干个tensor
tf.tile()#将Tensor按指定维度进行复制
tf.concat()#合并两个tensor
tf.tanspose()对tf进行转置

# In[]
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)

#shape and size
shape_of_tensor=tf.shape(constant_tensor)
size_of_tensor=tf.size(constant_tensor)

sess=tf.Session()
print(sess.run(shape_of_tensor)) 
print(sess.run(size_of_tensor)) 
# In[]
# slice
# tf.slice
#input_
#begin must be tensor
#size must be tensor
constant_tensor=tf.constant(value=[1.1,2.2,3.3],dtype=tf.float32)
tensor_sliced=tf.slice(constant_tensor,begin=[0],size=[2])
sess=tf.Session()
print(sess.run(tensor_sliced)) 
# In[]
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)
#从第零行第一个开始取
tensor_sliced=tf.slice(constant_tensor,begin=[0,1],size=[2,2])
sess=tf.Session()
print(sess.run(tensor_sliced)) 

# In[]
#split
#value
#num_of_size_splite；num_split；size_splits
#axis
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)
results=tf.split(constant_tensor,3,axis=1)

sess=tf.Session()
print(sess.run(results))
# In[]
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)
results=tf.split(constant_tensor,[1,2],axis=1)

sess=tf.Session()
print(sess.run(results))
# In[]
#tile
#input
#multiples must be an int tensor
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)
tensor_tiled=tf.tile(constant_tensor,[2,1])
#行堆叠2次，列堆叠一次
sess=tf.Session()
print(sess.run(tensor_tiled))

# In[]
#cancat concatenate
#values
#axis
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)
constant_tensor_2=tf.constant(value=[[1.1,2.2],[0.1,0.2]],dtype=tf.float32)

tensor_concat=tf.concat((constant_tensor,constant_tensor_2),axis=1)

sess=tf.Session()
print(sess.run(tensor_concat))

# In[]
#tanspose
constant_tensor=tf.constant(value=[[1.1,2.2,3.3],[0.1,0.2,0.3]],dtype=tf.float32)
tensor_t=tf.transpose(constant_tensor)
sess=tf.Session()
print(sess.run(tensor_t))

5.张量变形

tf.squeeze()#压缩tensor中的一个维度
tf.expand_dims()#扩展tensor中的一个维度
tf.reshape()#对tensor的维度进行改变

# In[]
#squeeze
#input
#axis
constant_tensor=tf.constant(1,shape=[2,1,3,1])
squeezed_tensor=tf.squeeze(constant_tensor,axis=1)
sess=tf.Session()
print(sess.run(constant_tensor))
print(sess.run(squeezed_tensor))

# In[]
#expand_dims
#input
#axis

expanded_tensor=tf.expand_dims(squeezed_tensor,axis=1)
sess=tf.Session()
print(sess.run(constant_tensor))
print(sess.run(squeezed_tensor))
print(sess.run(expanded_tensor))

# In[]
#reshape
#input
#shape
constant_tensor=tf.constant([1,2,3,4,5,6])
reshaped_shape=tf.reshape(constant_tensor,shape=[2,3])
sess=tf.Session()
print(sess.run(reshaped_shape))

二、数据流图 1.什么是数据流图

占位符和变量都表示为数据节点
创建好默认图之后，还可以创建新的计算图

![在这里插入图片描述](https://img-blog.csdnimg.cn/cea6327af7cd42229a849a11e5e92f81.png

三、会话、占位符与变量 1.会话

使用tf.Session()构建数据流图
使用sess.run()运行数据流图中的一个operation

import tensorflow as tf
x = tf.constant(2.0,dtype=tf.float64)
y = tf.constant(3.0,dtype=tf.float64)
z = tf.add(x,y)

with tf.Session() as sess:
    print(sess.run(z))

2.占位符

占位符只是一个变量，用于之后分配数据
在不提供具体数据的情况下创建操作并构建计算图
在执行计算时，通过占位符将数据提供给计算图

import numpy as np
x=tf.placeholder(tf.float32,shape=(1024,1024))
y=tf.matmul(x,x)

with tf.Session() as sess:
   # print(sess.run(y)) #会报错，因为没有将x传给y
    
    rand_array =np.random.rand(1024,1024)
    print(sess.run(y,feed_dict={x:rand_array}))

3.变量

用于定义网络中的参数，可被训练，需要初始化
使用Variable是表示程序处理的共享持久状态的最佳方法
通过实例化一个Variable()类来创建变量
Variable在被调用时会保持在计算图中的状态
Variable会存储持久性张量，允许读取和修改张量的值
修改在多个Session之间是可见的，对于一个Variable，多个工作器可以看到相同的值

4.变量和占位符

相同点:

二者都是TensorFlow数据流图中的数据节点表示形式
不同点:
placeholder一般不在训练中更新;Variable一般会在训练中更新
placeholder不需要初始化; Variable需要初始化
placeholder需要在Session中使用feed给定具体的数值;Variable无需feed给定数值

四、优化器、TensorflowBoard与模型加载保存 1.优化器

不同的优化算法是TensorFlow计算图中解决优化问题的一个Operation,需要在会话中运行
常用的优化器
class tf.train.GradientDescentOptimizer 收敛速度最慢，效果最好
class tf.train.Adadelta0ptimizer
class tf.train.Adagrad0ptimizer
class tf.train.MomentumOptimize
rclass tf.train.AdamOptimizer

2.TensorBoard

TensorBoard是TensorFlow内置的一个可视化工具，它通过将TensorFlow程序输出的日志文件的信息可视化使得程序的理解、调试和优化更加简单高效
使用步骤
定义FileWriter
将需要可视化的graph或数据添加到FileWriter中
启动TensorBoard服务端程序，在前端查看训练过程状态。
官方文档: https://github.com/tensorflow/tensorboard

3.模型载入/保存 a.保存

Saver类添加了在检查点之间保存和恢复变量的操作
检查点是专有格式的二进制文件，它将变量名称映射到张量值
可以使用提供的计数器自动为检查点文件名编号，可以在训练模型时在不同的步骤中保留多个检查点

b.恢复

restore恢复以前保存的变量
构造函数添加ops以恢复变量，需要启动图表的会话
要恢复的变量不必初始化，因为恢复本身就是一种初始化变量的方法
save _path参数通常是先前从save()调用对latest_checkpoint()调用返回的值

restore(sess,save_path)

五、矩阵计算 1.矩阵计算相关函数

更多请查阅:https://www.tensorflow.org/versions/r1.9/api_docs/python/tf/matrix solve

tf.diag(diagonal)#得到以diagnoal为对角线元素的Tensor
tf.trace()#求矩阵的迹
tf.transpose()#矩阵转置
tf.eye()#生成单位矩阵
tf.matmul()#矩阵相乘
tf.norm()#计算向量、矩阵、张量的范数
tf.matrix_determinant()#计算矩阵的行列式
tf.matrix_inverse()#计算矩阵的逆
tf.cholesky（）#计算一个或多个方针的cholesky分解
tf.matrix_solve()#求解线性方程组

tf.sin()/tf.cos()/tf.tan()
tf.sqrt()/tf.square()

tf.reduce_max()/tf.reduce_min()/tf.reduce_mean()/tf.reduce_sum()/tf.reduce_std()
#返回最大值/最小值/均值/总和/标准差，可通过axis指定维度

tf.argmax()/tf.argmin()
#返回最大值/最小值索引，可指定aixs（同上），输出默认为Int64型
tf.nn.softmax()/tf.sigmoid()

更多请参考:https://www.tensorflow.org/api docs/python/tf/math

# In[]
import tensorflow as tf

constant_tensor=tf.constant([1,2,3,4,5,6,7,8,9])
constant_tensor=tf.reshape(constant_tensor,shape=[3,3])

constant_tensor_2=tf.constant([0.1,0.2,0.3,0.4,0.5,0.6])
constant_tensor_2=tf.reshape(constant_tensor_2,shape=[3,2])
constant_tensor_2=tf.to_float(constant_tensor)
#constant_tensor_2=tf.cast(constant_tensor,dtype=tf.float32)
#diag
result_diag= tf.diag([1,5,9])
#trace
result_trace=tf.trace(constant_tensor)
#eye
result_eye=tf.eye(3)
#matmul 
#two matrices have the same dtype
result_matmul=tf.matmul(constant_tensor,constant_tensor_2)


sess=tf.Session()

print(sess.run(constant_tensor))
print(sess.run(result_diag))
print(sess.run(result_trace))
print(sess.run(result_eye))
print(sess.run(result_matmul))
# In[]
#norm
#tensor
#ord 2
#tensor must a float double complex
constant_tensor=tf.cast(constant_tensor,dtype=tf.float32)
result_norm=tf.norm(constant_tensor,2)
sess=tf.Session()

print(sess.run(result_norm))

# In[]
#matrix_inverse
#tf.linalg.inv
constant_tensor=tf.eye(3)
result_inv=tf.linalg.inv(constant_tensor)

sess=tf.Session()
print(sess.run(result_inv))
# In[]

#tf.cholesky
#tf.linalg.cholesky
result_cholesky=tf.linalg.cholesky(constant_tensor)
print(sess.run(result_cholesky))

# matrix_solve

六、线性回归实例

# -*- coding: utf-8 -*-
"""
Created on Mon Jun 13 19:31:38 2022

@author: dell
"""
# In[]
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# In[]
# 设置必要参数

## 设置学习率
learning_rate = 0.01

## 设置迭代轮数
training_epochs = 1000

## 每50轮展示当前模型的参数值和损失
display_step = 50

## 每500轮保存一次模型
save_step = 500
# In[]
# 设定原始数据

## 训练集
train_X = np.asarray([3.3,4.4,5.5,6.71,6.93,4.168,9.779,6.182,7.59,2.167,
                         7.042,10.791,5.313,7.997,5.654,9.27,3.1])

## 训练集标签
train_Y = np.asarray([1.7,2.76,2.09,3.19,1.694,1.573,3.366,2.596,2.53,1.221,
                         2.827,3.465,1.65,2.904,2.42,2.94,1.3])
# In[]
# 定义张量占位符
X = tf.placeholder("float", name="X")
Y = tf.placeholder("float", name="Y")
# In[]
# 定义权重和偏置

with tf.variable_scope("liner_regression"):
    # 设置模型的权重和偏置
    W = tf.get_variable(initializer=np.random.randn(), name="weight")  # 生成权重
    b = tf.get_variable(initializer=np.random.randn(), name="bias")  # 生成偏置
    # 构建线性回归模型（前向传播）
    mul = tf.multiply(X, W, name="mul")
    pred = tf.add(mul, b, name="pred")

# In[]
# 定义损失函数
with tf.variable_scope("l2_loss"):
    loss = tf.reduce_mean(tf.pow(pred - Y, 2)) # 以预测值pred和实际值Y之间的均方误差作为损失

# In[]
# 定义优化方法
train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)  # 使用梯度下降算法，最小化损失函数
# In[]
# 设定存储路径
ckpt_path = './ckpt/linear-regression-model.ckpt'

# In[]
# 创建一个存储器
saver = tf.train.Saver()
# In[]
# 日志数据存储路径
summary_path = './ckpt'
global_step = tf.train.get_or_create_global_step()
# In[]
# 数据汇总和记录
tf.summary.scalar('weight', W)
tf.summary.scalar('bias', b)
tf.summary.scalar('loss', loss)
# In[]
# 合并汇总结果
merged = tf.summary.merge_all()
# In[]
# 建立会话运行程序
with tf.Session() as sess:

    # 初始化变量
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    
    # 将汇总结果写入文件
    file_writer = tf.summary.FileWriter("./temp/summary/linear", graph=sess.graph)

    # 拟合训练数据
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            # 带入数据
            _, summary = sess.run([train_op, merged], feed_dict={X: x, Y: y})
 
        # 保存模型
        if (epoch + 1) % save_step == 0:
            save_path = saver.save(sess, ckpt_path, global_step=epoch)
            print("Model saved in file: %s" % save_path)
 
        # 展示每步训练的日志
        if (epoch + 1) % display_step == 0:
            # Display loss and value
            c = sess.run(loss, feed_dict={X: train_X, Y: train_Y})
            print("Epoch:", '%04d' % (epoch+1), "loss=", "{:.9f}".format(c), "W=", W.eval(), "b=", b.eval())

            file_writer.add_summary(summary, global_step=epoch)

    print("Optimization Finished!")

    # 保存最终模型
    save_path = saver.save(sess, ckpt_path, global_step=epoch)
    print("Final model saved in %s" % save_path)

    # 计算最终损失函数
    training_loss = sess.run(loss, feed_dict={X: train_X, Y: train_Y})
    print("Training loss=", training_loss, "W=", sess.run(W), "b=", sess.run(b), 'n')

    # 画图
    plt.plot(train_X, train_Y, 'ro', label='Original data')
    plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
    plt.legend()
    plt.show()
# In[]

Tensorflow1.9编程基础

Python相关栏目本月热门文章