keras学习-基础部分

2020-07-14 本文已影响0人锦绣拾年

keras学习基础

参考《Python深度学习》一书

python 扩展学习

   1   在 Python 2.2  ：

         要引用： from __future__ import division
  
        " / "就表示 浮点数除法，返回浮点结果;" // "表示整数除法。

   2    Python 3以后  ：
        " / "就表示 浮点数除法，返回浮点结果;" // "表示整数除法。
————————————————
版权声明：本文为CSDN博主「lw_waston」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/lw_waston/article/details/83150304

数据处理相关

'''
如果你的 targets 是 one-hot 编码，用 categorical_crossentropy
　　one-hot 编码：[0, 0, 1], [1, 0, 0], [0, 1, 0]
如果你的 tagets 是 数字编码 ，用 sparse_categorical_crossentropy
　　数字编码：2, 0, 1
'''

  def to_categorical(y, num_classes=None, dtype='float32')
  简单来说，to_categorical就是将类别向量转换为二进制（只有0和1）的矩阵类型表示。其表现为将原有的类别向量转换为独热编码的形式。
等同于以下方法：
def to_one_hot(labels, dimension=46):#负责转变y的,结果和上面to_categorical方法得到的结果是一样的，
    results = np.zeros((len(labels), dimension))#新建这么大维度的矩阵
    for i, label in enumerate(labels):
        results[i, label] = 1.#对应label位置标1
    return results

'''array和asarray都可将结构数据转换为ndarray类型。

但是主要区别就是当数据源是ndarray时，
array仍会copy出一个副本，占用新的内存，但asarray不会。'''
y_train = train_labels.astype('float32')#强制类型转换

轴方向

import numpy as np
a =np.array([[1,2,3],[2,3,4]])
mean=a.mean(axis=0)
a=a-mean
print(a)
print(mean)
print(a.shape)

#axis=0纵轴方向求平均值
[[-0.5 -0.5 -0.5]
 [ 0.5  0.5  0.5]]
[1.5 2.5 3.5]
(2, 3)

注意之后，k折交叉验证合并数据的代码，axis=0

    partial_train_data = np.concatenate([train_data[:i*num_val_samples],train_data[(i+1)*num_val_samples:]],axis=0)#?axis=0 纵向拼接
    partial_train_targets = np.concatenate([train_data[:i*num_val_samples],train_data[(i+1)*num_val_samples:]],axis=0)

常用画图总结

print(history.history.keys())
#dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])

import matplotlib.pyplot as plt

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

# "bo" is for "blue dot"
plt.plot(epochs, loss, 'b', label='Training loss')
# b is for "solid blue line"
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.figure()
plt.plot(epochs,acc,'b',label='Training acc')
plt.plot(epochs,val_acc,'r',label='Validation acc')
plt.title('Accuracy')
plt.legend()

plt.show()

神经网络相关

如果您需要将数据分类为大量类别，那么您应该避免使用太小的中间层造成的信息瓶颈。

metrics

acc mae

model.compile(loss='mean_squared_error',
              optimizer='sgd',
              metrics=['mae', 'acc'])#这里同时写了两种metrics
from keras import metrics

model.compile(loss='mean_squared_error',
              optimizer='sgd',
              metrics=[metrics.mae, metrics.categorical_accuracy])

binary_accuracy

binary_accuracy(y_true, y_pred)

categorical_accuracy

categorical_accuracy(y_true, y_pred)

sparse_categorical_accuracy

sparse_categorical_accuracy(y_true, y_pred)

top_k_categorical_accuracy

top_k_categorical_accuracy(y_true, y_pred, k=5)

sparse_top_k_categorical_accuracy

sparse_top_k_categorical_accuracy(y_true, y_pred, k=5)

自定义评价函数

自定义评价函数应该在编译的时候（compile）传递进去。该函数需要以 (y_true, y_pred) 作为输入参数，并返回一个张量作为输出结果。

import keras.backend as K

def mean_pred(y_true, y_pred):
    return K.mean(y_pred)

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy', mean_pred])

loss

可用损失函数

mean_squared_error

mean_squared_error(y_true, y_pred)

mean_absolute_error

mean_absolute_error(y_true, y_pred)

mean_absolute_percentage_error

mean_absolute_percentage_error(y_true, y_pred)

mean_squared_logarithmic_error

mean_squared_logarithmic_error(y_true, y_pred)

squared_hinge

squared_hinge(y_true, y_pred)

hinge

hinge(y_true, y_pred)

categorical_hinge

categorical_hinge(y_true, y_pred)

logcosh

logcosh(y_true, y_pred)

预测误差的双曲余弦的对数。

k折交叉验证

#K折交叉验证
import numpy as np
k=4
num_val_samples = len(train_data) // k 
num_epochs = 100
all_scores = []
for i in range(k):
    print('processing fol #'，i)
    
    val_data=train_data[i*num_val_samples:(i+1)*num_val_samples]
    val_targets = train_targets[i*num_val_samples:(i+1)*num_val_samples]
    #训练集，是上面除了验证集数据的拼接
    partial_train_data = np.concatenate([train_data[:i*num_val_samples],train_data[(i+1)*num_val_samples:]],axis=0)#?axis=0 纵向拼接
    partial_train_targets = np.concatenate([train_data[:i*num_val_samples],train_data[(i+1)*num_val_samples:]],axis=0)
    
        # Build the Keras model (already compiled)
    model = build_model()
    # Train the model (in silent mode, verbose=0)
    model.fit(partial_train_data, partial_train_targets,
              epochs=num_epochs, batch_size=1, verbose=0)
    # Evaluate the model on the validation data
    val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)
    all_scores.append(val_mae)

防止过拟合的方法

1）更小的模型

2）添加权重正则化

L1 正则化（L1 regularization）：添加的成本与权重系数的绝对值［权重的 L1 范数（norm）］成正比。
L2 正则化（L2 regularization）：添加的成本与权重系数的平方（权重的 L2 范数）成正比。
神经网络的 L2 正则化也叫权重衰减（weight decay）。不要被不同的名称搞混，权重衰减
与 L2 正则化在数学上是完全相同的。
在 Keras 中，添加权重正则化的方法是向层传递权重正则化项实例（weight regularizer
instance）作为关键字参数。

from keras import regularizers
model = models.Sequential()
model.add(layers.Dense(16, kernel_regularizer=regularizers.l2(0.001),
activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, kernel_regularizer=regularizers.l2(0.001),
activation='relu'))
model.add(layers.Dense(1, activation='sigmoid')

from keras import regularizers
regularizers.l1(0.001)#l1正则化
regularizers.l1_l2(l1=0.001, l2=0.001)#同时l2和l1正则化

3)dropout层

model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='sigmoid'))

总结一下，防止神经网络过拟合的常用方法包括：

获取更多的训练数据
减小网络容量
添加权重正则化
添加 dropout

keras学习-基础部分