tensorflow 基础API

tensorflow 常量（constant）

创建常量

矩阵创建常量、常量定义类型、定义一个随机数（标量）

t = tf.constant([[1.,2.,3.],[2.,3.,4.]])#矩阵创建常量
#设置类型为int32
zero_vector = tf.zeros(shape=(2), dtype=tf.int32)


# 定义一个随机数（标量）
random_float = tf.random.uniform(shape=())

定义一个有2个元素的零向量、定义两个2×2的常量矩阵

# 定义一个有2个元素的零向量
zero_vector = tf.zeros(shape=(2))

# 定义两个2×2的常量矩阵
A = tf.constant([[1., 2.], [3., 4.]])
B = tf.constant([[5., 6.], [7., 8.]])

0维张量、字符串张量

t = tf.constant(2.718)#0维张量

矩阵操作

举例加法、平方、矩阵相乘、转置

print(t+10)#加法
print(tf.square(t))#平方
print(t @ tf.transpose(t))#矩阵相乘，transpose是矩阵转置

输出矩阵信息

打印矩阵、打印范围行、打印第几行、用numpy输出

print(t)#打印t
print(t[:,1:])#打印后两行
print(t[...,1])#打印第几行
print(t.numpy())#用numpy的方法输出

输出矩阵形状、类型

print(t.shape)      #输出张量形状
print(A.dtype)      # 输出类型

和numpy相互转换

print(t.numpy())#用numpy的方法输出
np_t = np.array([[1.,2.,3.],[4.,5.,6.]])#创建numpy数组
print(tf.constant(np_t))#将numpy转成constant

字符串张量

创建字符串常量、打印字符串常量

t = tf.constant("cafe")#创建字符串常量
t = tf.constant(["cafe","coffee","咖啡"]) #字符串组成的数组
print(t)#打印字符串

获得字符串长度、获得在utf8编码下的长度、将字符串从unicode转换成utf-8

print(tf.strings.length(t))#获得字符串长度
print(tf.strings.length(t, unit = "UTF8_CHAR"))#获得在utf8编码下的长度
print(tf.strings.unicode_decode(t,"UTF8"))#将字符串从unicode转换成utf-8

不等长矩阵、不等长矩阵转换成普通矩阵

# ragged tensor
r = tf.ragged.constant([[1.,2.],[2.,4.,5.],[],[41.]])#不等长矩阵
print(r.to_tensor())#不等长张量转换成普通张量，缺失的地方用0补齐

矩阵拼接

print(tf.concat([r,r2],axis = 0))#纵向拼接
print(tf.concat([r,r2],axis = 1))#横向拼接

创建稀疏矩阵

#sparse tensor
s = tf.SparseTensor(#创建稀疏矩阵
    indices = [[0,1],[1,0],[2,3]],#制定不是零的元素的坐标
    values=[1.,2.,3.],#不是零的元素的值
    dense_shape = [3,4]#矩阵大小
)

将稀疏矩阵转成密集矩阵、和密集矩阵相乘

s6 =tf.sparse.reorder(s) #针对稀疏矩阵未排好序的时候可以执行排序后在输出
print(tf.sparse.to_dense(s6))

print(tf.sparse.to_dense(s))#讲稀疏矩阵转换成密集矩阵
print(tf.sparse.sparse_dense_matmul(s,s4))#和密集矩阵进行矩阵相乘

tensorflow 变量（Variable）

创建变量矩阵

v = tf.Variable([
    [1.,2.,3.],
    [4.,5.,6.]
])

打印变量矩阵、常量引用、numpy输出

print(v)#打印变量矩阵
print(v.value())#打印变量的常量引用
print(v.numpy())#打印numpy形式的输出

变量重赋值

v.assign(2*v)#变量重新赋值
v[0,1].assign(42)#对变量的某个位置赋值
v[1].assign([7.,8.,9.])#对一行进行赋值

自定义损失函数

#自定义损失函数
def customized_mse(y_true,y_pred): 
    return tf.reduce_mean(tf.square(y_pred - y_true)) 
#在下面loss直接等于这个函数就可以使用了

自定义层次（继承）

# 自定义层
class  customizedDenseLayer(keras.layers.Layer):
    def __init__(selff,unit,actication = None,**kwargs):
        self.units = units
        self.activation = keras.layers.Activation(activation)
        super(CustomizedDenseLayer,self).__init__(**kwargs)
    def build (self,input_shape):
        """构建所需要的参数"""
        self.kernel = self.add_weight(
            name = 'kernel',#名字叫什么
            shape = (input_shape[1],self.unis),#形状是什么样的
            initializer = 'uniform',#初始化方式
            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)

自定义层次（lambda）

#用lambda实现定义层
customized_softplus = keras.layers.Lambda(lambda x : tf.nn.softplus(x))#传入一个lambda表达式

打印层信息

打印layers所有参数、打印可训练参数、查看layer的方法和参考

layer.variables#打印layer中的所有参数
layer.trainable_variables#获得所有的可训练的变量
help(layer)#查看layer的方法和参考

tf.function()

#tf.function and auto-graph
def scaled_elu(z,scale=1.0,alpha=1.0):
    is_positive = tf.greater_equal(z, 0.0)
    return scale * tf.where(is_positive, z, alpha * tf.nn.elu(z))
scaled_elu_tf = tf.function(scaled_elu)#用function方法将python函数转换成tf图结构

print(scaled_elu_tf.python_function is scaled_elu )#用python_function方法取得原来的python函数

@tf.function

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


#tf.Variable不能定义在function里
var = tf.Variable(0.)
@tf.function
def add_21():
    return var.assign_add(21) #+=
print(add_21())


#在正常的函数里输入什么类型就会输出什么类型
@tf.function
def cube(z):
    return tf.pow(z, 3)
print(cube(tf.constant([1.,2.,3.])))
print(cube(tf.constant([1,2,3])))

签名函数

@tf.function(input_signature = [tf.TensorSpec([None],#必须是tf类型
                                                                   tf.int32,#必须是什么类型
                                                                   name = 'x')])#起了个名字
def cube(z):
    return tf.pow(z, 3)
print(cube(tf.constant([1.,2.,3.])))

展示@tf.function生成的tensorflow代码

def display_tf_code(func):
    code = tf.autograph.to_code(func)
    from ipython.display import display, Markdown
    display(Markdown('```python\n{}\n```'.format(code)))
display_tf_code(scaled_elu)

转换成图结构

cube_func_int32 = cube.get_concrete_function(
    tf.TensorSpec([None],tf.int32)#None那个方块里填写数字也可以
)
print(cube_func_int32)

转换图

cube_func_int32.graph

得到图结构里的所有操作

cube_func_int32.graph.get_operations()

打印图结构里的操作

pow_op = cube_func_int32.graph.get_operations()[2]
print(pow_op)

打印操作输入输出

print(list(pow_op.inputs))
print(list(pow_op.outputs))

通过名字获取tenser

cube_func_int32.graph.get_tensor_by_name("z:0")#一般在名字后面加个：0

打印所有节点信息

cube_func_int32.graph.as_graph_def()

自动求导

import tensorflow as tf

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

自动求偏导

x1 = tf.Variable(2.0)
x2 = tf.Variable(3.0)
def g(x1,x2):
    return (x1+5) * (x2**2)
with tf.GradientTape(persistent=True) as tape:#persistent=True是保存结果tape可以多次调用false就只能调用一次
    z = g(x1,x2)
dz_x1 = tape.gradient(z,x1)#输入（结果/哪个变量）获取导数
dz_x2 = tape.gradient(z,x2)#输入（结果/哪个变量）获取导数
del tape
print(dz_x1)
print(dz_x2)

#或者
x1 = tf.Variable(2.0)
x2 = tf.Variable(3.0)
def g(x1,x2):
    return (x1+5) * (x2**2)
with tf.GradientTape(persistent=True) as tape:#persistent=True是保存结果tape可以多次调用false就只能调用一次
    z = g(x1,x2)
dz = tape.gradient(z,[x1,x2])#输入（结果/哪个变量）获取导数
del tape
print(dz)

自定义求偏导（常量模式）

#自定义求偏导(常量模式)
x1 = tf.constant(2.0)
x2 = tf.constant(3.0)
def g(x1,x2):
    return (x1+5) * (x2**2)
with tf.GradientTape(persistent=True) as tape:#persistent=True是保存结果tape可以多次调用false就只能调用一次
    tape.watch(x1)#对常量求导必须关注这个变量
    tape.watch(x2)#对常量求导必须关注这个变量
    z = g(x1,x2)
dz = tape.gradient(z,[x1,x2])#输入（结果/哪个变量）获取导数
del tape
print(dz)

多个目标函数对一个变量求导

x = tf.Variable(5.0)
with tf.GradientTape() as tape:#persistent=True是保存结果tape可以多次调用false就只能调用一次
    z1 = 3 *x
    z2 = x ** 2
dz = tape.gradient([z1,z2],x)#输入（结果/哪个变量）获取导数
print(dz)#输出是变量对两个函数的导数相加

二阶求导

#求二阶导数
x1 = tf.Variable(2.0)
x2 = tf.Variable(3.0)
def g(x1,x2):
    return (x1+5) * (x2**2)
with tf.GradientTape(persistent=True) as outer_tape:#persistent=True是保存结果tape可以多次调用false就只能调用一次
    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]
del outer_tape,inner_tape
print(outer_grads)

模拟梯度下降

#模拟梯度下降
learning_rate = 0.1
x = tf.Variable(1.0)
def f (x):
    return x*x
for i 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)

keras优化器与求导结合实现梯度下降

#keras优化器与求导结合实现梯度下降
learning_rate = 0.1
x = tf.Variable(1.0)
def f (x):
    return x*x
optimizer = keras.optimizers.SGD(lr = learning_rate)#调用keras里的模型优化器的方法
for i in range(100):
    with tf.GradientTape() as tape:
        z = f(x)
    dz_dx = tape.gradient(z,x)
    optimizer.apply_gradients([(dz_dx,x),])#传入是个列表，么个元素是个元组，元组中导数在前，变量在后
print(x)

线性回归

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=1e-3)
for e in range(num_epoch):
    # 使用tf.GradientTape()记录损失函数的梯度信息
    with tf.GradientTape() as tape:
        y_pred = a * X + b
        loss = 0.5 * tf.reduce_sum(tf.square(y_pred - y))
    # TensorFlow自动计算损失函数关于自变量（模型参数）的梯度
    grads = tape.gradient(loss, variables)
    # TensorFlow自动根据梯度更新参数
    optimizer.apply_gradients(grads_and_vars=zip(grads, variables))

print(a, b)

自定义fit函数

#自定义fit函数
epochs = 100#训练多少轮
batch_size = 32#每一次训练的数据量
steps_per_epoch = len(x_train_scaled) // batch_size#应该训练多少次
optimizer = keras.optimizers.SGD()#定义优化器
metric = keras.metrics.MeanSquaredError()#定义损失函数

def random_batch(x,y,batch_size = 32):#定义取数据的方法
    idx = np.random.randint(0, len(x),size = batch_size)
    return x[idx] , y[idx]

model = keras.models.Sequential([#定义模型
    keras.layers.Dense(30, activation = 'relu',
                      input_shape= x_train.shape[1:]),
    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)
        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())