tensorboard

writer=tf.summary.FileWriter('/path/to/logs', tf.get_default_graph())
writer.close()

在上面程序的8、9行中侦鹏，創(chuàng)建一個writer俊抵，將tensorboard summary寫入文件夾/path/to/logs册赛，
然后運行上面的程序钠导，在程序定義的日志文件夾/path/to/logs目錄下，生成了一個新的日志文件events.out.tfevents.1524711020.bdi-172森瘪，
tensorboard –logdir /path/to/logs

https://blog.csdn.net/fendouaini/article/details/80344591
https://blog.csdn.net/fendouaini/article/details/80368770

cb.append(keras.callbacks.TensorBoard(
log_dir=os.path.join(logs_path, 'TensorBoard'),
histogram_freq=0, 
write_graph=True, 
write_grads=False, 
write_images=False,
embeddings_freq=0, 
embeddings_layer_names=None, 
embeddings_metadata=None, 
embeddings_data=None, 
update_freq='epoch'))

該類在keras.callbacks模塊中牡属。它的參數(shù)列表如下：

• log_dir: 用來保存被 TensorBoard 分析的日志文件的文件名。
• histogram_freq:對于模型中各個層計算激活值和模型權重直方圖的頻率（訓練輪數(shù)中扼睬。 該參數(shù)用于設置tensorboard面板中的histograms和distributions面板如果設置成 0 逮栅，直方圖不會被計算悴势。對于直方圖可視化的驗證數(shù)據（或分離數(shù)據）一定要明確的指出。
• write_graph: 是否在 TensorBoard 中可視化圖措伐。 如果 write_graph 被設置為 True特纤。

• write_grads: 是否在 TensorBoard 中可視化梯度值直方圖。 histogram_freq 必須要大于 0 侥加。

  
  
• batch_size: 用以直方圖計算的傳入神經元網絡輸入批的大小捧存。

• write_images: 是否在 TensorBoard 中將模型權重以圖片可視化，如果設置為True担败，日志文件會變得非常大昔穴。

  
  
• embeddings_freq: 被選中的嵌入層會被保存的頻率（在訓練輪中）。
• embeddings_layer_names: 一個列表提前，會被監(jiān)測層的名字吗货。 如果是 None 或空列表，那么所有的嵌入層都會被監(jiān)測狈网。
• embeddings_metadata: 一個字典卿操，對應層的名字到保存有這個嵌入層元數(shù)據文件的名字。 查看 詳情 關于元數(shù)據的數(shù)據格式孙援。 以防同樣的元數(shù)據被用于所用的嵌入層，字符串可以被傳入扇雕。
• embeddings_data: 要嵌入在 embeddings_layer_names 指定的層的數(shù)據拓售。 Numpy 數(shù)組（如果模型有單個輸入）或 Numpy 數(shù)組列表（如果模型有多個輸入）。 Learn ore about embeddings镶奉。
• update_freq: 'batch' 或 'epoch' 或 整數(shù)础淤。當使用 'batch' 時，在每個 batch 之后將損失和評估值寫入到 TensorBoard 中哨苛。同樣的情況應用到 'epoch' 中鸽凶。如果使用整數(shù)，例如 10000建峭，這個回調會在每 10000 個樣本之后將損失和評估值寫入到 TensorBoard 中玻侥。注意，頻繁地寫入到 TensorBoard 會減緩你的訓練亿蒸。

自己定義在tensorboard中顯示acc和loss

import numpy as np
 
import tensorflow as tf
 
from keras.models import Sequential  # 采用貫序模型
from keras.layers import Input, Dense, Dropout, Activation,Conv2D,MaxPool2D,Flatten
from keras.optimizers import SGD
from keras.datasets import mnist
from keras.utils import to_categorical
from keras.callbacks import TensorBoard
 
 
def create_model():
    model = Sequential()
    model.add(Conv2D(32, (5,5), activation='relu', input_shape=[28, 28, 1])) 
    model.add(Conv2D(64, (5,5), activation='relu'))                          
    model.add(MaxPool2D(pool_size=(2,2)))                                    #池化層
    model.add(Flatten())                                                     #平鋪層
    model.add(Dropout(0.5))
    model.add(Dense(128, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(10, activation='softmax'))
 
    return model
 
def compile_model(model):
    model.compile(loss='categorical_crossentropy', optimizer="adam",metrics=['acc']) 
    return model
 
def train_model(model,x_train,y_train,x_val,y_val,batch_size=128,epochs=10):
    train_loss = tf.placeholder(tf.float32, [],name='train_loss') 
    train_acc = tf.placeholder(tf.float32, [],name='train_acc') 
    val_loss = tf.placeholder(tf.float32, [],name='val_loss') 
    val_acc = tf.placeholder(tf.float32, [],name='val_acc') 
    
    #可視化訓練集凑兰、驗證集的loss、acc边锁、四個指標姑食，均是標量scalers
    tf.summary.scalar("train_loss", train_loss) 
    tf.summary.scalar("train_acc", train_acc)
    tf.summary.scalar("val_loss", val_loss)
    tf.summary.scalar("val_acc", val_acc)
  
    merge=tf.summary.merge_all()
 
    batches=int(len(x_train)/batch_size)  #沒一個epoch要訓練多少次才能訓練完樣本
 
    with tf.Session() as sess:
        logdir = './logs'
        writer = tf.summary.FileWriter(logdir, sess.graph) 
 
        for epoch in range(epochs): #用keras的train_on_batch方法進行訓練 
            print(F"正在訓練第 {epoch+1} 個 epoch")
            for i in range(batches):
                #每次訓練128組數(shù)據
                train_loss_,train_acc_ = model.train_on_batch(x_train[i*128:(i+1)*128:1,...],y_train[i*128:(i+1)*128:1,...]) 
            #驗證集只需要每一個epoch完成之后再驗證即可
            val_loss_,val_acc_ = model.test_on_batch(x_val,y_val) 
 
            summary=sess.run(merge,feed_dict={train_loss:train_loss_,train_acc:train_acc_,val_loss:val_loss_,val_acc:val_acc_})
            writer.add_summary(summary,global_step=epoch)
 
 
 
if __name__=="__main__":
    (x_train,y_train),(x_test,y_test) = mnist.load_data()  #數(shù)據我已經下載好了
    print(np.shape(x_train),np.shape(y_train),np.shape(x_test),np.shape(y_test))  #(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)
 
    x_train=np.expand_dims(x_train,axis=3)
    x_test=np.expand_dims(x_test,axis=3)
    y_train=to_categorical(y_train,num_classes=10)
    y_test=to_categorical(y_test,num_classes=10)
    print(np.shape(x_train),np.shape(y_train),np.shape(x_test),np.shape(y_test)) #(60000, 28, 28, 1) (60000, 10) (10000, 28, 28, 1) (10000, 10)
 
    x_train_=x_train[1:50000:1,...]    #重新將訓練數(shù)據分成訓練集50000組
    x_val_=x_train[50000:60000:1,...]  #重新將訓練數(shù)據分成測試集10000組
    y_train_=y_train[1:50000:1,...]
    y_val_=y_train[50000:60000:1,...]
    print(np.shape(x_train_),np.shape(y_train_),np.shape(x_val_),np.shape(y_val_),np.shape(x_test),np.shape(y_test))
    #(49999, 28, 28, 1) (49999, 10) (10000, 28, 28, 1) (10000, 10) (10000, 28, 28, 1) (10000, 10)
    
    model=create_model()       #創(chuàng)建模型      
 
    model=compile_model(model) #編譯模型
 
    train_model(model,x_train_,y_train_,x_val_,y_val_)

可視化

模型可視化

from keras.utils import plot_model
keras.utils.plot_model(model, to_file='model.png', show_shapes='Ture', dpi=200)

訓練歷史可視化

import matplotlib.pyplot as plt
history = model.fit(x, y, validation_split=0.25, epochs=50, batch_size=16, verbose=1)
# 繪制訓練 & 驗證的準確率值
plt.plot(history.history['acc'])

學習率調整

import keras.backend as K
from keras.callbacks import LearningRateScheduler
 
def lr_scheduler(epoch):
    initial_lrate = 0.1
    drop = 0.5
    epochs_drop = 10.0
    lrate = initial_lrate * math.pow(drop, math.floor((1+e )/epochs_drop))
    return lrate
-------------------------------------------------------------------------
    # 每隔2個epoch，學習率減小為原來的1/10
    if epoch % 2 == 0 and epoch != 0:
        lr = K.get_value(model.optimizer.lr)
        K.set_value(model.optimizer.lr, lr * 0.1)
        print("lr changed to {}".format(lr * 0.1))
    return K.get_value(model.optimizer.lr)
 
reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
model.fit(train_x, train_y, batch_size=32, epochs=300, callbacks=[reduce_lr])

from keras.callbacks import ReduceLROnPlateau
reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=2, mode='auto')
model.fit(train_x, train_y, batch_size=32, epochs=300, validation_split=0.1, callbacks=[reduce_lr])

keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0,, min_delta=0.0001,mode='auto', epsilon=0.0001, cooldown=0, min_lr=0)
monitor：被監(jiān)測的量
factor：每次減少學習率的因子茅坛，學習率將以lr = lr*factor的形式被減少
patience：當patience個epoch過去而模型性能不提升時音半，學習率減少的動作會被觸發(fā)
min_delta: 增大或減小的閾值。
mode：‘auto’，‘min’曹鸠，‘max’之一煌茬，在min模式下，如果檢測值觸發(fā)學習率減少物延。在max模式下宣旱，當檢測值不再上升則觸發(fā)學習率減少。
epsilon：閾值叛薯，用來確定是否進入檢測值的“平原區(qū)”
cooldown：學習率減少后浑吟，會經過cooldown個epoch才重新進行正常操作會經過cooldown個epoch才會重新計算被監(jiān)控的指標沒有提高(或者減少)的輪次(即patience).設置這個參數(shù)是因為減少學習率時, 模型的損失函數(shù)可能不在最優(yōu)解附近,而訓練至最優(yōu)解附近需要一定輪次, 如果不設置則會導致學習率在遠離最優(yōu)解時接連衰減導致訓練陷入僵局
min_lr：學習率的下限

tf.keras.layers中網絡配置：

• activation：設置層的激活函數(shù)。此參數(shù)由內置函數(shù)的名稱指定耗溜，或指定為可調用對象组力。默認情況下，系統(tǒng)不會應用任何激活函數(shù)抖拴。

• kernel_initializer 和 bias_initializer：創(chuàng)建層權重（核和偏差）的初始化方案燎字。此參數(shù)是一個名稱或可調用對象，默認為 "Glorot uniform" 初始化器阿宅。

random_uniform：初始化權重為（-0.05候衍，0.05）之間的均勻隨機的微小數(shù)值。換句話說洒放，給定區(qū)間里的任何值都可能作為權重蛉鹿。
random_normal：根據高斯分布初始化權重，平均值為0往湿，標準差為0.05妖异。如果你不熟悉高斯分布，可以回想一下對稱鐘形曲線领追。
zero：所有權重初始化為0他膳。

• kernel_regularizer 和 bias_regularizer：應用層權重（核和偏差）的正則化方案，例如 L1 或 L2 正則化绒窑。默認情況下棕孙，系統(tǒng)不會應用正則化函數(shù)。

• 我們也可以得到網絡的變量些膨、權重矩陣散罕、偏置等
  print(layer.variables) # 包含了權重和偏置
print(layer.kernel, layer.bias) # 也可以分別取出權重和偏置

  layers.Dense(32, activation='sigmoid')
  layers.Dense(32, activation=tf.sigmoid)
  layers.Dense(32, kernel_initializer='orthogonal')
  layers.Dense(32, kernel_initializer=tf.keras.initializers.glorot_normal)
  layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l2(0.01))
  layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l1(0.01))
  

metric評估

• 1)accuracy
  如我們有6個樣本，其真實標簽y_true為[0, 1, 3, 3, 4, 2]傀蓉，但被一個模型預測為了[0, 1, 3, 4, 4, 4]欧漱，即y_pred=[0, 1, 3, 4, 4, 4]，那么該模型的accuracy=4/6=66.67%葬燎。
• 2)binary_accuracy
  它適用于2分類的情況误甚。從上圖中可以看到binary_accuracy的計算除了y_true和y_pred外缚甩，還有一個threshold參數(shù)，該參數(shù)默認為0.5窑邦。比如有6個樣本擅威，其y_true為[0, 0, 0, 1, 1, 0]，y_pred為[0.2, 0.3, 0.6, 0.7, 0.8, 0.1].具體計算方法為：1）將y_pred中的每個預測值和threshold對比冈钦，大于threshold的設為1郊丛，小于等于threshold的設為0，得到y(tǒng)_pred_new=[0, 0, 1, 1, 1, 0]瞧筛；2）將y_true和y_pred_new代入到2.1中計算得到最終的binary_accuracy=5/6=87.5%厉熟。
• 3)categorical_accuracy
  針對的是y_true為onehot標簽，y_pred為向量的情況较幌。比如有4個樣本揍瑟，其y_true為[[0, 0, 1], [0, 1, 0], [0, 1, 0], [1, 0, 0]]，y_pred為[[0.1, 0.6, 0.3], [0.2, 0.7, 0.1], [0.3, 0.6, 0.1], [0.9, 0, 0.1]]乍炉。具體計算方法為：1）將y_true轉為非onehot的形式绢片，即y_true_new=[2, 1, 1, 0]；2）根據y_pred中的每個樣本預測的分數(shù)得到y(tǒng)_pred_new=[1, 1, 1, 0]岛琼；3）將y_true_new和y_pred_new代入到2.1中計算得到最終的categorical_accuracy=75%底循。
• 4)sparse_categorical_accuracy
  和categorical_accuracy功能一樣，只是其y_true為非onehot的形式槐瑞。比如有4個樣本此叠，其y_true為[2， 1随珠， 1， 0]猬错，y_pred為[[0.1, 0.6, 0.3], [0.2, 0.7, 0.1], [0.3, 0.6, 0.1], [0.9, 0, 0.1]]窗看。具體計算方法為：1）根據y_pred中的每個樣本預測的分數(shù)得到y(tǒng)_pred_new=[1, 1, 1, 0]；2）將y_true和y_pred_new代入到2.1中計算得到最終的categorical_accuracy=75%倦炒。
• 5)top_k_categorical_accuracy
  在categorical_accuracy的基礎上加上top_k显沈。categorical_accuracy要求樣本在真值類別上的預測分數(shù)是在所有類別上預測分數(shù)的最大值，才算預測對逢唤，而top_k_categorical_accuracy只要求樣本在真值類別上的預測分數(shù)排在其在所有類別上的預測分數(shù)的前k名就行拉讯。比如有4個樣本，其y_true為[[0, 0, 1], [0, 1, 0], [0, 1, 0], [1, 0, 0]]鳖藕，y_pred為[[0.3, 0.6, 0.1], [0.5, 0.4, 0.1], [0.3, 0.6, 0.1], [0.9, 0, 0.1]]魔慷。具體計算方法為：1）將y_true轉為非onehot的形式，即y_true_new=[2, 1, 1, 0]著恩；2）計算y_pred的top_k的label院尔，比如k=2時蜻展，y_pred_new = [[0, 1], [0, 1], [0, 1], [0, 2]]；3）根據每個樣本的真實標簽是否在預測標簽的top_k內來統(tǒng)計準確率邀摆，上述4個樣本為例纵顾，2不在[0, 1]內，1在[0, 1]內栋盹，1在[0, 1]內施逾，0在[0, 2]內，4個樣本總共預測對了3個例获，因此k=2時top_k_categorical_accuracy=75%汉额。說明一下，Keras中計算top_k_categorical_accuracy時默認的k值為5躏敢。
• 6)sparse_top_k_categorical_accuracy
  和top_k_categorical_accuracy功能一樣闷愤，只是其y_true為非onehot的形式。比如有4個樣本件余，其y_true為[2讥脐， 1， 1啼器， 0]旬渠，y_pred為[[0.3, 0.6, 0.1], [0.5, 0.4, 0.1], [0.3, 0.6, 0.1], [0.9, 0, 0.1]]。計算步驟如下：1）計算y_pred的top_k的label端壳，比如k=2時告丢，y_pred_new = [[0, 1], [0, 1], [0, 1], [0, 2]]；2）根據每個樣本的真實標簽是否在預測標簽的top_k內來統(tǒng)計準確率损谦，上述4個樣本為例岖免，2不在[0, 1]內，1在[0, 1]內照捡，1在[0, 1]內颅湘，0在[0, 2]內，4個樣本總共預測對了3個栗精，因此k=2時top_k_categorical_accuracy=75%闯参。

ROC,AUC

import tensorflow as tf
from sklearn.metrics import roc_auc_score

def auroc(y_true, y_pred):
    return tf.py_func(roc_auc_score, (y_true, y_pred), tf.double)

# Build Model...

model.compile(loss='categorical_crossentropy', optimizer='adam',metrics=['accuracy', auroc])
--------------------------------------------------------------------------------
class RocAucEvaluation(Callback):
    def __init__(self, validation_data=(), interval=1):
        super(Callback, self).__init__()
        self.interval = interval
        self.x_val,self.y_val = validation_data
    def on_epoch_end(self, epoch, log={}):
        if epoch % self.interval == 0:
            y_pred = self.model.predict_proba(self.x_val, verbose=0)
            score = roc_auc_score(self.y_val, y_pred)
            print('\n ROC_AUC - epoch:%d - score:%.6f \n' % (epoch+1, score))
x_train, x_val, y_train, y_val = train_test_split(x_train_nn, y_train_nn, train_size=0.9, random_state=233)

RocAuc = RocAucEvaluation(validation_data=(y_train,y_label), interval=1)
hist = model.fit(x_train, x_label, batch_size=batch_size, epochs=epochs, validation_data=(y_train, y_label), callbacks=[RocAuc], verbose=2)

訓練

對.fit的調用在這里做出兩個主要假設：
我們的整個訓練集可以放入RAM
沒有數(shù)據增強（即不需要Keras生成器）

真實世界的數(shù)據集通常太大而無法放入內存中
它們也往往具有挑戰(zhàn)性，要求我們執(zhí)行數(shù)據增強以避免過擬合并增加我們的模型的泛化能力
在這些情況下悲立，我們需要利用Keras的.fit_generator函數(shù)：

# initialize the number of epochs and batch size
EPOCHS = 100
BS = 32
# construct the training image generator for data augmentation
aug = ImageDataGenerator(rotation_range=20, zoom_range=0.15,
    width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15,
    horizontal_flip=True, fill_mode="nearest")
# train the network
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
    validation_data=(testX, testY), steps_per_epoch=len(trainX) // BS,
    epochs=EPOCHS)

對于尋求對Keras模型進行精細控制（ finest-grained control）的深度學習實踐者鹿寨，您可能希望使用.train_on_batch例如數(shù)據迭代過程非常復雜并且需要自定義代碼。

模型評估

print(model.evaluate(x_test,y_test))

y = model.predict_classes(x_test)
print(accuracy_score(y_test,y))

構建高級模型

• 模型子類化

通過對 tf.keras.Model 進行子類化并定義您自己的前向傳播來構建完全可自定義的模型薪夕。在 init 方法中創(chuàng)建層并將它們設置為類實例的屬性脚草。在 call 方法中定義前向傳播

class MyModel(tf.keras.Model):
    def __init__(self, num_classes=10):
        super(MyModel, self).__init__(name='my_model')
        self.num_classes = num_classes
        self.layer1 = layers.Dense(32, activation='relu')
        self.layer2 = layers.Dense(num_classes, activation='softmax')
    def call(self, inputs):
        h1 = self.layer1(inputs)
        out = self.layer2(h1)
        return out
    def compute_output_shape(self, input_shape):
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.num_classes
        return tf.TensorShape(shape)
model = MyModel(num_classes=10)

• 自定義層

通過對 tf.keras.layers.Layer 進行子類化并實現(xiàn)以下方法來創(chuàng)建自定義層：

• __init__()函數(shù)，你可以在其中執(zhí)行所有與輸入無關的初始化
• build： 可以獲得輸入張量的形狀原献， 創(chuàng)建層的權重玩讳。使用 add_weight 方法添加權重涩蜘。
• call： 構建網絡結構， 定義前向傳播熏纯。
• compute_output_shape：指定在給定輸入形狀的情況下如何計算層的輸出形狀同诫。
  或者，可以通過實現(xiàn) get_config 方法和 from_config 類方法序列化層樟澜。

class MyLayer(layers.Layer):
    def __init__(self, output_dim, **kwargs):
        super(MyLayer, self).__init__(**kwargs)
        self.output_dim = output_dim
    def build(self, input_shape):
        shape = tf.TensorShape((input_shape[1], self.output_dim))
        self.kernel = self.add_weight(name='kernel1', shape=shape,
                                   initializer='uniform', trainable=True)
        super(MyLayer, self).build(input_shape)
    def call(self, inputs):
        return tf.matmul(inputs, self.kernel)
    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)
model = tf.keras.Sequential([
    MyLayer(10),
    layers.Activation('softmax')])

損失函數(shù)

? mean_ squared_ error 或mse 误窖。
? mean_absolute_error 或mae 。
? mean_ absolute_percentage_error 或mape 秩贰。
? mean_squared_logarithmic_error 或msle 霹俺。
? squared_hinge 。
? hinge 毒费。
? binary_ crossentropy 丙唧。
? categorical_ crossentropy 。
? sparse_ categorical_ crossentrop 觅玻。
? kullback_lei bier_ divergence 想际。
? poisson 。
? cosine_proximity 溪厘。

注意：當使用categorical_crossentropy 作為目標函數(shù)時胡本，標簽應該為多類模式，即one-hot 形式編碼的向量畸悬，而不是單個數(shù)值侧甫。用戶可以使用工具中的to_ categorical 函數(shù)完成該轉換.

from keras.utils.np_utils import to_categorical
int_labels= [1,2,3]
categorical_labels=to_categorical(int_labels, num classes=None)
print(categorical_labels)

優(yōu)化器函數(shù)

選定了整個深度網絡的損失函數(shù)，緊接著需要考慮的就是優(yōu)化器的選擇蹋宦。因為有了訓練目標披粟，剩下最重要的就是達成該目標的方法

保存和恢復

權重保存

model.save_weights('./model.h5')
model.load_weights('./model.h5')

保存網絡結構

這樣導出的模型并未包含訓練好的參數(shù)

# 序列化成json
import json
with open('model_struct.json', 'w') as ff:
    json_config = am.model.to_json()
    ff.write(json_string)  # 保存模型信息
with open('model_struct.json', 'r') as ff:
   json_config = ff.read()
reinitialized_model = keras.models.model_from_json(json_config)
new_prediction = reinitialized_model.predict(x_test)

# 其他形式
config = model.get_config()
reinitialized_model = keras.Model.from_config(config)
new_prediction = reinitialized_model.predict(x_test)
# 保持為yaml格式  #需要提前安裝pyyaml
yaml_str = model.to_yaml()
print(yaml_str)
fresh_model = tf.keras.models.model_from_yaml(yaml_str)

保存整個模型

內容包括：架構;權重（在訓練期間學到的）;訓練配置（你傳遞給編譯的），如果有的話;優(yōu)化器及其狀態(tài)（如果有的話）（這使您可以從中斷的地方重新啟動訓練）

model.save('all_model.h5')
new_model = keras.models.load_model('the_save_model.h5')

new_prediction = new_model.predict(x_test)
np.testing.assert_allclose(predictions, new_prediction, atol=1e-6) # 預測結果一樣

# 保存為SavedModel文件  
keras.experimental.export_saved_model(model, 'saved_model')
new_model = keras.experimental.load_from_saved_model('saved_model')

checkpoint

checkpoint_path = os.path.join(os.path.join(logs_path, 'Checkpoint'), 'weights-improvement-{epoch:02d}-{loss:.2f}.hdf5')
cb.append(keras.callbacks.ModelCheckpoint(checkpoint_path, monitor='loss', verbose=0, save_best_only=True, save_weights_only=False, mode='auto'))
# 恢復至最近的checkpoint
latest=tf.train.latest_checkpoint(checkpoint_dir)
model = create_model()
model.load_weights(latest)

模型集成

import numpy as np
from tensorflow.keras.wrappers.scikit_learn import KerasClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.metrics import accuracy_score

def mlp_model():
    model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
    ])
    model.compile(optimizer=keras.optimizers.SGD(),
             loss=keras.losses.SparseCategoricalCrossentropy(),
             metrics=['accuracy'])
    return model
# 下面是使用投票的方法進行模型集成
model1 = KerasClassifier(build_fn=mlp_model, epochs=100, verbose=0)
model2 = KerasClassifier(build_fn=mlp_model, epochs=100, verbose=0)
model3 = KerasClassifier(build_fn=mlp_model, epochs=100, verbose=0)
ensemble_clf = VotingClassifier(estimators=[('model1', model1), ('model2', model2), ('model3', model3)], voting='soft')
ensemble_clf.fit(x_train, y_train)
y_pred = ensemble_clf.predict(x_test)
print('acc: ', accuracy_score(y_pred, y_test))

MLP樣例

import tensorflow as tf
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
print(tf.keras.__version__)
# 生成數(shù)據
train_x = np.random.random((1000, 72))
train_y = np.random.random((1000, 10))
val_x = np.random.random((200, 72))
val_y = np.random.random((200, 10))
test_x = np.random.random((1000, 72))
test_y = np.random.random((1000, 10))
dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y))
dataset = dataset.batch(32).repeat()
val_dataset = tf.data.Dataset.from_tensor_slices((val_x, val_y))
val_dataset = val_dataset.batch(32).repeat()
test_data = tf.data.Dataset.from_tensor_slices((test_x, test_y))
test_data = test_data.batch(32).repeat()
# 模型堆疊
model = tf.keras.Sequential([
    layers.Dense(32, activation='relu', input_shape=(72,)),
    layers.BatchNormalization(),  
    layers.Dropout(0.2),
    layers.Dense(32, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')])
model.compile(optimizer=keras.optimizers.SGD(0.1),
             loss=tf.keras.losses.categorical_crossentropy,
             metrics=[tf.keras.metrics.categorical_accuracy])
model.summary()
# 網絡圖
# !sudo apt-get install graphvizf
# keras.utils.plot_model(model, 'model_info.png', show_shapes=True)
history = model.fit(train_data, epochs=10, steps_per_epoch=30)
# 畫出學習曲線
# print(history.history.keys())
plt.plot(history.history['categorical_accuracy'])
plt.plot(history.history['loss'])
plt.legend(['categorical_accuracy', 'loss'], loc='upper left')
plt.show()
# 評估與預測
result = model.predict(test_data, steps=30)
print(result)
loss, accuracy = model.evaluate(test_data, steps=30)
print('test loss:', loss)
print('test accuracy:', accuracy)

多輸入與多輸出網絡

import numpy as np
# 載入輸入數(shù)據
title_data = np.random.randint(num_words, size=(1280, 10))
body_data = np.random.randint(num_words, size=(1280, 100))
tag_data = np.random.randint(2, size=(1280, num_tags)).astype('float32')
# 標簽
priority_label = np.random.random(size=(1280, 1))
department_label = np.random.randint(2, size=(1280, num_departments))
# 超參
num_words = 2000
num_tags = 12
num_departments = 4
# 輸入
title_input = keras.Input(shape=(None,), name='title')
body_input = keras.Input(shape=(None,), name='body')
tag_input = keras.Input(shape=(num_tags,), name='tag')
# 嵌入層
title_feat = layers.Embedding(num_words, 64)(title_input)
body_feat = layers.Embedding(num_words, 64)(body_input)
# 特征提取層
title_feat = layers.Embedding(num_words, 64)(title_input)
body_feat = layers.LSTM(32)(body_feat)
features = layers.concatenate([title_feat,body_feat, tag_input])
# 分類層
priority_pred = layers.Dense(1, activation='sigmoid', name='priority')(features)
department_pred = layers.Dense(num_departments, activation='softmax', name='department')(features)
# 構建模型
model = keras.Model(inputs=[body_input, title_input, tag_input], outputs=[priority_pred, department_pred])
model.summary()
keras.utils.plot_model(model, 'multi_model.png', show_shapes=True)
model.compile(optimizer=keras.optimizers.RMSprop(1e-3),
             loss={'priority': 'binary_crossentropy', 'department': 'categorical_crossentropy'},
             loss_weights=[1., 0.2])
# 訓練
history = model.fit(
    {'title': title_data, 'body':body_data, 'tag':tag_data},
    {'priority':priority_label, 'department':department_label},
    batch_size=32,
    epochs=5)

layers.Conv2D((filters,kernel_size,strides=(1, 1),padding='valid',data_format=None,dilation_rate=(1,1),activation=None,use_bias=True,kernel_initializer='glorot_uniform',bias_initializer='zeros',kernel_regularizer=None,bias_regularizer=None,activity_regularizer=None,kernel_constraint=None,bias_constraint=None,**kwargs)

layers.MaxPooling2D(pool_size=(2, 2),strides=None,padding='valid',data_format=None,**kwargs)

小型殘差網絡

inputs = keras.Input(shape=(32,32,3), name='img')
h1 = layers.Conv2D(32, 3, activation='relu')(inputs)
h1 = layers.Conv2D(64, 3, activation='relu')(h1)
block1_out = layers.MaxPooling2D(3)(h1)

h2 = layers.Conv2D(64, 3, activation='relu', padding='same')(block1_out)
h2 = layers.Conv2D(64, 3, activation='relu', padding='same')(h2)
block2_out = layers.add([h2, block1_out])

h3 = layers.Conv2D(64, 3, activation='relu', padding='same')(block2_out)
h3 = layers.Conv2D(64, 3, activation='relu', padding='same')(h3)
block3_out = layers.add([h3, block2_out])

h4 = layers.Conv2D(64, 3, activation='relu')(block3_out)
h4 = layers.GlobalMaxPool2D()(h4)
h4 = layers.Dense(256, activation='relu')(h4)
h4 = layers.Dropout(0.5)(h4)
outputs = layers.Dense(10, activation='softmax')(h4)

model = keras.Model(inputs, outputs, name='small resnet')
model.summary()
keras.utils.plot_model(model, 'small_resnet_model.png', show_shapes=True)
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
x_train = x_train.astype('float32') / 255
x_test = y_train.astype('float32') / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

model.compile(optimizer=keras.optimizers.RMSprop(1e-3),
             loss='categorical_crossentropy',
             metrics=['acc'])
model.fit(x_train, y_train,
         batch_size=64,
         epochs=1,
         validation_split=0.2)
#model.predict(x_test, batch_size=32)

image.png

封裝被sklearn調用

from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.cross_validation import StratifiedKFold
from sklearn.cross_validation import cross_val_score
import numpy
import pandas
# Function to create model, required for KerasClassifier
def create_model():
    model = Sequential()
    model.add(Dense(12, input_dim=8, init='uniform', activation='relu'))        model.add(Dense(8, init='uniform', activation='relu')) 
    model.add(Dense(1, init='uniform', activation='sigmoid'))
    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=            ['accuracy']) return model
# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# Keras的KerasClassifier和KerasRegressor兩個類接受build_fn參數(shù)冷冗，傳入編譯好的模型守屉。我們加入nb_epoch=150和batch_size=10這兩個參數(shù)這兩個參數(shù)會傳入模型的fit()方法。
model = KerasClassifier(build_fn=create_model, nb_epoch=150, batch_size=10)
# 用scikit-learn的StratifiedKFold類進行10折交叉驗證贾惦，測試模型在未知數(shù)據的性能，并使用cross_val_score()函數(shù)檢測模型敦捧，打印結果须板。
# StratifiedKFold用法類似Kfold，但是他是分層采樣兢卵，確保訓練集习瑰，測試集中各類別樣本的比例與原始數(shù)據集中相同
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold, , verbose=0, cv=5, n_jobs=-1, scoring=make_scorer(mean_absolute_error))
print("Results: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

# 使用網格搜索調整深度學習模型的參數(shù)
model = KerasClassifier(build_fn=create_model)
param_grid = {'optimizers': ['rmsprop', 'adam'],
        'kernel_initializer': ['glorot_uniform', 'normal', 'uniform'],
        'use_bias': ['True', 'False'],
        'epochs': np.array([50, 100, 150]),
        'batch_size': np.array([5, 10, 20])}
# GridSearchCV會對每組參數(shù)（2×3×3×3）進行訓練，進行3折交叉檢驗秽荤。
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid_result = grid.fit(X, Y)
# summarize results
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
for params, mean_score, scores in grid_result.grid_scores_:
    print("%f (%f) with: %r" % (scores.mean(), scores.std(), params))
# Best: 0.751302 using {'init': 'uniform', 'optimizer': 'rmsprop', 'nb_epoch': 150, 'batch_size': 5}
#0.653646 (0.031948) with: {'init': 'glorot_uniform', 'optimizer': 'rmsprop', 'nb_epoch': 50, 'batch_size': 5}
#0.665365 (0.004872) with: {'init': 'glorot_uniform', 'optimizer': 'adam', 'nb_epoch': 50, 'batch_size': 5}
# 0.683594 (0.037603) with: {'init': 'glorot_uniform', 'optimizer': 'rmsprop', 'nb_epoch': 100, 'batch_size': 5}

卷積甜奄、池化

二維卷積：

keras.layers.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)
Conv2D輸入：(samples, rows, cols, channels)
kernel：尺寸(k, k)柠横， 數(shù)量filters
輸出：（samples, new_rows, new_cols, filters)， new_rows=(rows-k+2padding)/strides+1
備注：實際計算時课兄，kernel維度為(k,k,channels)牍氛，會包含所有channels維度，因此若filters=1烟阐，即只有一個卷積核搬俊，則輸出為(samples, new_rows,new_cols,1)

一維卷積：

keras.layers.Conv1D(filters, kernel_size, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)
Conv1D輸入：(batch_size, steps, input_dim)
行向量代表單個時間步，單個時間步包含特征維度input_dim
列向量代表單個特征維度蜒茄，單個特征維度包含時間步長steps
kernel：尺寸k唉擂， 數(shù)量filters
輸出：(batch_size, new_steps, filters)，new_steps=(steps-k+2padding)/strides+1
備注：實際計算時檀葛，kernel維度為(k,input_dim)玩祟，會包含所有input_dim（這里的input_dim與Conv2D中的channels類似）

一維最大池化

keras.layers.MaxPooling1D(pool_size=2, strides=None, padding='valid', data_format='channels_last')
輸入為 3D 張量，尺寸為： (batch_size, steps, features)
輸出為 3D 張量屿聋，尺寸為： (batch_size, downsampled_steps, features)
Maxpooling1D(3,2))池化核大小為3空扎，步長為2，(8-3＋1)/2=3,
注意:若model.add(Maxpooling1D(2))胜臊，則池化核大小為2勺卢，步長也為2。