keras深度学习摘要（第二章）

3.1 神经网络剖析

前面几章介绍过，训练神经网络主要围绕以下四个方面。
层，多个层组合成网络（或模型）。
输入数据和相应的目标。
损失函数，即用于学习的反馈信号。
优化器，决定学习过程如何进行。
在这里插入图片描述
3.1.1 层：深度学习的基础组件

简单的向量数据保存在形状为 (samples, features) 的 2D 张量中，通常用密集连接层［densely connected layer，也叫全连接层（fully connected layer）或密集层（dense layer），对应于 Keras 的 Dense 类］来处理。序列数据保存在形状为(samples, timesteps, features) 的 3D 张量中，通常用循环层（recurrent layer，比如 Keras 的 LSTM 层）来处理。图像数据保存在 4D 张量中，通常用二维卷积层（Keras 的 Conv2D）来处理。

from keras import layers layer = layers.Dense(32, input_shape=(784,))#这个input_shape说明输入的张量是（N*784）的

我们创建了一个层，只接受第一个维度大小为 784 的 2D 张量（第 0 轴是批量维度，其大小没有指定，因此可以任意取值）作为输入。这个层将返回一个张量，第一个维度的大小变成
了 32。

from keras import models from keras import layers model = models.Sequential()
model.add(layers.Dense(32, input_shape=(784,)))
model.add(layers.Dense(32))

其中第二层没有输入形状（input_shape）的参数，它可以自动推导出输入形状等于上一层的输出形状。
3.1.3 损失函数与优化器：配置学习过程的关键

一旦确定了网络架构，你还需要选择以下两个参数。
损失函数（目标函数）——在训练过程中需要将其最小化。它能够衡量当前任务是否已成功完成。
优化器——决定如何基于损失函数对网络进行更新。它执行的是随机梯度下降（SGD）的某个变体。
loss函数的选择：
例如，对于二分类问题，你可以使用二元交叉熵（binary crossentropy）损失函数；对于多分类问题，可以用分类交叉熵（categorical crossentropy）损失函数；对于回归问题，可以用均方误差（mean-squared error）损失函数；对于序列学习问题，可以用联结主义时序分类（CTC，connectionist temporal classification）损失函数

3.2 Keras 简介

你已经见过一个 Keras 模型的示例，就是 MNIST 的例子。典型的 Keras 工作流程就和那个例子类似。
(1) 定义训练数据：输入张量和目标张量。
(2) 定义层组成的网络（或模型），将输入映射到目标。
(3) 配置学习过程：选择损失函数、优化器和需要监控的指标。
(4) 调用模型的 fit 方法在训练数据上进行迭代。
定义模型有两种方法：一种是使用 Sequential 类（仅用于层的线性堆叠，这是目前最常见的网络架构），另一种是函数式 API（functional API，用于层组成的有向无环图，让你可以构建任意形式的架构）

Sequential 类定义的两层模型（注意，我们向第一层传入了输入数据的预期形状）：

from keras import models from keras import layers
model = models.Sequential()
model.add(layers.Dense(32, activation='relu', input_shape=(784,)))
model.add(layers.Dense(10, activation='softmax'))

下面是用函数式 API 定义的相同模型：

input_tensor = layers.Input(shape=(784,)) 
x = layers.Dense(32, activation='relu')(input_tensor)
output_tensor = layers.Dense(10, activation='softmax')(x)
model = models.Model(inputs=input_tensor, outputs=output_tensor)

一旦定义好了模型架构，使用 Sequential 模型还是函数式 API 就不重要了。接下来的步骤都是相同的。
配置学习过程是在编译这一步，你需要指定模型使用的优化器和损失函数，以及训练过程中想要监控的指标。下面是单一损失函数的例子，这也是目前最常见的

from keras import optimizers model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss='mse',
metrics=['accuracy'])

model.fit(input_tensor, target_tensor, batch_size=128, epochs=10)#这种方法 不好，这个是把全部的数据丢进网络中，太占内存了

3.4 电影评论分类：二分类问题

from keras.datasets import imdb from keras.datasets import reuters import numpy as np from keras import models from keras import layers from keras import optimizers from keras import losses from keras import metrics import matplotlib.pyplot as plt

(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)#在线加载数据
#train_data 和 test_data 这两个变量都是评论组成的列表，
#每条评论又是单词索引组成的列表（表示一系列单词）。
#train_labels 和 #test_labels 都是 0 和 1 组成的列表，其中 0
#代表负面（negative），1 代表正面（positive）。

数据准备：
对列表进行 one-hot 编码，将其转换为 0 和 1 组成的向量。举个例子，序列[3, 5]将会被转换为 10 000 维向量，只有索引为 3 和 5 的元素是 1，其余元素都是 0。然后网络第
一层可以用 Dense 层，它能够处理浮点数向量数据

#下面的这个函数我是这么理解的，train_data是一个列表包含评论每个单词的索引，这个函数所做的是首先创建了一个(len(sequences), dimension)的矩阵，然后行代表数据的大小，列代表，索引是10000.
然后在对应出置为1.

def vectorize_sequences(sequences, dimension=10000):
results = np.zeros((len(sequences), dimension))
for i, sequence in enumerate(sequences):
results[i, sequence] = 1.
return results
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(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’))

model.compile(optimizer='rmsprop', loss='binary_crossentropy',
metrics=['accuracy'])
model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy'])书上也有例子这个我看，和下面正式使用的差别是：acc，和accuracy的差别，具体用哪个不清楚

上述代码将优化器、损失函数和指标作为字符串传入，这是因为 rmsprop、binary_ crossentropy 和 accuracy 都是 Keras 内置的一部分。有时你可能希望配置自定义优化器的参数，或者传入自定义的损失函数或指标函数。前者可通过向 optimizer 参数传入一个优化器类实例来实现，如代码清单 3-5 所示；后者可通过向 loss 和 metrics 参数传入函数对象来实现，
如代码清单 3-6 所示。
下面是自定义优化器
其实就是加了参数

from keras import optimizers model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss='binary_crossentropy',
metrics=['accuracy'])

预留数据做验证
x_val = x_train[:10000]
partial_x_train = x_train[10000:]
y_val = y_train[:10000]
partial_y_train = y_train[10000:]

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=(x_val, y_val))

注意，调用 model.fit() 返回了一个 History 对象。这个对象有一个成员 history，它是一个字典，包含训练过程中的所有数据。我们来看一下。

history_dict = history.history
history_dict.keys()
dict_keys([‘val_acc’, ‘acc’, ‘val_loss’, ‘loss’])
字典中包含 4 个条目，对应训练过程和验证过程中监控的指标。在下面两个代码清单中，我们将使用 Matplotlib 在同一张图上绘制训练损失和验证损失

绘制函数如下：
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()

plt.clf() 清空图像
acc = history_dict[‘acc’] val_acc = history_dict[‘val_acc’]
plt.plot(epochs, acc, ‘bo’, label=‘Training acc’) plt.plot(epochs, val_acc, ‘b’, label=‘Validation acc’) plt.title(‘Training and validation accuracy’) plt.xlabel(‘Epochs’) plt.ylabel(‘Accuracy’) plt.legend()
plt.show()

实在太懒了，贴一个可以运行的代码，其中，改过bug是因为不能加载数据集的问题

from keras.datasets import imdb
from keras.datasets import reuters
import numpy as np
from keras import models
from keras import layers
from keras import optimizers
from keras import losses
from keras import metrics
import matplotlib.pyplot as plt

(train_data, train_labels), (test_data, test_labels) = imdb.load_data(
num_words=10000)
print(len(train_data[0]))
word_index = imdb.get_word_index()
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
decoded_review = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])

def vectorize_sequences(sequences, dimension=10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(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'))



x_val = x_train[:10000]
partial_x_train = x_train[10000:]
y_val = y_train[:10000]
partial_y_train = y_train[10000:]


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=(x_val, y_val))

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()
plt.clf() 
acc = history_dict['acc'] 
val_acc = history_dict['val_acc']
plt.plot(epochs, acc, 'bo', label='Training acc') 
plt.plot(epochs, val_acc, 'b', label='Validation acc') 
plt.title('Training and validation accuracy') 
plt.xlabel('Epochs') plt.ylabel('Accuracy') 
plt.legend()
plt.show()

还有两个例子和上面的例子一样。

import numpy as np
from keras.datasets import reuters 

from keras import models 
from keras import layers
(train_data, train_labels), (test_data, test_labels) = reuters.load_data(
num_words=10000)#加载数据集


def vectorize_sequences(sequences, dimension=10000): 
    results = np.zeros((len(sequences), dimension)) 
    for i, sequence in enumerate(sequences): 
        results[i, sequence] = 1.
    return results
x_train = vectorize_sequences(train_data) 
x_test = vectorize_sequences(test_data)
def to_one_hot(labels, dimension=46): 
    results = np.zeros((len(labels), dimension)) 
    for i, label in enumerate(labels): 
        results[i, label] = 1. 
    return results
one_hot_train_labels = to_one_hot(train_labels)
one_hot_test_labels = to_one_hot(test_labels)



model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10000,))) 
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(46, activation='softmax'))


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


x_val = x_train[:1000] 
partial_x_train = x_train[1000:]
y_val = one_hot_train_labels[:1000]
partial_y_train = one_hot_train_labels[1000:]


history = model.fit(partial_x_train, partial_y_train, epochs=20,
batch_size=512,
validation_data=(x_val, y_val))


import matplotlib.pyplot as plt 
loss = history.history['loss'] 
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1) 
plt.plot(epochs, loss, 'bo', label='Training loss') 
plt.plot(epochs, val_loss, 'b', label='Validation loss') 
plt.title('Training and validation loss') 
plt.xlabel('Epochs') 
plt.ylabel('Loss') 
plt.legend()
plt.show()