3_TensorFlow基础API
先上图，后改思维导图
1 @tf.function
- 将python函数编译成tf的图结构（eg:if、for、while、break、print、递归调用、列表方法等）
- 易于将python写的模型导出为GraphDef + checkpoint或者SavedModel
- 使用eager execution可以默认打开
- 1.0的代码可以通过tf.function来继续在2.0里使用
- 2.0中的 tf.function相当于对tf1.0中的session的替代
1.1 API列表
- 基础数据类型
- Tf.constant, tf.string
- tf.ragged.constant, tf.SparseTensor, Tf.Variable
- 自定义损失函数——Tf.reduce_mean
- 自定义层次——Keras.layers.Lambda和继承法
- Tf.function
- Tf.function, tf.autograph.to_code, get_concrete_function
- GraphDef
- get_operations, get_operation_by_name
- get_tensor_by_name, as_graph_def
- 自动求导
- Tf.GradientTape
- Optimzier.apply_gradients
1.2 基础API
加载库
import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
#import keras
print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
print(module.__name__,module.__version__)
基础API
#tf第一个基础API 常量
t = tf.constant([[1.,2.,3.],[4.,5.,6.]])
#索引操作
print(t)
print(t[:,1:])
print(t[...,1]) #只得到第二列 结果是一个向量
#做算子操作ops
print(t + 10) #相加
print(tf.square(t)) #平方
print(t @ tf.transpose(t)) #矩阵乘以自身的转置
#tf对象与numpy转换
print(t.numpy()) #调用numpy把值取出来
print(np.square(t)) #tf作为numpy方法的输入
#将numpy对象直接转换为tf_tensor
np_t = np.array([[1.,2.,3.],[4.,5.,6.]])
print(tf.constant(np_t))
#Scalars
t = tf.constant(2.717)
print(t.numpy())
print(t.shape)
#strings
t = tf.constant("cafe")
print(tf.strings.length(t))
print(tf.strings.length(t,unit = "UTF8_CHAR"))
print(tf.strings.unicode_decode(t,"UTF8"))
#存储数组字符串 string array
#string array
t = tf.constant(["cafe","coffee","咖啡"])
print(tf.strings.length(t,unit = "UTF8_CHAR"))
r = tf.strings.unicode_decode(t,"UTF8")
print(r)
RaggedTensor不完整的矩阵
#RaggedTensor不完整的矩阵
#ragged tensor 的使用
r = tf.ragged.constant([[11,12],[21,22,23],[],[41]])
# index op
print(r)
print(r[1])
print(r[1:2])
# ops on ragged tensor
#拼接操作
r2 = tf.ragged.constant([[51,52],[],[71]])
print(tf.concat([r,r2],axis = 0)) #按行拼接，第零维度
#因为行数不一致，所以按列拼接需要让其行维度相同
r3 = tf.ragged.constant([[13,14],[15],[],[42,43]])
print(tf.concat([r,r3],axis = 1)) #按列拼接
#raggedtensor 可以 变成普通tensor
print(r.to_tensor())
# sparse tensor
#如果一个矩阵中大部分都是0只有小部分是1，那么就可以把对应是1的值和坐标记录下来
s = tf.SparseTensor(indices = [[0,1],[1,0],[2,3]],
values = [1.,2.,3.],
dense_shape = [3,4])
print(s)
print(tf.sparse.to_dense(s)) #sparse转换成普通的tensor
# sparse tensor
s5 = tf.SparseTensor(indices = [[0,2],[0,1],[2,3]], #indices当顺序不正确的时候 调用to_dense（）时会报错
values = [1.,2.,3.],
dense_shape = [3,4])
print(s5)
s6 = tf.sparse.reorder(s5) #排序
print(tf.sparse.to_dense(s6))
变量 Variables
# Variables
v = tf.Variable([[1.,2.,3.],[4.,5.,6.]])
print(v)
print(v.value())
print(v.numpy())
#变量重新赋值
v.assign(2*v) #给变量重新赋值
print(v.numpy())
v[0,1].assign(42) #具体位置赋值
print(v.numpy())
v[1].assign([7.,8.,9.]) #某一行赋值
print(v.numpy())
try:
v[1] = [7.,8.,9.]
except TypeError as ex:
print(ex)
2 自定义损失函数与DenseLayer
2.1、自定义损失函数
- 构建模型
#自定义损失函数
def customized_mse(y_true,y_pred):
mse = tf.reduce_mean(tf.square(y_pred - y_true)) #均方差
return mse
#构建模型
model = keras.models.Sequential([
keras.layers.Dense(30,activation='relu',input_shape=x_train.shape[1:]), #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
keras.layers.Dense(1),
])
model.summary() #打印model的信息
model.compile(loss=customized_mse,optimizer="sgd",metrics=["mean_squared_error"]) #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-3)]
- 训练模型
#训练模型
history = model.fit(x_train_scaled, y_train,
validation_data = (x_valid_scaled, y_valid),
epochs = 100,
callbacks = callbacks)
由上述训练结果可以看出 自定义损失函数和mean_squared_error效果一样
2.2、自定义层次
DenseLayer
#customized dense layer 自定义全连接层
class CustomizedDenseLayer(keras.layers.Layer):
def __init__(self,units,activation = None,**kwargs): #初始化函数
self.units = units #这一层输出由几个单元
self.activation = keras.layers.Activation(activation)
super(CustomizedDenseLayer,self).__init__(**kwargs) #调用父类函数
def build(self,input_shape): #负责参数初始化
'''构建需要的参数'''
#x * w + b input_shape:[None,a] w:[a,b] output_shape:[None,b]
self.kernel = self.add_weight(name = 'kernel',
shape = (input_shape[1],self.units),
initializer = 'uniform', #使用均匀分布的方法去初始化kernel
trainable = True) #可训练
self.bias = self.add_weight(name = 'bias',
shape = (self.units,),
initializer = 'zeros',
trainable = True)
super(CustomizedDenseLayer,self).build(input_shape)
def call(self,x): #完成一次正向计算
'''需要完成正向计算'''
return self.activation(x @ self.kernel + self.bias)
#构建模型
model = keras.models.Sequential([
# keras.layers.Dense(30,activation='relu',input_shape=x_train.shape[1:]), #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
# keras.layers.Dense(1),
CustomizedDenseLayer(30,activation='relu',input_shape=x_train.shape[1:]), #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
CustomizedDenseLayer(1),
])
model.summary() #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd") #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-3)]
对于DenseLayer这种自带参数的层，我们定义了一个这样的子类。
如果是想把一个简单的函数定义为一个层次，没有参数build()函数也就不需要了，整个类比较小，这样写不雅观。所以，对于没有参数的函数，想把它们定义为层次的时候可以选择使用，lambda的方式自定义层次。
#lambda的方式自定义层次
'''eg:将激活函数定义为一个层 tf.nn.softplus : log(1 + e^x)'''
customized_softplus = keras.layers.Lambda(lambda x : tf.nn.softplus(x))
print(customized_softplus([-10.,-5.,0.,5.,10.]))
#customized dense layer 自定义全连接层
class CustomizedDenseLayer(keras.layers.Layer):
def __init__(self,units,activation = None,**kwargs): #初始化函数
self.units = units #这一层输出由几个单元
self.activation = keras.layers.Activation(activation)
super(CustomizedDenseLayer,self).__init__(**kwargs) #调用父类函数
def build(self,input_shape): #负责参数初始化
'''构建需要的参数'''
#x * w + b input_shape:[None,a] w:[a,b] output_shape:[None,b]
self.kernel = self.add_weight(name = 'kernel',
shape = (input_shape[1],self.units),
initializer = 'uniform', #使用均匀分布的方法去初始化kernel
trainable = True) #可训练
self.bias = self.add_weight(name = 'bias',
shape = (self.units,),
initializer = 'zeros',
trainable = True)
super(CustomizedDenseLayer,self).build(input_shape)
def call(self,x): #完成一次正向计算
'''需要完成正向计算'''
return self.activation(x @ self.kernel + self.bias)
#构建模型
model = keras.models.Sequential([
# keras.layers.Dense(30,activation='relu',input_shape=x_train.shape[1:]), #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
# keras.layers.Dense(1),
CustomizedDenseLayer(30,activation='relu',input_shape=x_train.shape[1:]), #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
CustomizedDenseLayer(1),
#加一个自定义的激活函数层
customized_softplus, #等价于下面两种代码
# '''
# keras.layers.Dense(1,activation = "softplus")
# #或
# keras.layers.Dense(1),
# keras.layers.Activation('softplus')
# #或
# '''
])
model.summary() #打印model的信息
model.compile(loss="mean_squared_error",optimizer="sgd") #编译
callbacks = [keras.callbacks.EarlyStopping(patience = 5, min_delta = 1e-3)]
3 tf.function函数转换
import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf
from tensorflow import keras
#import keras
print(tf.__version__)
print(sys.version_info)
for module in mpl,np,pd,sklearn,tf,keras:
print(module.__name__,module.__version__)
- tf.function函数转换python代码—1
#讲两个东西 1、tf.function 2、auto-graph
def scaled_elu(z,scale=1.0,alpha=1.0):
# z >= 0 ? scale * z : scale * alpha * tf.nn.elu(z)
is_positive = tf.greater_equal(z,0.0) #判断z是否>0
return scale * tf.where(is_positive,z,alpha * tf.nn.elu(z)) #三元表达式，tf中用where实现三元表达式
print(scaled_elu(tf.constant(-3.)))
print(scaled_elu(tf.constant([3.,-2.5])))
#一行代码，将python实现的函数转换成，tf中图实现的函数(tf图结构里面有很多优化，最大的优点就是：快！！！)
scaled_elu_tf = tf.function(scaled_elu)
print(scaled_elu_tf(tf.constant(-3.)))
print(scaled_elu_tf(tf.constant([3.,-2.5])))
#将python实现的函数转换成，tf中图实现的函数(tf图结构里面有很多优化，最大的优点就是：快！！！)
#下面做一个测试
%timeit scaled_elu(tf.random.normal((1000,1000)))
%timeit scaled_elu_tf(tf.random.normal((1000,1000)))
- tf.function函数转换python代码—2
'''举个例子'''
#1 + 1/2 + 1/2^2 + ... + 1/2^n
def converge_to_2(n_iters):
total = tf.constant(0.)
increment = tf.constant(1.)
for _ in range(n_iters):
total += increment
increment /= 2.0
return total
print(converge_to_2(20))
%timeit converge_to_2(20)
#加一个代码，也可以将代码转换为tf中的图
@tf.function
def converge_to_2(n_iters):
total = tf.constant(0.)
increment = tf.constant(1.)
for _ in range(n_iters):
total += increment
increment /= 2.0
return total
print(converge_to_2(20))
%timeit converge_to_2(20)
查看如何将python代码转换为tf图结构的
'''用auto-graph函数查看python代码如何转换为tf图结构的'''
def display_tf_code(func):
code = tf.autograph.to_code(func)
from IPython.display import display,Markdown
display(Markdown('```python```'.format(code)))
display_tf_code(scaled_elu)
display_tf_code(converge_to_2)
注：使用@tf.function时 里面不能定义变量，需要放在外面，否则会报错
# 注：使用@tf.function时 里面不能定义变量，需要放在外面
var = tf.Variable(0.) #变量的定义写在@tf.function函数外面
@tf.function
def add_21():
return var.assign_add(21) # +=
print(add_21)
#添加input_signature限定类型
@tf.function(input_signature=[tf.TensorSpec([None],tf.int32,name='x')])
def cube(z):
return tf.pow(z,3)
try:
print(cube(tf.constant([1.,2.,3.])))
except ValueError as ex:
print(ex)
print(cube(tf.constant([1,2,3])))
4 函数签名（类型）与图结构
这部分内容，与训练model没有关系。这些函数会用在两个地方：
1、如何保存模型；
2、保存好模型，要使用这个模型的时候，怎么载入模型
（get_operation_by_name，get_tensor_by_name）
5、自定义求导（近似求导）
5.1、python自定义，求导
5.2、tf.GradientTape基本使用方法
- tf.GradientTape基本使用方法
'''tf.GradientTape基本使用方法'''
#tensorflow中，自定义求导
x1 = tf.Variable(2.0)
x2 = tf.Variable(3.0)
with tf.GradientTape() as tape:
z = g(x1,x2)
dz_x1 = tape.gradient(z,x1)
print(dz_x1)
#tape 只能使用一次。因为，调用一次tape.gradient，tape就会自动被释放了，无法再用
#所以，这里先用try 抓住这个error
try:
dz_x2 = tape.gradient(z,x2)
except RuntimeError as ex:
print(ex)
- 两个目标函数，对一个变量求导
'''两个目标函数，对一个变量求导'''
x = tf.Variable(5.0)
with tf.GradientTape() as tape:
z1 = 3 * x
z2 = x ** 2
tape.gradient([z1,z2],x)
- 求二阶导数，使用嵌套方法实现
'''求二阶导数，使用嵌套方法实现'''
#tensorflow中，自定义求导
x1 = tf.Variable(2.0)
x2 = tf.Variable(3.0)
with tf.GradientTape(persistent = True) as outer_tape:
with tf.GradientTape(persistent = True) as inner_tape:
z = g(x1,x2)
inner_grads = inner_tape.gradient(z,[x1,x2])
outer_grads = [outer_tape.gradient(inner_grad,[x1,x2])
for inner_grad in inner_grads]
print(outer_grads)
del inner_tape
del outer_tape
- 模拟梯度下降法
#模拟梯度下降法
learning_rate = 0.1
x = tf.Variable(0.0)
for _ in range(100):
with tf.GradientTape() as tape:
z = f(x)
dz_dx = tape.gradient(z,x)
x.assign_sub(learning_rate * dz_dx)
print(x)
- GradientTape与optimizer结合
#GradientTape与optimizer结合
learning_rate = 0.1
x = tf.Variable(0.0)
optimizer = keras.optimizers.SGD(lr = learning_rate)
for _ in range(100):
with tf.GradientTape() as tape:
z = f(x)
dz_dx = tape.gradient(z,x)
#x.assign_sub(learning_rate * dz_dx)
optimizer.apply_gradients([(dz_dx,x)])
print(x)
5.3、tf.GradientTape与tf.keras结合使用
手动求导方式，对回归问题的求解
'''回归一下在fit函数中都做过什么'''
# 1.batch 遍历训练集 metric
#1.1 自动求导
# 2.epoch结束 验证集 metric
#遍历训练集
epochs = 100 #遍历100次
batch_size = 32
steps_per_epoch = len(x_train_scaled) // batch_size #训练多少次
optimizer = keras.optimizers.SGD() #优化函数（这里lr使用默认值）
metric = keras.metrics.MeanSquaredError() #均方差损失
#数据如何遍历
def random_batch(x,y,batch_size=32):
idx = np.random.randint(0,len(x),size=batch_size) #随机出32个索引
return x[idx],y[idx] #这里因为是numpy数据 所以idx是个列表，这样y[idx] 对应的就是数据了
#构建模型
model = keras.models.Sequential([
keras.layers.Dense(30,activation='relu',input_shape=x_train.shape[1:]), #这里取8(读取第二维的长度)，因为x_train.shape -> (11610,8)
keras.layers.Dense(1),
])
for epoch in range(epochs):
metric.reset_states()
for step in range(steps_per_epoch):
x_batch,y_batch = random_batch(x_train_scaled,y_train,batch_size) #取出数据
with tf.GradientTape() as tape:
y_pred = model(x_batch) #获取预测值
loss = tf.reduce_mean(keras.losses.mean_squared_error(y_batch,y_pred)) #有预测值之后，计算损失（均方误差）
metric(y_batch,y_pred) #累计计算metric
grads = tape.gradient(loss,model.variables) #求梯度
grads_and_vars = zip(grads,model.variables) #梯度和变量绑定
optimizer.apply_gradients(grads_and_vars) #梯度更新
print("\rEpoch",epoch,"train mse:",metric.result().numpy(),end="") #打印出来
y_valid_pred = model(x_valid_scaled) #验证集验证
valid_loss = tf.reduce_mean(keras.losses.mean_squared_error(y_valid_pred,y_valid))
print("\t","valid mse:",valid_loss.numpy())
其中，后面的for循环替代了之前用到的fit函数
6、章节总结
- 基础API
- 基础API与keras的集成
- 自定义损失函数
- 自定义层次
- @tf.function的使用
- 图结构
- 自定义求导
845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
