Python深度学习--学习笔记（十七）

结合 CNN 和 RNN 来处理长序列

运用一维卷积与循环层对文本进行学习，这里我们依然拿耶拿的天气数据进行举例。

• 处理数据

import os

data_dir = 'C:\\Users\\Administrator\\Desktop\\Keras_learn\\jena_climate'
fname = os.path.join(data_dir,'jena_climate_2009_2016.csv')

f = open(fname,encoding='utf-8')
data = f.read()
f.close()

lines = data.split('\n')
header = lines[0].split(',') #csv文件
lines = lines[1:]

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
    
mean = float_data[:200000].mean(axis=0)
float_data -= mean
std = float_data[:200000].std(axis=0)
float_data /= std

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 #10天
step = 3
delay = 144 #1天
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)

test_gen = generator(float_data,
                     lookback=lookback,
                     delay=delay,
                     min_index=300001,
                     max_index=None,
                     step=step,
                     batch_size=batch_size)

val_steps = (300000 - 200001 - lookback) // batch_size 
#类似与卷积层经过卷积核后的大小计算公式

test_steps = (len(float_data) - 300001 - lookback) // batch_size

在前面几节提到过，如不理解可以翻到之前学习笔记查看。
特别注意,以上代码中我将step从6改为3，这意味着从每一个小时提取一次数据改为每半个小时，其目的是为了更好的学习。

• 定义，训练模型

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

model = Sequential()
model.add(layers.Conv1D(32,(5,),activation='relu',input_shape=(None,float_data.shape[-1])))
model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32,(5,),activation='relu'))
model.add(layers.GRU(32,dropout=0.1,recurrent_dropout=0.5))
model.add(layers.Dense(1))

model.summary()

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)

• 绘制图像

epochs = range(1,21)
loss = history.history['loss']
val_loss = history.history['val_loss']

plt.plot(epochs,loss,'bo',label="Training loss")
plt.plot(epochs,val_loss,'b',label="Validation loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend()
plt.show()

从验证损失来看，这种架构的效果不如只用正则化 GRU，但速度要快很多。它查看了两倍的数据量，在本例中可能不是非常有用，但对于其他数据集可能非常重要。