MachineLearning入门---第7章---TensorFlow的中阶API(2)

指导教程: https://github.com/lyhue1991/eat_tensorflow2_in_30_days
实际上就是抄的,我已经看不懂这些都是什么东西了, eat_tensorflow2_in_30_days这系列的教程,我准备先停下,等把吴恩达老师的机器学习入门课程啃完,再继续,
现在相当于抄书,停一段时间再抄吧

# -*- coding: utf-8 -*-
import os

import tensorflow as tf
from tensorflow.keras import layers, models, regularizers

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

'''
激活函数:
    激活函数在深度学习中扮演着⾮常᯿要的⻆⾊，它给⽹络赋予了⾮线性，从⽽使得神经⽹络能够拟合任意复杂的函数。
    如果没有激活函数，⽆论多复杂的⽹络，都等价于单⼀的线性变换，⽆法对⾮线性函数进⾏拟合。
    ⽬前，深度学习中最流⾏的激活函数为 relu

常用的激活函数:
    tf.nn.sigmoid： 将实数压缩到0到1之间，⼀般只在⼆分类的最后输出层使⽤。
                        主要缺陷为存在梯度消失问题，计算复杂度⾼，输出不以0为中⼼
    tf.nn.tanh：   将实数压缩到-1到1之间，输出期望为0。
                        主要缺陷为存在梯度消失问题，计算复杂度⾼
    tf.nn.relu：   修正线性单元，最流⾏的激活函数。⼀般隐藏层使⽤。
                        主要缺陷是：输出不以0为中⼼，输⼊⼩于0时存在梯度消失问题(死亡relu)。
    tf.nn.leaky_relu：对修正线性单元的改进，解决了死亡relu问题。
    tf.nn.elu：      指数线性单元。对relu的改进，能够缓解死亡relu问题。
    tf.nn.selu：   扩展型指数线性单元。在权重⽤tf.keras.initializers.lecun_normal初始化前提下能够对神经⽹络进⾏⾃归⼀化。
                    不会出现梯度爆炸或者梯度消失问题。需要和Dropout的变种AlphaDropout⼀起使⽤。
    tf.nn.swish：  ⾃⻔控激活函数。⾕歌出品，相关研究指出⽤swish替代relu将获得轻微效果提升。
    gelu：    ⾼斯误差线性单元激活函数。在Transformer中表现最好。tf.nn模块尚没有实现该函数。
'''


def use_activation():
    # 使用激活函数
    # ⼀般有两种⽅式，⼀种是作为某些层的activation参数指定，
    # 另⼀种是显式添加layers.Activation激活层
    model = tf.keras.models.Sequential()
    model.add(tf.keras.layers.Dense(32, input_shape=(None, 16), activation=tf.nn.relu))  # 通过activation参数指定
    model.add(tf.keras.layers.Dense(10))
    model.add(tf.keras.layers.Activation(tf.nn.softmax))  # 显式添加layers.Activation激活层
    model.summary()


'''
模型层layers
深度学习模型⼀般由各种模型层组合⽽成。
tf.keras.layers内置了⾮常丰富的各种功能的模型层。例如，
    layers.Dense,layers.Flatten,
    layers.Input,layers.DenseFeature,
    layers.Dropout
    layers.Conv2D,
    layers.MaxPooling2D,
    layers.Conv1D
    layers.Embedding,
    layers.GRU,
    layers.LSTM,
    layers.Bidirectional等等。
    
如果这些内置模型层不能够满⾜需求，我们也可以通过编写tf.keras.Lambda匿名模型层或继承
tf.keras.layers.Layer基类构建⾃定义的模型层。
其中tf.keras.Lambda匿名模型层只适⽤于构造没有学习参数的模型层

'''
'''
⼀些常⽤的内置模型层:
基础层:
    Dense：密集连接层。参数个数 = 输⼊层特征数× 输出层特征数(weight)＋ 输出层特征数(bias)
    Activation：激活函数层。⼀般放在Dense层后⾯，等价于在Dense层中指定activation。
    Dropout：随机置零层。训练期间以⼀定⼏率将输⼊置0，⼀种正则化⼿段。
    BatchNormalization：批标准化层。通过线性变换将输⼊批次缩放平移到稳定的均值和标准差。
    可以增强模型对输⼊不同分布的适应性，加快模型训练速度，有轻微正则化效果。⼀般在激活函数
    之前使⽤。
    SpatialDropout2D：空间随机置零层。训练期间以⼀定⼏率将整个特征图置0，⼀种正则化⼿段，
    有利于避免特征图之间过⾼的相关性。
    Input：输⼊层。通常使⽤Functional API⽅式构建模型时作为第⼀层。
    DenseFeature：特征列接⼊层，⽤于接收⼀个特征列列表并产⽣⼀个密集连接层。
    Flatten：压平层，⽤于将多维张量压成⼀维。
    Reshape：形状᯿塑层，改变输⼊张量的形状。
    Concatenate：拼接层，将多个张量在某个维度上拼接。
    Add：加法层。
    Subtract： 减法层。
    Maximum：取最⼤值层。
    Minimum：取最⼩值层。

    
卷积⽹络相关层: 
    Conv1D：普通⼀维卷积，常⽤于⽂本。参数个数 = 输⼊通道数×卷积核尺⼨(如3)×卷积核个数
    Conv2D：普通⼆维卷积，常⽤于图像。参数个数 = 输⼊通道数×卷积核尺⼨(如3乘3)×卷积核个数
    Conv3D：普通三维卷积，常⽤于视频。参数个数 = 输⼊通道数×卷积核尺⼨(如3乘3乘3)×卷积核个数
    SeparableConv2D：⼆维深度可分离卷积层。不同于普通卷积同时对区域和通道操作，
            深度可分离卷积先操作区域，再操作通道。即先对每个通道做独⽴卷即先操作区域，
            再⽤1乘1卷积跨通道组合即再操作通道。参数个数 = 输⼊通道数×卷积核尺⼨ + 输⼊通道数×1×1×输出通道数。
            深度可分离卷积的参数数量⼀般远⼩于普通卷积，效果⼀般也更好。
    DepthwiseConv2D：⼆维深度卷积层。仅有SeparableConv2D前半部分操作，即只操作区域，
            不操作通道，⼀般输出通道数和输⼊通道数相同，
            但也可以通过设置depth_multiplier让输出通道为输⼊通道的若⼲倍数。
            输出通道数 = 输⼊通道数 × depth_multiplier。参数个数 = 输⼊通道数×卷积核尺⼨× depth_multiplier。
    Conv2DTranspose：⼆维卷积转置层，俗称反卷积层。并⾮卷积的逆操作，
            但在卷积核相同的情况下，当其输⼊尺⼨是卷积操作输出尺⼨的情况下，
            卷积转置的输出尺⼨恰好是卷积操作的输⼊尺⼨。
    LocallyConnected2D: ⼆维局部连接层。类似Conv2D，唯⼀的差别是没有空间上的权值共享，
            所以其参数个数远⾼于⼆维卷积。
    MaxPooling2D: ⼆维最⼤池化层。也称作下采样层。池化层⽆参数，主要作⽤是降维。
    AveragePooling2D: ⼆维平均池化层。
    GlobalMaxPool2D: 全局最⼤池化层。每个通道仅保留⼀个值。⼀般从卷积层过渡到全连接层时使⽤，是Flatten的替代⽅案。
    GlobalAvgPool2D: 全局平均池化层。每个通道仅保留⼀个值。
    
循环⽹络相关层:
    Embedding：  嵌⼊层。⼀种⽐Onehot更加有效的对离散特征进⾏编码的⽅法。⼀般⽤于将输⼊中的单词映射为稠密向量。嵌⼊层的参数需要学习。
    LSTM：   ⻓短记忆循环⽹络层。最普遍使⽤的循环⽹络层。具有携带轨道，遗忘⻔，更新⻔，输出⻔。
            可以较为有效地缓解梯度消失问题，从⽽能够适⽤⻓期依赖问题。设置return_sequences =True时可以返回各个中间步骤输出，否则只返回最终输出。
    GRU：    ⻔控循环⽹络层。LSTM的低配版，不具有携带轨道，参数数量少于LSTM，训练速度更快。
    SimpleRNN：  简单循环⽹络层。容易存在梯度消失，不能够适⽤⻓期依赖问题。⼀般较少使⽤。
    ConvLSTM2D： 卷积⻓短记忆循环⽹络层。结构上类似LSTM，但对输⼊的转换操作和对状态的转换操作都是卷积运算。
    Bidirectional：  双向循环⽹络包装器。可以将LSTM，GRU等层包装成双向循环⽹络。从⽽增强特征提取能⼒。
    RNN：    RNN基本层。接受⼀个循环⽹络单元或⼀个循环单元列表，通过调⽤tf.keras.backend.rnn函数在序列上进⾏迭代从⽽转换成循环⽹络层。
    LSTMCell：   LSTM单元。和LSTM在整个序列上迭代相⽐，它仅在序列上迭代⼀步。可以简单理解LSTM即RNN基本层包裹LSTMCell。
    GRUCell：    GRU单元。和GRU在整个序列上迭代相⽐，它仅在序列上迭代⼀步。
    SimpleRNNCell：  SimpleRNN单元。和SimpleRNN在整个序列上迭代相⽐，它仅在序列上迭代⼀步。
    AbstractRNNCell：    抽象RNN单元。通过对它的⼦类化⽤户可以⾃定义RNN单元，再通过RNN基本层的包裹实现⽤户⾃定义循环⽹络层。
    Attention：  Dot-product类型注意⼒机制层。可以⽤于构建注意⼒模型。
    AdditiveAttention：  Additive类型注意⼒机制层。可以⽤于构建注意⼒模型。
    TimeDistributed：    时间分布包装器。包装后可以将Dense、Conv2D等作⽤到每⼀个时间⽚段上。  
    
'''

'''
⾃定义模型层:
    如果⾃定义模型层没有需要被训练的参数，⼀般推荐使⽤Lamda层实现。
    如果⾃定义模型层有需要被训练的参数，则可以通过对Layer基类⼦类化实现。
    Lamda层由于没有需要被训练的参数，只需要定义正向传播逻辑即可，使⽤⽐Layer基类⼦类化更加简单


'''


def diy_layers():
    mypower = layers.Lambda(lambda x: tf.math.pow(x, 2))
    mypower(tf.range(5))


# Layer的子类化一般需要重新实现初始化方法，Build方法和Call方法。下面是一个简化的线性层的范例，类似Dense.
class Linear(layers.Layer):
    def __init__(self, units=32, **kwargs):
        super(Linear, self).__init__(**kwargs)
        self.units = units

    # build方法一般定义Layer需要被训练的参数。
    def build(self, input_shape):
        self.w = self.add_weight("w", shape=(input_shape[-1], self.units),
                                 initializer='random_normal',
                                 trainable=True)  # 注意必须要有参数名称"w",否则会报错
        self.b = self.add_weight("b", shape=(self.units,),
                                 initializer='random_normal',
                                 trainable=True)
        super(Linear, self).build(input_shape)  # 相当于设置self.built = True

    # call方法一般定义正向传播运算逻辑，__call__方法调用了它。
    @tf.function
    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    # 如果要让自定义的Layer通过Functional API 组合成模型时可以被保存成h5模型，需要自定义get_config方法。
    def get_config(self):
        config = super(Linear, self).get_config()
        config.update({'units': self.units})
        return config


def diy_layers2():
    linear = Linear(units=8)
    print(linear.built)
    # 指定input_shape，显式调用build方法，第0维代表样本数量，用None填充
    linear.build(input_shape=(None, 16))
    print(linear.built)

    linear = Linear(units=8)
    print(linear.built)
    linear.build(input_shape=(None, 16))
    print(linear.compute_output_shape(input_shape=(None, 16)))

    linear = Linear(units=16)
    print(linear.built)
    # 如果built = False，调用__call__时会先调用build方法, 再调用call方法。
    linear(tf.random.uniform((100, 64)))
    print(linear.built)
    config = linear.get_config()
    print(config)

    #
    #  下面是啥 我没看懂
    #
    tf.keras.backend.clear_session()
    model = models.Sequential()
    # 注意该处的input_shape会被模型加工，无需使用None代表样本数量维
    model.add(Linear(units=1, input_shape=(2,)))
    print("model.input_shape: ", model.input_shape)
    print("model.output_shape: ", model.output_shape)
    model.summary()

    model.compile(optimizer="sgd", loss="mse", metrics=["mae"])
    print(model.predict(tf.constant([[3.0, 2.0], [4.0, 5.0]])))

    # 保存成 h5模型
    model.save("./data/linear_model.h5", save_format="h5")
    model_loaded_keras = tf.keras.models.load_model(
        "./data/linear_model.h5", custom_objects={"Linear": Linear})
    print(model_loaded_keras.predict(tf.constant([[3.0, 2.0], [4.0, 5.0]])))

    # 保存成 tf模型
    model.save("./data/linear_model", save_format="tf")
    model_loaded_tf = tf.keras.models.load_model("./data/linear_model")
    print(model_loaded_tf.predict(tf.constant([[3.0, 2.0], [4.0, 5.0]])))


# 损失函数losses
'''
    ⼀般来说，监督学习的⽬标函数由损失函数和正则化项组成。（Objective = Loss + Regularization）
    对于keras模型，目标函数中的正则化项一般在各层中指定，例如使用Dense的 kernel_regularizer 和 bias_regularizer等参数指定权重使用l1或者l2正则化项，
    此外还可以用kernel_constraint 和 bias_constraint等参数约束权重的取值范围，这也是一种正则化手段。
    损失函数在模型编译时候指定。对于回归模型，通常使用的损失函数是均方损失函数 mean_squared_error。
    对于二分类模型，通常使用的是二元交叉熵损失函数 binary_crossentropy。
    对于多分类模型，如果label是one-hot编码的，则使用类别交叉熵损失函数 categorical_crossentropy。如果label是类别序号编码的，
    则需要使用稀疏类别交叉熵损失函数 sparse_categorical_crossentropy。
    如果有需要，也可以自定义损失函数，自定义损失函数需要接收两个张量y_true,y_pred作为输入参数，并输出一个标量作为损失函数值。

'''


def loss_funciton():
    # 损失函数和正则化项
    tf.keras.backend.clear_session()

    model = models.Sequential()
    model.add(layers.Dense(64, input_dim=64,
                           kernel_regularizer=regularizers.l2(0.01),
                           activity_regularizer=regularizers.l1(0.01),
                           kernel_constraint=tf.keras.constraints.MaxNorm(max_value=2, axis=0)))
    model.add(layers.Dense(10, kernel_regularizer=regularizers.l1_l2(0.01, 0.01), activation="sigmoid"))
    model.compile(optimizer="rmsprop", loss="binary_crossentropy", metrics=["AUC"])
    model.summary()


'''
内置损失函数
内置的损失函数⼀般有类的实现和函数的实现两种形式。
如：CategoricalCrossentropy 和 categorical_crossentropy 都是类别交叉熵损失函数，前者是类的实现形式，后者是函数的实现形式。
常见的内置损失函数:
    * mean_squared_error（均方误差损失，用于回归，简写为 mse, 类与函数实现形式分别为 MeanSquaredError 和 MSE）
    * mean_absolute_error (平均绝对值误差损失，用于回归，简写为 mae, 类与函数实现形式分别为 MeanAbsoluteError 和 MAE)
    * mean_absolute_percentage_error (平均百分比误差损失，用于回归，简写为 mape, 类与函数实现形式分别为 MeanAbsolutePercentageError 和 MAPE)
    * Huber(Huber损失，只有类实现形式，用于回归，介于mse和mae之间，对异常值比较鲁棒，相对mse有一定的优势)
    * binary_crossentropy(二元交叉熵，用于二分类，类实现形式为 BinaryCrossentropy)
    * categorical_crossentropy(类别交叉熵，用于多分类，要求label为onehot编码，类实现形式为 CategoricalCrossentropy)
    * sparse_categorical_crossentropy(稀疏类别交叉熵，用于多分类，要求label为序号编码形式，类实现形式为 SparseCategoricalCrossentropy)
    * hinge(合页损失函数，用于二分类，最著名的应用是作为支持向量机SVM的损失函数，类实现形式为 Hinge)
    * kld(相对熵损失，也叫KL散度，常用于最大期望算法EM的损失函数，两个概率分布差异的一种信息度量。类与函数实现形式分别为 KLDivergence 或 KLD)
    * cosine_similarity(余弦相似度，可用于多分类，类实现形式为 CosineSimilarity)
    
    # 自定义 损失函数:
    ⾃定义损失函数接收两个张量y_true,y_pred作为输⼊参数，并输出⼀个标量作为损失函数值。
    也可以对tf.keras.losses.Loss进⾏⼦类化，᯿写call⽅法实现损失的计算逻辑，从⽽得到损失函数的类的实现。

'''

if __name__ == '__main__':
    # use_activation()
    # diy_layers2()
    loss_funciton()