深度学习之负荷分解——LSTM（一对多）任务场景

1.任务场景

以家庭为例，假设该家庭有m种电器和总负荷的曲线，其中，总负荷为,各个电器的负荷有（m是电器个数，n是n个时刻）。我们需要通过对总负荷曲线进行分解，识别出该负荷有几种电器同时运行实现。

之前的博客已经用NILMTK的组合优化和因子隐马尔可夫实现过了，因为效果不是很好，考虑用LSTM实现。

2.算法原理

RNN是循环神经网络，与CNN不同，循环神经网络可以很好地处理文本数据变长且有序的输入序列。RNN设计的初衷是解决长距离输入之间的依赖，但是在用基于时间距离的反向传播算法（BPTT）时，会出现神经网络中的梯度消失问题。LSTM（长短时记忆网络）和GRU通过加入门控机制，来弥补梯度消失问题。

遗忘门：损失函数是sigmoid。

记忆门：损失函数是tanh函数，生成候选记忆。

输出门：损失函数是sigmoid。

当输入的序列中没有重要信息时，LSTM的遗忘门的值接近于1，输入门的值接近于0，此时，过去的记忆将会被保存，从而实现长期记忆的功能。当输出的序列中有重要信息时，输入门为1，遗忘门接近于0，这样旧的记忆就会被遗忘，新的重要记忆被重新记忆。

3.理论实现

（1）基于Tensorflow的Keras

首先，建立一个LSTM模型，输入维度是批次大小（batch_size），特征向量值（n_in，vector），因为这里是1对多，因此，n_in应为1。

RepeatVector是如果输入的形状为（None,32），经过添加RepeatVector(3)层之后，输出变为（None,3,32）,RepeatVector不改变我们的步长，改变我们的每一步的维数（即：属性长度）

TimeDistributed和Dense一起配合使用，主要应用于一对多，多对多的情况。首先使用TimeDistributed（Dense（8），input_shape = (1,16)）把每一步的维度为16变成8，不改变步长的大小，若该层的批输入形状然后(50, 10, 16)，则这一层之后的输出为(50, 10, 8)

这里vetor=120，经数据处理之后，时间并非是一秒一个负荷数据。代表每120个时刻的负荷数据构成一组输入变量。

model = Sequential()
model.add(LSTM(150, batch_input_shape=(batch_size, n_in, vector), stateful=True))
model.add(RepeatVector(n_out))
model.add(LSTM(150, return_sequences=True, stateful=True))
model.add(TimeDistributed(Dense(vector, activation='softmax')))
print(model.summary())

（2）基于pytorch

（暂时不会，后期更新）

4.实战

（1）基于Tensorflow的Keras

读取数据redd的功率数据集

import pandas as pd
import numpy as np
import os
from keras.models import Sequential
from keras.layers import LSTM,Dense,TimeDistributed,RepeatVector
import tensorflow as tf

from sklearn.model_selection import train_test_split

def read_data_all(file_dir):    
    data = []
    for parent, dirnames, filenames in os.walk(file_dir):
        if parent==file_dir:
            print('父目录')
        else:
            for curDir, dirs, files in os.walk(parent):
                
                print("当前文件夹：",curDir)
#                fl = open(parent+'/'+'labels.dat','r',encoding='utf-8')
#                for f in fl.readlines():
#                    f = f.split(' ')[1].strip()
#                    labels.append(f)
                
                for i in range(len(files)-1):
                    
                    fo = open(parent+'/'+files[i],'r',encoding='utf-8')
#                    fo = pd.DataFrame(fo.readlines(),columns=['1'])
                    
#                    channel_1 = fo['1'].str.strip().str.split(' ',expand=True)
#                    channel_1 = channel_1.rename(columns={0:'date',1:'power'})
#                    channel_1['date']=channel_1['date'].astype(int)
#                    channel_1['label']=labels[i]
#                    data = pd.concat([data,channel_1],axis=0)
                    for file in fo.readlines():
                        file = file.strip()
                        file =[float(i) for i in  file.split(' ')]
                        data.append((int(file[0]),file[1],str(i+1),curDir.split('/')[-1]))
    return data


#获取数据
file_dir = 'F:/aayu/负荷分解/low_freq/'
data = read_data_all(file_dir)

选择house_1为训练数据，并进行数据预处理

#选择第一个家庭进行训练
data = pd.DataFrame(data,columns=['date','power','type','house'])
house_1 =data[data['house']=='house_1'] 

#house_1 = house_1.set_index(['date'])

#各个电器时间点拼接
elec_type = list(set(house_1['type'].tolist()))
house = pd.DataFrame()
for i in elec_type:
    print(i)
    e = house_1[house_1['type']==i][['date','power']]
    e = e.rename(columns={'power':i})
    e = e.set_index(['date'])
    print(e.shape)
    house = pd.concat([house,e],axis=1)
    print(house.shape)
    
#处理缺失
rows = []
for row in house.index[house.isnull().sum(axis=1)>0]:
    rows.append(row)
house = house.drop(rows,axis=0)
#  for i in list(Udata.columns[Udata.isnull().sum(axis=0)>0]):
#                columnsU.append(i)
house = house.drop(['12'],axis=1)

填充1，mains
#house['1'] = house['1'].fillna(house['1'].mean())

#将用电量小的电器也做剔除
#columns = house[['3','4','5','6','7','8','9','10','11','13','14','15','16','17','18','19','20']].sum().sort_values(ascending=False)[:5].index
#columns = np.append(columns,['1'])
#columns = np.append(columns,['2'])
#house=house[columns]


elec_y = []
elec_X_1= []
elec_X_2= []
for j in range(0,house.shape[0],120):
#        print(j)
        if j+120>house.shape[0]: #
            print('data limits')
        else:
#            print(j)
#            print(len(elec[j:j+3600]))
            elec_X_1.append((np.array(house[j:j+120][['1']]).T))
            elec_X_2.append((np.array(house[j:j+120][['2']]).T))
            elec_y.append((np.array(house[j:j+120][['3','4','5','6','7','8','9','10','11','13','14','15','16','17','18','19']]).T))



X = np.array(elec_X_1)
y = np.array(elec_y)

通过sklearn进行数据集划分

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.1) 

使用Keras进行模型训练

batch_size = 2
n_in = 1
vector = 120
n_out = 20


model = Sequential()
model.add(LSTM(150, batch_input_shape=(batch_size, n_in, vector), stateful=True))
model.add(RepeatVector(n_out))
model.add(LSTM(150, return_sequences=True, stateful=True))
model.add(TimeDistributed(Dense(vector, activation='softmax')))
print(model.summary())


model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])  
model.fit(X_train, y_train, epochs=20, validation_data=(X_test, y_test), batch_size=batch_size)  

5.模型优化

在进行模型训练时，表现性并不好，忽略数据质量的问题，可以考虑进行模型调参。模型调参一般从以下方面进行考虑：

• 神经网络的层数

• 每层神经元的个数

• 如何初始化Weights和biases

• loss函数选择哪一个

• 选择何种Regularization？L1,L2

• Regularization parameter lambda 选择多大合适

• 激励函数如何选择

• 是否使用dropout

• 训练集多大比较合适

• mini-batch选择多大

• 学习率多少合适

• 选择何种梯度下降算法

• 何时停止Epoch训练

• 自己模型的超参数

参考资料

keras中TimeDistributed和RepeatVector的解释

Pytorch TimeDistributed 层封装器

keras中使用LSTM实现一对多和多对多