tensorflow 数据及操作整理

标签：numpy random print tape tf 整理 tensorflow 操作 grad

 

目录：

# 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))

 

 

 

 

标签：numpy,random,print,tape,tf,整理,tensorflow,操作,grad
From： https://www.cnblogs.com/xiaoxuebiye/p/17681359.html