编码卷积

def windowed_dataset(series, window_size, batch_size, shuffle_buffer):
    series = tf.expand_dims(series, axis=-1)
    dataset = tf.data.Dataset.from_tensor_slices(series)
    dataset = dataset.window(window_size + 1, shift=1, drop_remainder=True)
    dataset = dataset.flat_map(lambda window: window.batch(window_size + 1))
    dataset = dataset.shuffle(shuffle_buffer).map(
                   lambda window: (window[:-1], window[-1]))
    dataset = dataset.batch(batch_size).prefetch(1)
    return dataset

现在您有了修改后的数据集，您可以在之前的密集层之前添加一个卷积层：

dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

model = tf.keras.models.Sequential([
    tf.keras.layers.Conv1D(filters=128, kernel_size=3,
                           strides=1, padding="causal",
                           activation="relu",
                           input_shape=[None, 1]),
    tf.keras.layers.Dense(28, activation="relu"), 
    tf.keras.layers.Dense(10, activation="relu"), 
    tf.keras.layers.Dense(1),
])

optimizer = tf.keras.optimizers.SGD(lr=1e-5, momentum=0.5)
model.compile(loss="mse", optimizer=optimizer)
history = model.fit(dataset, epochs=100, verbose=1)

filters：是您希望该层学习的过滤器数量。它会生成这个数字，并随着时间的推移调整它们以适应您的数据。

kernel_size：是过滤器的大小——之前我们演示了一个值为 –0.5, 1, –0.5的过滤器，这将是内核大小为 3。

strides：是过滤器在扫描列表时将采取的“步骤”的大小。这通常是 1。

padding：确定关于从中删除结束数据的列表的行为。3 × 1 过滤器将“丢失”列表的第一个和最后一个值，因为它无法计算第一个的先验值或最后一个的后续值。通常，您将causal在此处使用序列数据，它只会从当前和之前的时间步长中获取数据，而不会从未来的时间步长中获取数据。因此，例如，一个 3 × 1 滤波器将采用当前时间步长以及前两个时间步长。

input_shape：与往常一样，是传递到网络中的数据的输入形状。由于这是第一层，您必须指定它。

用它训练会像以前一样给你一个模型，但是要从模型中得到预测，假设输入层已经改变形状，你需要稍微修改你的预测代码。

此外，不是根据前一个窗口一个一个地预测每个值，如果您已将序列正确格式化为数据集，您实际上可以获得整个序列的单个预测。为了稍微简化一下，这里有一个辅助函数，可以根据模型预测整个系列，具有指定的窗口大小：

def model_forecast(model, series, window_size):
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window_size, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window_size))
    ds = ds.batch(32).prefetch(1)
    forecast = model.predict(ds)
    return forecast

如果你想使用模型来预测这个系列，你只需将系列与一个新轴一起传入，以处理Conv1D具有额外轴的层所需的 s。你可以这样做：

forecast = model_forecast(model, series[..., np.newaxis], window_size)

您可以使用预定的拆分时间将此预测拆分为验证集的预测：

results = forecast[split_time - window_size:-1, -1, 0]

图 11-4显示了结果与系列的关系图。

本例中的 MAE 为 4.89，比之前的预测略差。这可能是因为我们没有适当地调整卷积层，或者可能是卷积根本没有帮助。这是您需要对数据进行的实验类型。

请注意，此数据中有一个随机元素，因此值会在会话之间发生变化。如果你使用第 10 章的代码然后单独运行这段代码，你当然会有随机波动影响你的数据，从而影响你的 MAE。

图 11-4。具有时间序列数据预测的卷积神经网络

 但是在使用卷积时，问题总是会出现：为什么要选择我们选择的参数？为什么有 128 个过滤器？为什么尺寸为 3 × 1？好消息是您可以使用Keras Tuner对它们进行试验，如前所示。接下来我们将探讨这一点。

使用 Conv1D 超参数进行实验

在此示例中，您将试验过滤器数量、内核大小和步幅大小的超参数，同时保持其他参数不变：

def build_model(hp):
    model = tf.keras.models.Sequential()
    model.add(tf.keras.layers.Conv1D(
        filters=hp.Int('units',min_value=128, max_value=256, step=64), 
        kernel_size=hp.Int('kernels', min_value=3, max_value=9, step=3),
        strides=hp.Int('strides', min_value=1, max_value=3, step=1),
        padding='causal', activation='relu', input_shape=[None, 1]
    ))
  
    model.add(tf.keras.layers.Dense(28, input_shape=[window_size], 
                                    activation='relu'))
  
    model.add(tf.keras.layers.Dense(10, activation='relu'))
  
    model.add(tf.keras.layers.Dense(1))

    model.compile(loss="mse", 
                   optimizer=tf.keras.optimizers.SGD(momentum=0.5, lr=1e-5))
    return model

过滤器值将从 128 开始，然后以 64 为增量向上增加到 256。内核大小将从 3 开始，以 3 为增量增加到 9，步幅将从 1 开始，逐步增加到 3。

这里有很多值的组合，所以实验需要一些时间来运行。您还可以尝试其他更改，例如使用更小的起始值filters来查看它们的影响。

这是进行搜索的代码：

tuner = RandomSearch(build_model, objective='loss', 
                      max_trials=500, executions_per_trial=3, 
                      directory='my_dir', project_name='cnn-tune')

tuner.search_space_summary()

tuner.search(dataset, epochs=100, verbose=2)

当我运行实验时，我发现 128 个过滤器，大小为 9，步幅为 1，给出了最好的结果。因此，与初始模型相比，最大的区别在于改变了过滤器的大小——这对于如此庞大的数据体来说是有意义的。过滤器大小为 3 时，只有最近的邻居有影响，而过滤器大小为 9 时，更远的邻居也会对应用过滤器的结果产生影响。这将保证进一步的实验，从这些值开始并尝试更大的过滤器尺寸和可能更少的过滤器。我会把它留给你，看看你是否可以进一步改进模型！

将这些值插入模型架构中，您将得到：

dataset = windowed_dataset(x_train, window_size, batch_size, 
                            shuffle_buffer_size)

model = tf.keras.models.Sequential([
    tf.keras.layers.Conv1D(filters=128, kernel_size=9,
                           strides=1, padding="causal",
                           activation="relu",
                           input_shape=[None, 1]),
    tf.keras.layers.Dense(28, input_shape=[window_size], 
                           activation="relu"), 
    tf.keras.layers.Dense(10, activation="relu"), 
    tf.keras.layers.Dense(1),
])

optimizer = tf.keras.optimizers.SGD(lr=1e-5, momentum=0.5)
model.compile(loss="mse", optimizer=optimizer)
history = model.fit(dataset, epochs=100,  verbose=1)

 训练后，与之前创建的原始 CNN和原始 DNN相比，该模型的准确性有所提高，如图 11-5 所示。

图 11-5。优化的 CNN 预测

这导致 MAE 为 4.39，这比我们在不使用卷积层的情况下得到的 4.47 略有改进。对 CNN 超参数的进一步实验可能会进一步改善这一点。

除了卷积之外，我们在使用 RNN（包括 LSTM）进行自然语言处理的章节中探索的技术在处理序列数据时可能非常强大。就其本质而言，RNN 是为维护上下文而设计的，因此以前的值可以对以后的值产生影响。接下来您将探索使用它们进行序列建模。但首先，让我们从合成数据集开始，开始研究真实数据。在这种情况下，我们将考虑天气数据。

在 Python 中读取 GISS 数据

def get_data():
    data_file = "/home/ljpm/Desktop/bookpython/station.csv"
    f = open(data_file)
    data = f.read()
    f.close()
    lines = data.split('\n')
    header = lines[0].split(',')
    lines = lines[1:]
    temperatures=[]
    for line in lines:
        if line:
            linedata = line.split(',')
            linedata = linedata[1:13]
            for item in linedata:
                if item:
                    temperatures.append(float(item))

    series = np.asarray(temperatures)
    time = np.arange(len(temperatures), dtype="float32")
    return time, series

这将在指定的路径（您的路径当然会有所不同）打开文件并将整个文件作为一组行读入，其中行拆分是换行符 ( \n)。然后它将循环遍历每一行，忽略第一行，并根据逗号字符将它们拆分为一个名为linedata. 此数组中从 1 到 13 的项目将以字符串形式表示一月到二月的值。这些值被转换为浮点数并添加到名为 的数组temperatures中。完成后，它将变成一个名为 的 Numpy 数组，并且将创建series另一个名为 的 Numpy 数组，其大小与 相同。由于它是使用 创建的，因此第一个元素将为 1，第二个为 2，依此类推。因此，此函数将返回timeseriesnp.arangetime从 1 到数据点的数量，series作为当时的数据。

现在如果你想要一个标准化的时间序列，你可以简单地运行这个代码：

time, series = get_data()
mean = series.mean(axis=0)
series-=mean
std = series.std(axis=0)
series/=std

这可以像以前一样分为训练集和验证集。根据数据大小选择拆分时间——在本例中我有大约 840 个数据项，所以我在 792 处拆分（保留四年的数据点用于验证）：

split_time = 792
time_train = time[:split_time]
x_train = series[:split_time]
time_valid = time[split_time:]
x_valid = series[split_time:]

因为数据现在是一个 Numpy 数组，您可以使用与以前相同的代码从中创建一个窗口数据集来训练神经网络：

window_size = 24
batch_size = 12
shuffle_buffer_size = 48
dataset = windowed_dataset(x_train, window_size, 
                           batch_size, shuffle_buffer_size)
valid_dataset = windowed_dataset(x_valid, window_size, 
                                 batch_size, shuffle_buffer_size)

这应该使用与windowed_dataset本章前面的卷积网络相同的功能，增加了一个新的维度。使用 RNN、GRU 和 LSTM 时，您将需要这种形状的数据。

探索更大的数据集

我已经准备好数据，剥离标题并删除无关的空格。这样就很容易阅读这样的代码：

def get_data():
    data_file = "tdaily_cet.dat.txt"
    f = open(data_file)
    data = f.read()
    f.close()
    lines = data.split('\n')
    temperatures=[]
    for line in lines:
        if line:
            linedata = line.split(' ')
            temperatures.append(float(linedata[1]))

    series = np.asarray(temperatures)
    time = np.arange(len(temperatures), dtype="float32")
    return time, series

该数据集包含 90,663 个数据点，因此，在训练您的模型之前，请确保对其进行适当拆分。我使用了 80,000 的分割时间，留下 10,663 条记录进行验证。此外，适当更新窗口大小、批量大小和随机播放缓冲区大小。这是一个例子：

window_size = 60
batch_size = 120
shuffle_buffer_size = 240

其他一切都可以保持不变。正如您在图 11-11中所见，经过一百个时期的训练后，针对验证集的预测图看起来相当不错。

图 11-11。对真实数据的预测图

 这里有很多数据，所以让我们放大到最近一百天的数据（图 11-12）。

图 11-12。一百天数据的结果

 虽然图表总体上遵循数据曲线，并且使趋势大致正确，但还差得很远，尤其是在极端情况下，因此还有改进的余地。

同样重要的是要记住我们对数据进行了标准化，因此虽然我们的损失和 MAE 可能看起来很低，但这是因为它们基于标准化值的损失和 MAE，这些标准化值的方差比真实值低得多。因此，图 11-13显示的损失小于 0.1，可能会让您产生一种错误的安全感。