[人工智能]Tensorflow2从入门到入土：一些乱七八糟的概念

Keras接口

是支持Keras语法的高级API。Keras是最通用的前端神经网络接口。Tf 中处理使用tf.keras 接口还可以直接使用Keras，pip install keras。这是使用的Keras也会自动变成 TF的后端进行运算。

另外keras集成了数据集（MNIST之类的）可以快速验证模型效果。使用keras 回归一个 y=2x：

import numpy as np
import random
from tensorflow.keras.layers import Dense,Input
from tensorflow.keras.models import Model


# 生成训练数据 y=2x+随机数
x_train = np.linspace(0, 10, 100)  		# 100个数
y_train_random = -1 + 2 * np.random.random(100)  	# -1到1之间的随机数
y_train = 2 * x_train + y_train_random  

# 生成测试数据
x_test = np.linspace(0, 10, 100)  			# 100个数
y_test_random = -1 + 2 * np.random.random(100)  	# -1到1之间的随机数
y_test = 2 * x_test + y_test_random  		# y=2*x +随机数

x_predict = random.sample(range(0,10),10) # 预测10个数，随机排序

# 定义网络层，一个输入层，三个全连接层
inputs = Input(shape=(1,))
x = Dense(64,activation='relu')(inputs)
x = Dense(54,activation='relu')(x)
predictions = Dense(1)(x)

# 编译模型，指定训练参数
model = Model(inputs=inputs, outputs=predictions)
model.compile(optimizer='rmsprop',  # 指定优化器
                loss = 'mse',   # 损失函数为均方差
                metrics=['mae']) # 定义度量为绝对误差均值

# 训练模型，指定超参数
history = model.fit(x_train,y_train,epochs=100,batch_size=16)
# 测试模型
score = model.evaluate(x_test,y_test,batch_size=16)

print("score \n",score)

y_predict = model.predict(x_predict)
print("x_predict \n", x_predict)
print("y_predict \n", y_predict)

搭建了3层的全连接网络，实现回归拟合。整个函数式API 开发的步骤就是:

• 定义网络层
• 调用compile() 编译模型，指定训练参数
• 调用fit() 方法训练模型，指定超参数
• 调用evaluate() 方法测试模型
• 调用predict 对新数据预测。

使用子类模式开发

自定义网络层，可以继承Layer网络层类
步骤：

• 自定义类，继承Layer
• 定义__init__() 初始化方法
• 定义build() 实现权重的计算逻辑
• 定义 call() 编写各层的计算逻辑
• 如果层改变了输入张量的形状，需要定义 compute_output_shape() ，实现形状变换的逻辑

import tensorflow as tf			
import tensorflow.keras
import numpy as np
from tensorflow.keras.layers import Dense, Input, Layer
from tensorflow.keras.models import Model
import random

class MyLayer(Layer):
    # 自定义一个类，继承自Layer
    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)

    # 定义build方法用来创建权重
    def build(self, input_shape):
        shape = tf.TensorShape((input_shape[1], self.output_dim))
        # 定义可训练变量
        self.weight = self.add_weight(name='weight',
                                      shape=shape,
                                      initializer='uniform',
                                      trainable=True)
        super(MyLayer, self).build(input_shape)

    # 实现父类的call方法,实现层功能逻辑
    def call(self, inputs):
        return tf.matmul(inputs, self.weight)

    # 如果层更改了输入张量的形状，需要定义形状变化的逻辑
    def compute_output_shape(self, input_shape):
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.output_dim
        return tf.TensorShape(shape)

    def get_config(self):  # 
        base_config = super(MyLayer, self).get_config()
        base_config['output_dim'] = self.output_dim
        return base_config

    @classmethod
    def from_config(cls, config):
        return cls(**config)

if __name__ == '__main__':
    x_train = np.linspace(0, 10, 100)  		
    y_train_random = -1 + 2 * np.random.random(100)	
    y_train = 2 * x_train + y_train_random  	# y=2*x + 随机数
    print("x_train \n", x_train)
    print("y_train \n", y_train)

    x_test = np.linspace(0, 10, 100)  		
    y_test_random = -1 + 2 * np.random.random(100)
    y_test = 2 * x_test + y_test_random  		# y=2*x + 随机数
    print("x_test \n", x_test)
    print("y_test \n", y_test)

    x_predict = random.sample(range(0, 10), 10)  	# 10个数

    # 定义网络层，一个输入层，三个全连接层
    inputs = Input(shape=(1,))  			# 定义输入张量
    x = Dense(64, activation='relu')(inputs)  	# 第1个全连接层
    x = MyLayer(64)(x)  				# 第2个全连接层，是自定义的层
    predictions = Dense(1)(x)  			# 第3个全连接层

    # 编译模型，指定训练的参数
    model = Model(inputs=inputs, outputs=predictions)
    model.compile(optimizer='rmsprop',  		# 定义优化器
                  loss='mse',  			# 定义损失函数,绝对误差均值
                  metrics=['mae'])  			# 定义度量

    # 训练模型，指定训练超参数
    history = model.fit(x_train,
                        y_train,
                        epochs=100,  			# 50个epochs
                        batch_size=16)  		# 训练的每批数据量

    # 测试模型
    score = model.evaluate(x_test,
                           y_test,
                           batch_size=16)  		# 测试的每批数据量
    # 打印误差值和评估标准值
    print("score \n", score)

    # 模型预测
    y_predict = model.predict(x_predict)
    print("x_predict \n", x_predict)
    print("y_predict \n", y_predict)

保存模型与加载模型

tk.keras 接口保留了 Kears框架中保存模型的格式，生成 .h5 的模型文件，也可以生成TF 检查点格式的文件。

1. 生成和载入 h5 模型文件 ，可以保存整个模型，权重，模型架构，训练配置，优化器和状态（可以再中断的地方重新开始训练）。

model.save("my_model.h5")

del model
model = tf.keras.models.load_model('hhh.h5',custom_objects={'MyLayer':MyLayer})a = model.predict(x_predict)

import h5py
f = h5py.File('my_model.h5')  # 可以调用h5py 解析，比如打印节点名称
for name in f:
	print(name)


model.save_weights('hhh',save_format='h5') # 可以指定格式是h5，还是tf的格式
# 虽然生成的没有后缀，但还是 h5 的格式

但是我们自定义了MyLayer 层，HD5的格式就要改，就是后面两个函数get_config(), from_config：

# 加载模型还需要MyLayer 的定义
new_model = tf.keras.models.load_model('my_model.h5',custom_objects=
											{'MyLayer':MyLayer})
new_model.evaluate(x_test,y_test,batch_size=16)

2. 生成检查点文件。保存权重

model.save_weights('hhh') # 默认生成 ckpt格式的文件
model.load_weights('hhh')

# 保存整个模型，SavedModel格式，包含asset文件夹，变量文件夹，和.pb文件
model.save('saved_model/my_model')
new_model = tf.keras.models.load_model('saved_model/my_model') 

模型与JSON 文件的导入导出

tf的检查点文件包含模型的符号和对应的值，而在Keras框架中生成的 h5 文件，只包含模型的值。

tf.keras接口中，可以将模型符号转换为JSON 文件再保存。

json_string = model.to_json() # 模型json化
open('my_model.json','w').write(json_string)

model = tf.keras.models.model_from_json(open('my_model.json').read())
wodel.load_weights('my_model.h5')
a = model.predict(x_predict)

tf.keras 接口中训练模型的方法

• fit() ，普通训练方法，支持从内存数据，tf.Data.dataset 数据集对象中读取数据进行训练
• fit_generator() ，模型对象的迭代器训练方法。支持从迭代器对象中读取数据进行训练。（fit()也支持了）
• train_on_batch() 模型对象的单次训练方法，相对底层使用时，可以手动在外层构建循环并获得数据，然后送入模型训练。

fit(
    x=None, y=None, batch_size=None, epochs=1, verbose='auto',
    callbacks=None, validation_split=0.0, validation_data=None, shuffle=True,
    class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None,
    validation_steps=None, validation_batch_size=None, validation_freq=1,
    max_queue_size=10, workers=1, use_multiprocessing=False
)

Callbacks() 方法

Callbacks()方法是指在被调用的函数或方法里回调其他函数的计数。即调用函数提供回调函数的实现，由被调函数选择执行的时机。

fit() 方法虽然只有一句，但内部实现了很复杂了流程，设计接口时这种高度封装的方法会提供一个回调的方法，保证使用该接口时的灵活性。比如 fit() 方法的 Callbacks参数，实现训练过程中各环节的控制。

• TensorBoard就是一种callback类，可视化训练，将日志以Web的方式展示
• ModelCheckpoint 类可以在训练过程中保存检查点文件。、

cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,
                                                 save_weights_only=True,
                                                 verbose=1)

# Train the model with the new callback
model.fit(train_images, 
          train_labels,  
          epochs=10,
          validation_data=(test_images, test_labels),
          callbacks=[cp_callback])

• 自定义方法，继承kears.callbacks.Callback类，然后重载对应的成员函数，就可以在指定时机调用方法。

资源分配

1. 指定GPU

import os
os.environ["CUDA_VISIBLE_DEVICES"]="0" # ‘’不使用，0，2，3使用0，2，3序号的卡

# 或者命令中执行时
CUDA_VISIBLE_DEVICES=1 python test.py

2. 指定分配的显存，使用tf.compat.v1.ConfigProto容器里的GPUOptions。
3. 指定语句在哪个设备上运行 with tf.device('/cpu:0')

分布策略

分配运算资源最简单的方式就是使用分布策略，可以自动分配资源

• MirroredStrategy，镜像策略，适用于一机，多卡，将计算任务均匀分配
• CollectiveAllReduceStrategy，集合规约策略，适用于分布训练，多个机器训练一个模型
• ParameterServerStrategy 参数服务器策略，也是多机器训练一个模型，参数服务器来控制每个GPU 的训练参数。

使用方法就是在 model.compile中的distribute参数，传入tf.distribute.MirroredStrategy() 就行，或者传入估算器框架的RunConfig() 方法中

tfdbg 调试TF模型

对TF程序，估算器程序，keras程序进行调试。。。。也不知道有没有用。

自动混合精度加速模型训练

在GPU底层计算的基础上实现的一种加速训练网络的方法，可以提升训练速度，也可以减小训练占的显存。训练过程中，参数和中间结果大多使用单精度浮点数Float32进行存储和计算。当网络很大，使用较低精度的浮点数可以大大提高速度

使用方法：

import os 
os['TF_AUTO_MIXED_PRECISION_GRAPH_REWRITE_IGNORE_PERFORMANCE']=1

optim = tf.train.AdamOptimizer()  # 包装一下优化器
optim = tf.train.experimental.enable_mixed_precision_graph_rewrite(optim)

其他乱七八糟的

win10 清显存，pid通过nvidia-smi 查看
tskill pid


# 复习一下super函数。。hhh
class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），
        # 然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)  # 应该是把父类的那部分直接放到这里
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.