目录：
# 1. 类型
# 2. 基础操作
# 3. 运算相关
# 4. 求导相关
数据类型：
##############################
# 标量（0 维数组）、
# 向量（1 维数组）、
# 矩阵（2 维数组）
# 张量 （Tensor）, 概念上等同于多维数组
# 1. 类型
# 定义一个随机数（标量）
random_float = tf.random.uniform(shape=()) print("random_float:",random_float) random_1d = tf.zeros(shape=(1)) print("random_1d:",random_1d)
# 定义一个有2个元素的零向量
zero_vector = tf.zeros(shape=(2)) print("zero_vector:",zero_vector)
# 定义两个2×2的常量矩阵
A = tf.constant([[1., 2.], [3., 4.]]) B = tf.constant([[5., 6.], [7., 8.]]) print("tf.constant:",A) print(A.shape) # 输出(2, 2)，即矩阵的长和宽均为2 print(A.dtype) # 输出<dtype: 'float32'> print(A.numpy()) # 输出[[1. 2.]
# 2. 基础操作
print(A+B) print(A-B) print(A*B) print(A/B) ten = tf.convert_to_tensor( [[1., 2.], [3., 4.]] ) random_1d = tf.zeros(shape=(1)) tf.zeros_initializer() tf.zeros_like() # tensor = tf.constant([[1, 2, 3], [4, 5, 6]]) # tf.zeros_like(tensor) # [[0, 0, 0], [0, 0, 0]]
#
# 7种初始化
#
tf.constant_initializer() #初始化给定的常量 tf.zeros_initializer() # = tf.Zeros() 设0 tf.ones_initializer() tf.random_normal_initializer(mean,stddev) # 正太分布 tf.truncatediv ## ?? tf.random_uniform_initializer(a,b,seed,dtype) # a-b 随机分布 tf.random_uniform_initializer #??
#
# 打乱
tf.random.shuffle(val, seed, name) #沿着0维度打乱
# 检查维度
A.ndim()
tf.rank(A)
A.shape
#to numpy
A.numpy()
#检查数据类型
tf.is_tensor()
A.dtype
isinstance(A, tf.Tensor)
# ==> tf.Tensor 转成 tf 类型数据
ten = tf.convert_to_tensor( [[1., 2.], [3., 4.]] ) data_5d = np.random.rand(10000*5) data_5d = data_5d.reshape((10000,5)) tensor = tf.convert_to_tensor( data_5d )
#数据转换
tf.cast(A, dtype = tf.float32)
tf.Variable(A)
#维度转变
tf.reshape(A,[4,-1,3]) tf.reshape(A,[4,784,3])
tf.transpose() # 倒置
########################
# 3. 运算相关
A+B tf.expand_dims(A, axis = 0)
# tf.GradientTape() 自动求导机制
x = tf.Variable(initial_value=3.) with tf.GradientTape() as tape: # 在 tf.GradientTape() 的上下文内，所有计算步骤都会被记录以用于求导 y = tf.square(x) y_grad = tape.gradient(y, x) # 计算y关于x的导数 print(y, y_grad) for x_n in [1.0,2.0,3.0]: x = tf.Variable(initial_value=x_n) with tf.GradientTape() as tape: # 在 tf.GradientTape() 的上下文内，所有计算步骤都会被记录以用于求导 y = tf.square(x) y_grad = tape.gradient(y, x) # 计算y关于x的导数 print("x, y,y_grad:", x_n, y.numpy(), y_grad.numpy())
#########################################
### 求导
# 更多情况是复杂的多元 函数 求导
X = tf.constant([[1., 2.], [3., 4.]]) y = tf.constant([[1.], [2.]]) w = tf.Variable(initial_value=[[1.], [2.]]) b = tf.Variable(initial_value=1.) # y = wx + b with tf.GradientTape() as tape: L = tf.reduce_sum(tf.square(tf.matmul(X, w) - y)) # + b w_grad1 = tape.gradient(L, w) # w_grad, b_grad = tape.gradient(L, [w, b]) # 计算L(w, b)关于w, b的偏导数 # w_grad1 = tape.gradient(L, [w]) print("L, w , w_grad, :",L.numpy(), w.numpy(), w_grad1.numpy() ) # print("L, w , w_grad :",L.numpy(), w.numpy(), w_grad.numpy() ) # print("L, w ,b , w_grad, b_grad :",L.numpy(), w.numpy(), b.numpy(), w_grad.numpy(), b_grad.numpy() )
# 关于 tape.gradient 常规方法， 手工撸方程和参数更新方法
# y = wx + b with tf.GradientTape() as tape: L = tf.reduce_sum(tf.square(tf.matmul(X, w) + b - y)) w_grad, b_grad = tape.gradient(L, [w, b]) # 计算L(w, b)关于w, b的偏导数 print("L,w_grad:" , L,w_grad) # y = wx with tf.GradientTape() as tape: L = tf.reduce_sum(tf.square(tf.matmul(X, w) - y)) w_grad1 = tape.gradient(L, w) # 计算L(w, b)关于w, b的偏导数 print("L,w_grad1:" , L,w_grad1)
# 关于 tape.gradient 用tf 方法
# 使用 tape.gradient(ys, xs) 自动计算梯度；
# 使用 optimizer.apply_gradients(grads_and_vars) 自动更新模型参数。
#########################################
### 线性回归
# 数据准备
import numpy as np X_raw = np.array([2013, 2014, 2015, 2016, 2017], dtype=np.float32) y_raw = np.array([12000, 14000, 15000, 16500, 17500], dtype=np.float32) X = (X_raw - X_raw.min()) / (X_raw.max() - X_raw.min()) y = (y_raw - y_raw.min()) / (y_raw.max() - y_raw.min()) a, b = 0, 0 num_epoch = 10000 learning_rate = 5e-4 for e in range(num_epoch): # 手动计算损失函数关于自变量（模型参数）的梯度 y = ax + b y_pred = a * X + b grad_a, grad_b = 2 * (y_pred - y).dot(X), 2 * (y_pred - y).sum() # 更新参数 a, b = a - learning_rate * grad_a, b - learning_rate * grad_b print(a, b)
### 线性回归 使用 tf 方式
X = tf.constant(X) y = tf.constant(y) a = tf.Variable(initial_value=0.) b = tf.Variable(initial_value=0.) variables = [a, b] num_epoch = 10000 optimizer = tf.keras.optimizers.SGD(learning_rate=5e-4) for e in range(num_epoch): # 使用tf.GradientTape()记录损失函数的梯度信息 with tf.GradientTape() as tape: y_pred = a * X + b loss = tf.reduce_sum(tf.square(y_pred - y)) print(e, "loss" , loss.numpy() ) # TensorFlow自动计算损失函数关于自变量（模型参数）的梯度 grads = tape.gradient(loss, variables) # TensorFlow自动根据梯度更新参数 optimizer.apply_gradients(grads_and_vars=zip(grads, variables))