Question

在进入代码之前，先对数据进行一些描述：

具有14个特征的时间序列，但我们只关注预测指数2处的温度。此外，给定数据的间隔为10分钟：

["Date Time","p (mbar)","T (degC)","Tpot (K)","Tdew (degC)","rh (%)","VPmax (mbar)","VPact (mbar)","VPdef (mbar)","sh (g/kg)","H2OCmmol/mol)","rho (g/m**3)","wv (m/s)","max. wv (m/s)","wd (deg)"]

接下来，作者解析文件并将其存储为numpy数组（注意：float_data不包含时间戳：

import numpy as np

float_data = np.zeros((len(lines), len(header) - 1))
for i, line in enumerate(lines):
    values = [float(x) for x in line.split(',')[1:]]
    float_data[i, :] = values

接下来是一个标准化步骤，我在这里跳过。到目前为止它很简单。以下步骤定义了一个生成元组(samples, targets)的生成器，其中samples是一批输入数据，targets是相应的目标温度数组。它需要以下参数：

data：浮点数据的原始数组，我们刚刚在上面的代码片段中对其进行了规范化。
lookback：我们的输入数据应该返回多少次。
延迟：未来我们的目标应该是多少次。
min_index和max_index：数据数组中的索引，用于分隔要绘制的时间步长。这对于保留一部分数据以进行验证以及另一部分用于测试非常有用。
shuffle：是否按时间顺序洗牌我们的样品。
batch_size：每批样本数。

步骤：我们对数据进行采样的时间段（以时间步长为单位）。我们将其设置为6以便每小时绘制一个数据点。

def generator(data, lookback, delay, min_index, max_index,
      shuffle=False, batch_size=128, step=6):

    if max_index is None:
        max_index = len(data) - delay - 1
    i = min_index + lookback
    while 1:
        if shuffle:
             rows = np.random.randint(
             min_index + lookback, max_index, size=batch_size)
        else:
            if i + batch_size >= max_index:
                i = min_index + lookback
        rows = np.arange(i, min(i + batch_size, max_index))
        i += len(rows)

        samples = np.zeros((len(rows),
                   lookback // step,
                   data.shape[-1]))
        targets = np.zeros((len(rows),))
        for j, row in enumerate(rows):
            indices = range(rows[j] - lookback, rows[j], step)
            samples[j] = data[indices]
            targets[j] = data[rows[j] + delay][1]
        yield samples, targets


 lookback = 1440  # Basically, going back 10 days
 step = 6         # Taking an hourly sample     
 delay = 144      # Want to forecast temperature for the next 24 hours
 batch_size = 128

 train_gen = generator(float_data,
              lookback=lookback,
              delay=delay,
              min_index=0,
              max_index=200000,
              shuffle=True,
              step=step,
              batch_size=batch_size)

 val_gen = generator(float_data,
            lookback=lookback,
            delay=delay,
            min_index=200001,
            max_index=300000,
            step=step,
            batch_size=batch_size)

现在，我理解代码的作用。如果我错了，请纠正我。它将以以下格式生成输入数据：

每批次将有128个序列，每个序列长240个。例如：

批次0：[[0-239]，[1-240]，[2-241]，... [127-366]]

批次1：[[128-367]，...，....]

在此之后，作者训练了一个简单的模型：

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop

model = Sequential()
model.add(layers.Flatten(input_shape=(lookback // step,   float_data.shape[-1])))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(1))

model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
                          steps_per_epoch=500,
                          epochs=20,
                          validation_data=val_gen,
                          validation_steps=val_steps)

我的问题

首先，我不明白为什么以这种方式生成数据并将其输入神经网络。换句话说，为什么数据看起来不像以下那样？：

批次0：[[0-240]，[241-479]，...........]

其次，在train_gen中为什么shuffle参数设置为True？它会导致数据丢失时间顺序。

Answer 1

数据的索引从0开始：由于序列长度为240：

len（[0-239]）= 240

当您想训练时，将随机播放设置为True，当您要进行评估时，将其设置为False

Answer 2

我想这是Francois Chollet的Python深度学习示例。回头看是从中构建观察值的观察值数量。

步骤将定义观察顺序：

第i个观察指标如下：-

X -- [i, i+step, i+(2*Step), i+(3*step),...  .. ,(i+look_back/step)] 
y --- [(i+look_back/step)+delay]

batch_size =这样的观察次数

例如：输入数据

   [[996.57,  -8.41, 265.01],
   [996.53,  -8.51, 264.91],
   [996.51,  -8.31, 265.12],
   [996.51,  -8.27, 265.15],
   [996.5 ,  -8.05, 265.38],
   [996.5 ,  -7.62, 265.81],
   [996.5 ,  -7.62, 265.81],
   [996.5 ,  -7.91, 265.52],
   [996.53,  -8.43, 264.99],
   [996.62,  -8.76, 264.66],
   [996.62,  -8.88, 264.54],
   [996.63,  -8.85, 264.57],
   [996.74,  -8.83, 264.58],

对于以下参数：

lookback = 6 step = 2 delay = 2 batch_size = 3

输出为：

 array([[[996.57,  -8.41, 265.01],
     [996.51,  -8.31, 265.12],
     [996.5 ,  -8.05, 265.38]],

    [[996.53,  -8.51, 264.91],
     [996.51,  -8.27, 265.15],
     [996.5 ,  -7.62, 265.81]],

    [[996.51,  -8.31, 265.12],
     [996.5 ,  -8.05, 265.38],
     [996.5 ,  -7.62, 265.81]]]), array([-8.43, -8.76, -8.88])]

设置shuffle = True并不重要，因为观察总是从索引回溯到特定索引进行的。

过去10天的小时读数用于预测24小时后的温度。因此，以这种格式[[0-240]，[241-479]，...........]生成数据将无法提供用于预测（24小时+10分钟）温度的观测值

Answer 3

每个sample包含batch_size个序列，每个序列包含10天的数据，即每小时的数据点，因此考虑到24，将是10天的24*10 = 240个数据点每天的数据点。因此[0-239]拥有240个数据点，相当于10天的数据量。

shuffle参数设置为True，以便为rows numpy数组选择的索引将在起点和终点之间包含随机但连续的索引，即min_index + lookback, max_index, size=batch_size大小为128。使用此rows数组，我们构建了sample。

因此总结： sample 3D张量的形状为(128,240,14)的形状batch_size，相当于10天的数据点，考虑到由于step = 6我们每小时需要一个数据点连续10天和每个数据点的14列要素。

使用Keras

3 个答案: