深度学习1：二分类问题

IMDB数据

包含来自互联网电影数据库的50000条两极分化的评论，数据集被分为用于训练的25000条评论与用于测试的25000条评论，训练集和测试集都包含百分之五十的正面评论和百分之五十负面评论。
该数据集也内置于Keras库，它已经过预处理：评论已经被转换为整数序列，其中每个整数代表字典中的某个单词。
加载IMDB数据集

from tensorflow.keras.datasets import imdb
# 仅仅保留训练数据前10000个最常出现的单词，低频单词将被舍弃，加载数据，其中train_label,test_label都是0和1组成的列表，0代表负面，1代表正面
(train_data, train_labels),(test_data, test_labels) = imdb.load_data(num_words=10000)

实现过程

准备数据
将整数序列编码成二进制矩阵
enumerate方法实例：

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

import numpy as np
def vectorize_sequence(sequences,dimension=10000):
    results = np.zeros((len(sequences), dimension))
    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results
# 将数据都向量化
x_train = vectorize_sequence(train_data)
x_test = vectorize_sequence(test_data)
#将标签向量化
y_train = np.asarray(train_labels.astype('float32'))
y_test = np.asarray(test_labels.astype('float32'))

构建网络

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

relu是深度学习最常用的激活函数，如果没有relu等激活函数（非线性），Dense层将只包含两个线性运算（点积和加法）。
需要选择损失函数和优化器，由于面对的是一个二分类问题，网络输出是一个概率值，那么最好用binary_crossentropy（二元交叉熵）损失，还可以选择mean_squared_error（均方误差），但是对于输出概率值的模型，交叉熵往往是一个最好的选择。
编译模型
keras内置rmsprop优化器，以及binary_crossentropy和accuracy。

# 编译模型
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])

配置优化器

# 配置优化器
model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss='binary_crossentropy',
              metrics=['accuracy'])

使用自定义的损失和指标

# 使用自定义的损失和指标
model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss=losses.binary_crossentropy,
              metrics=[metrics.binary_accuracy])

验证方法

# 留出验证集，10000个
x_val = x_train[:10000]
partial_x_train = x_train[10000:]
y_val = y_train[:10000]
partial_y_train = y_train[10000:]
# 训练模型，使用512个样本作为小批量，将模型训练20个轮次
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['acc'])
history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=20,
                    batch_size=512,
                    #将验证数据传入validation_data参数来完成
                    validation_data=(x_val, y_val))

model.fit()返回了一个history对象，这个对象有一个成员history，它是一个字典，包含训练过程中的所有数据。

绘制图像

# 绘制训练损失和验证损失
history_dict = history.history
loss_values = history_dict['loss']
val_loss_values = history_dict['val_loss']
epochs = range(1, len(loss_values)+1)
plt.plot(epochs,loss_values,'bo',label='Training loss')
plt.plot(epochs,val_loss_values,'b',label='Validation loss')
plt.title("Training and validation loss")
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

acc_values = history_dict['acc']
val_acc = history_dict['val_acc']
plt.plot(epochs,loss_values,'bo',label='Training acc')
plt.plot(epochs,val_loss_values,'b',label='Validation acc')
plt.title("Training and validation accuracy")
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

分析：
如图所见，训练损失每轮都在降低，训练精度每轮都在上升，可见它们似乎在第四轮最佳，再往后模型在训练数据上表现的越来越好，在前所未有的数据上不一定表现的越来越好，也就是过拟合，为了防止过拟合，可以在第三轮后停止训练，通常可以采用多种方法来降低拟合。

完整代码：

from tensorflow.keras.datasets import imdb
from tensorflow.keras import models, layers
from tensorflow.keras import optimizers, losses, metrics
import numpy as np
from tensorflow_core.python.keras import regularizers


def vectorize_sequence(sequences,dimension=10000):
    results = np.zeros((len(sequences), dimension))
    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results
(train_data, train_labels),(test_data, test_labels) = imdb.load_data(num_words=10000)
# 将数据都向量化
x_train = vectorize_sequence(train_data)
x_test = vectorize_sequence(test_data)
y_train = np.asarray((train_labels).astype('float32'))
y_test = np.asarray((test_labels).astype('float32'))
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'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])
history = model.fit(x_train,
                    y_train,
                    epochs=4,
                    batch_size=512)
results = model.evaluate(x_test, y_test)
print(results)
# 使用训练好的网络在新数据上生成预测结果
print(model.predict(x_test))