神经网络迁移学习以及神经网络中间的各种参数（优化器，学习率，正则化）

        迁移学习：本质上是重用预训练层，是通过类似的已经训练过的模型进行重组。

        目的：使用迁移学习，使用部分已经存在的模型，这样子可以增加训练速度与减少参数的训练量，这里利用的是已存在的模型的权重这一信息。

        注意：如果两个model之间有共享层的话，当一个model的参数改变，那么会影响另一个model的权重，可以通过clone_model进行操作。

keras.clone_model(),clone.set_weights(model.get_weights())

        在迁移模型时，由于一开始是随机权重，所欲将迁移层的权重进行冻结，使用layer.trainable=False。这是为了防止反向传播对迁移的权重有大更改。在训练了几次之后，解冻迁移层，应该降低学习率，防止权重发生更改（这里需要再次编译与训练）。

import tensorflow as tf
from tensorflow import keras
(X_train_full, y_train_full), (X_test, y_test) = keras.datasets.fashion_mnist.load_data()
X_train_full = X_train_full / 255.0
X_test = X_test / 255.0
X_valid, X_train = X_train_full[:5000], X_train_full[5000:]
y_valid, y_train = y_train_full[:5000], y_train_full[5000:]
import numpy as np
def split_dataset(X, y):
    y_5_or_6 = (y == 5) | (y == 6) # sandals or shirts
    y_A = y[~y_5_or_6]
    y_A[y_A > 6] -= 2 # class indices 7, 8, 9 should be moved to 5, 6, 7
    y_B = (y[y_5_or_6] == 6).astype(np.float32) # binary classification task: is it a shirt (class 6)?
    return ((X[~y_5_or_6], y_A),
            (X[y_5_or_6], y_B))
 
(X_train_A, y_train_A), (X_train_B, y_train_B) = split_dataset(X_train, y_train)
(X_valid_A, y_valid_A), (X_valid_B, y_valid_B) = split_dataset(X_valid, y_valid)
(X_test_A, y_test_A), (X_test_B, y_test_B) = split_dataset(X_test, y_test)
X_train_B = X_train_B[:200]
y_train_B = y_train_B[:200]

model_A = keras.models.Sequential()
model_A.add(keras.layers.Flatten(input_shape=[28, 28]))
for n_hidden in (300, 100, 50, 50, 50):
    model_A.add(keras.layers.Dense(n_hidden, activation="selu"))
model_A.add(keras.layers.Dense(8, activation="softmax"))
model_A.compile(loss="sparse_categorical_crossentropy",
                optimizer=keras.optimizers.SGD(learning_rate=1e-3),
                metrics=["accuracy"])
history = model_A.fit(X_train_A, y_train_A, epochs=20,
                    validation_data=(X_valid_A, y_valid_A))
model_A.save("my_model_A.h5")

model_B = keras.models.Sequential()
model_B.add(keras.layers.Flatten(input_shape=[28, 28]))
for n_hidden in (300, 100, 50, 50, 50):
    model_B.add(keras.layers.Dense(n_hidden, activation="selu"))
model_B.add(keras.layers.Dense(1, activation="sigmoid"))
model_B.compile(loss="binary_crossentropy",
                optimizer=keras.optimizers.SGD(learning_rate=1e-3),
                metrics=["accuracy"])
history = model_B.fit(X_train_B, y_train_B, epochs=20,
                      validation_data=(X_valid_B, y_valid_B))

进行模型的迁移，冻结迁移层。

model_a = keras.models.load_model('my_model_A.h5')
model_b_on_a = keras.models.Sequential(model_a.layers[:-1])
model_b_on_a.add(keras.layers.Dense(1,activation='sigmoid'))
for layer in model_b_on_a.layers[:-1]:
    layer.trainable=False
model_b_on_a.compile(loss='binary_crossentropy',optimizer='sgd',metrics=['accuracy'])
history =model_b_on_a.fit(X_train_B,y_train_B,epochs=4,validation_data=[X_valid_B,y_valid_B])

解冻重用层后，建议降低学习率，放置反向传播对全中的更改

for layer in model_b_on_a.layers[:-1]:
    layer.trainable=True
optimizer=keras.optimizers.SGD(lr=1e-4)
model_b_on_a.compile(loss='binary_crossentropy',optimizer=optimizer,metrics=['accuracy'])
history=model_b_on_a.fit(X_train_B,y_train_B,epochs=16,validation_data=[X_valid_B,y_valid_B])
model_b_on_a.evaluate(X_test_B,y_test_B)

        更快的优化器

        1.动量优化

        相比于梯度下降，动量优化的速度更快，相比于梯度下降的公式，有一个动量向量，它积攒了历史的梯度，同时还存在一个b参数，它的目的是防止动量过大。

keras.optimizers.SGD(lr=0.0001,momentum=0.9)

        2.Nesterov加速梯度

        Nesterov使梯度一直想着动量方向，而动量方向一直会直线正确方向。

keras.optimizers.SGD(lr=0.0001,momentum=0.9,nesterov=True)

        3.AdaGrad

        通过遮掩最陡峭的维度，按照比例进行缩小梯度来进行校正。一个公式是让维度维度影响更加明显，另一个是将向量等比例缩小。它会使学习率降低，但是对陡峭的维度进行突显，相比于梯度下降，速度更快，但是会导致停止过早。

        4.RMSprop

        通过累加最近的迭代中的梯度。

keras.optimizers.RMSprop(lr=0.001,rho=0.9)

        5.Adam与Nadam

        Adam自适应矩估计，它结合了动量估计与RMSprop，是通过动量优化与比例缩放。

keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999)

        而Nadam是Nesterov与Adam的结合。

        学习率的调整。

        有幂调整，指数调整，分段恒定调整，性能调整与周期调整。

##幂调度
keras.optimizers.SGD(learning_rate=0.01,decay=1e-4)

##指数调度
def exponential_decay_fn(epoch):
    return 0.01*0.1**(epoch/20)

##性能调度
keras.callbacks.ReduceLROnPlateau(factor=0.5,patience=5)

##周期调整
s = 20*(len(X_train))
learning_rate = keras.optimizers.schedules.ExponentialDecay(0.01,s,0.1)
keras.optimizers.SGD(learning_rate)

        对于性能调整的解释：factor为降低率，而patience为等待次数，如果验证误差没有改变，那么等待次数之后，那么学习率下降。

        通过正则化避免过拟合

        1.L1,L2正则化

        L1正则化作用于稀疏模型，L2正则化用于约束神经网络权重，在keras.layers.Dense()中的kernel_regularizer=()中进行设置。kernel_regularizers.l1/l2/l1_l2()

##l1,l2正则化
keras.layers.Dense(10,activation='relu',
                  kernel_initializer='he_normal',
                  kernel_regularizer =keras.regularizers.l2(0.01))

         2.functools.partial

        这个方法可以让所有隐藏层，使用相同的激活函数，初始化以及正则化，进行包装。

from functools import partial
layers = partial(keras.layers.Dense,activation = 'elu',
                kernel_initializer='he_normal',
                kernel_regularizer=keras.regularizers.l2(0.01))
model =keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28,28]),
    layers(300),
    layers(100)
])

         3.dropout

        将隐藏层中的一些神经元暂时忽略，在实践中通常只能对一到三层的神经元进行应用，dropout只在训练期间激活。当过拟合，那么应该提高dropout，如果欠拟合，那么降低dropout。

layer=partial(keras.layers.Dense,activation='elu',kernel_initializer='he_normal')
model=keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28,28]),
    layer(300),
    keras.layers.Dropout(rate=0.2),
    layer(100),
    keras.layers.Dropout(rate=0.2),
    keras.layers.Dense(10,activation='softmax')
])

        4.MCdropout

        对具有dropout功能的多个预测进行平均。

Class MCDropout(keras.layers.Dropout):
    def call(self,inputs):
        return super().call(inputs,training=Ture)

         5.最大范数正则化

        设置一个最大范数超参数。

keras.layers.Dense(kernel_constraint=keras.constraint.max_norm(1.0))