张量的变换
# 2.4.3 张量的变换
# ndarray属性的修改
# 类型的修改
# 1）ndarray.astype(type)
# tf.cast(tensor, dtype)
# 不会改变原始的tensor
# 返回新的改变类型后的tensor
# 2）ndarray.tostring()
# 形状的修改
# 1）ndarray.reshape(shape)#返回一个新的数组
# -1 自动计算形状
# 2）ndarray.resize(shape)#对原数组进行修改
# 静态形状 - 初始创建张量时的形状
# 1）如何改变静态形状
# 什么情况下才可以改变/更新静态形状？
# 只有在形状没有完全固定下来的情况下(占位符)
# tensor.set_shape(shape)
# 2）如何改变动态形状
# tf.reshape(tensor, shape)
# 不会改变原始的tensor
# 返回新的改变形状后的tensor
# 动态创建新张量时，张量的元素个数必须匹配
类型改变
由tf.int32变成了tf.float32
linear_squares = tf.constant([[4], [9], [16], [25]], dtype=tf.int32)
print("linear_squares_before:\n",linear_squares)
l_cast=tf.cast(linear_squares,dtype=tf.float32)
print("linear_squares_after:\n",linear_squares)
print("l_cast:\n",l_cast)
更新/改变静态形状
#定义占位符
a_p=tf.placeholder(dtype=tf.float32,shape=[None,None])
b_p=tf.placeholder(dtype=tf.float32,shape=[None,10])
c_p=tf.placeholder(dtype=tf.float32,shape=[3,2])
print("a_p:\n",a_p)
print("b_p:\n",b_p)
print("c_p:\n",c_p)
#更新形状未确定的部分,已经固定的部分不能更改，只能更改那些为问号的地方
a_p.set_shape([2,3])
b_p.set_shape([2,10])
print("a_p:\n",a_p)
print("b_p:\n",b_p)
动态形状的修改,不能改变原始数据的个数，只能变换形状
a_p_reshape=tf.reshape(a_p,shape=[2,3,1])
print("a_p:\n",a_p)
print("a_p_reshape:\n",a_p_reshape)
关于动态形状和静态形状必须符合以下规则
静态形状
转换静态形状的时候，1-D到1-D，2-D到2-D，不能跨阶数改变形状（比如原来形状是[None,None],可以改成[3,4],不能改成[2,2,2]）
对于已经固定的张量的静态形状的张量，不能再次设置静态形状
动态形状
tf.reshape)动态创建新张量时，张量的元素个数必须匹配
张量的数学运算
张量的数学运算
1.算术运算符
2.基本数学函数
3.矩阵运算
4.reduce操作
5.序列索引操作
详细请参考: https://tensorflow.google.cn/versions/r1.15/api_docs/python/tf/math
变量
TensorFlow变量是表示程序处理的共享持久状态的最佳方法。变量通过tf.VariableOP类进行操作。变量的特点∶
●存储持久化
●可修改值
●可指定被训练
变量是用来保存深度学习的模型参数
创建变量
**tf.Variable(initial_value=None,trainable=True,collections=None,name=None)**
# 2.5 变量OP
# TensorFlow - 变量
# 存储模型参数
# 2.5.1 创建变量
# tf.Variable.init(initial_value, trainable=True, collections=None, validate_shape=True, name=None)
# 变量需要显式初始化，才能运行值
# 2.5.2 使用tf.variable_scope()修改变量的命名空间
# 使得结构更加清晰
initial_value:初始化的值
trainable:是否被训练
collections:新变量将添加到列出的图的集合中collections，默认为[GraphKeys.GLOBAL_VARIABLES]，如果trainable是True变量也被添加到图形集合GraphKeys.TRA INABLE_VARIABLES
变量需要显式初始化，才能运行值
import tensorflow as tf
#创建变量
#修改命名空间
with tf.variable_scope("my_scope"):
a = tf.Variable(initial_value=50)
b = tf.Variable(initial_value=40)
with tf.variable_scope("your_scope"):
c = tf.add(a, b)
print("a:\n",a)
print("b:\n",b)
print("c:\n",c)
#初始化变量
init=tf.global_variables_initializer()
#开启会话
with tf.Session() as sess:
#运行初始化
sess.run(init)
a_value,b_value,c_value=sess.run([a,b,c])
print("a_value:\n",a_value)
print("b_value:\n", b_value)
print("c_value:\n", c_value)
tensorflow实现线性回归
# 2.7 案例：实现线性回归
# 2.7.1 线性回归原理复习
# 1）构建模型
# y = w1x1 + w2x2 + …… + wnxn + b
# 2）构造损失函数
# 均方误差
# 3）优化损失
# 梯度下降
# 2.7.2 案例：实现线性回归的训练
# 准备真实数据
# 100样本
# x 特征值 形状 (100, 1)
# y_true 目标值 (100, 1)
# y_true = 0.8x + 0.7
# 假定x 和 y 之间的关系 满足
# y = kx + b
# k ≈ 0.8 b ≈ 0.7
# 流程分析：
# (100, 1) * (1, 1) = (100, 1)
# y_predict = x * weights(1, 1) + bias(1, 1)
# 1）构建模型
# y_predict = tf.matmul(x, weights) + bias
# 2）构造损失函数
# error = tf.reduce_mean(tf.square(y_predict - y_true))
# 3）优化损失
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)
# 5 学习率的设置、步数的设置与梯度爆炸
# 2.7.3 增加其他功能
# 1 增加变量显示
# 1）创建事件文件
# 2）收集变量
# 3）合并变量
# 4）每次迭代运行一次合并变量
# 5）每次迭代将summary对象写入事件文件
# 2 增加命名空间
# 3 模型的保存与加载
# saver = tf.train.Saver(var_list=None,max_to_keep=5)
# 1）实例化Saver
# 2）保存
# saver.save(sess, path)
# 3）加载
# saver.restore(sess, path)
# 3 模型的保存与加载
# saver = tf.train.Saver(var_list=None,max_to_keep=5)
# 1）实例化Saver
# 2）保存
# saver.save(sess, path)
# 3）加载
# saver.restore(sess, path)
# 4 命令行参数使用
# 1）tf.app.flags
# tf.app.flags.DEFINE_integer("max_step", 0, "训练模型的步数")
# tf.app.flags.DEFINE_string("model_dir", " ", "模型保存的路径+模型名字")
# 2）FLAGS = tf.app.flags.FLAGS
# 通过FLAGS.max_step调用命令行中传过来的参数
# 3、通过tf.app.run()启动main(argv)函数
import tensorflow as tf
import os
with tf.variable_scope("prepare_data"):
# 1）准备数据
X = tf.random_normal(shape=[100, 1], name="feature")
y_true = tf.matmul(X, [[0.8]]) + 0.7
with tf.variable_scope("create_model"):
# 2）构造模型
# 定义模型参数 用 变量
weights = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Weights")
bias = tf.Variable(initial_value=tf.random_normal(shape=[1, 1]), name="Bias")
y_predict = tf.matmul(X, weights) + bias
with tf.variable_scope("loss_function"):
# 3）构造损失函数
error = tf.reduce_mean(tf.square(y_predict - y_true))
with tf.variable_scope("optimizer"):
# 4）优化损失
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(error)
# 2_收集变量
tf.summary.scalar("error", error)
tf.summary.histogram("weights", weights)
tf.summary.histogram("bias", bias)#偏置
# 3_合并变量
merged = tf.summary.merge_all()
# 创建Saver对象
saver = tf.train.Saver()
# 显式地初始化变量
init = tf.global_variables_initializer()
# 开启会话
with tf.Session() as sess:
# 初始化变量
sess.run(init)
# 1_创建事件文件
file_writer = tf.summary.FileWriter("./tmp/linear", graph=sess.graph)
# 查看初始化模型参数之后的值
print("训练前模型参数为：权重%f，偏置%f，损失为%f" % (weights.eval(), bias.eval(), error.eval()))
# 开始训练
# for i in range(100):
# sess.run(optimizer)
# print("第%d次训练后模型参数为：权重%f，偏置%f，损失为%f" % (i+1, weights.eval(), bias.eval(), error.eval()))
#
# # 运行合并变量操作
# summary = sess.run(merged)
# # 将每次迭代后的变量写入事件文件
# file_writer.add_summary(summary, i)
#
# # 保存模型
# if i % 10 ==0:
# saver.save(sess, "./tmp/model/my_linear.ckpt")
# 加载模型
if os.path.exists("./tmp/model/checkpoint"):
saver.restore(sess, "./tmp/model/my_linear.ckpt")
print("训练后模型参数为：权重%f，偏置%f，损失为%f" % (weights.eval(), bias.eval(), error.eval()))
稀疏数组
class SparseArray(object):
def print_array(self, array): # 打印测试
for row_item in array:
for data in row_item:
print("%d" % data, end=" ")
print()
def make_sparse_array(self, array): # 将二维数组 转 稀疏数组
if array == "":
return
total = 0
for row_num in range(len(array)):
for col_num in range(len(array[0])):
if array[row_num][col_num] != 0:
total += 1
# 开始创建稀疏数组
sparse_array = [[0 for i in range(3)] for j in range(total + 1)]
sparse_array[0][0] = len(array)
sparse_array[0][1] = len(array[0])
sparse_array[0][2] = total
# 遍历二维数组，将非0的值存放到 sparse_array 中
count = 0
for row_index, row_item in enumerate(array):
for col_index, col_item in enumerate(row_item):
if col_item:
count += 1
sparse_array[count][0] = row_index
sparse_array[count][1] = col_index
# sparse_array[count][2] = chess_array[row_index][col_index]
sparse_array[count][2] = col_item
return sparse_array
def back_array(self, array): # 将稀疏数组 还原 二维数组
previous_array = [[0 for i in range(array[0][0])] for j in range(array[0][1])]
for index, item in enumerate(array):
if index == 0:
continue
previous_array[item[0]][item[1]] = item[2]
return previous_array
if __name__ == '__main__':
row = 11 # 得到行数
col = 11 # 得到列数
chess_array = [[0 for i in range(col)] for j in range(row)]
# 给原始二维数组输入值
chess_array[1][2] = 1
chess_array[2][3] = 2
chess_array[4][5] = 2
# 实例测试
obj = SparseArray()
obj.print_array(chess_array)
sparse_array = obj.make_sparse_array(chess_array)
obj.print_array(sparse_array)
previous_array = obj.back_array(sparse_array)
obj.print_array(previous_array)
# print(obj.make_sparse_array(chess_array))
# print(obj.back_array(obj.make_sparse_array(chess_array)))
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
