import jsonimport numpy as npfrom datetime import dateclass Node:
    def __init__(self, _id, parent_id, dates, mode, name=None, order=None):
        '''
            创建节点

            参数：
                _id: 节点 id
                parent_id：父节点id
                dates：日期列表
                mode：'node' / 'meter'
                name：节点名称
                order：节点序号
        '''
        self._id = _id
        self.parent_id = parent_id
        self.name = name
        self.order = order
        self.dates = dates
        self.mode = mode
        self.values = [0] * len(dates)
        self.parent = None
        self.children = []    def add_child(self, node):
        '''
        添加子节点
        
        参数：
            node：子节点
        '''
        if node not in self.children:
            self.children.append(node)
            node.parent = self    def get_values(self):
        '''
        获取节点能耗数据

        返回：
           节点能耗数据 
        '''
        sum_values = [self.values]        for child in self.children:
            sum_values.append(child.get_values())        return np.asarray(sum_values).sum(0).tolist()    
    def set_value(self, date, value):
        '''
        设置指定日期的 meter 节点能耗数据

        参数：
            date：日期
            value：能耗数据
        '''
        assert self.mode=='meter'
        self.values[self.dates.index(date)] += value    def set_values(self, values):
        '''
        设置 meter 节点能耗数据
        
        参数：
            values：能耗数据
        '''
        assert self.mode=='meter'
        assert len(values) == len(self.dates)
        self.values = values    
    def reset_dates(self, dates):
        '''
        重设日期

        参数：
            dates：日期
        '''
        self.dates = dates
        self.values = [0] * len(dates)        for child in self.children:
            child.reset_dates(dates)    def meters(self):
        '''
        获取所有 meter

        返回：
            所有 meter
        '''
        if self.mode == 'meter':            return [self]        else: 
            meters = []            for child in self.children:
                meters += child.meters()            return meters    def nodes(self):
        '''
        获取所有 node

        返回：
            所有 node
        '''
        if self.mode == 'meter':            return []        else: 
            nodes = [self]            for child in self.children:
                nodes += child.nodes()            return nodes    
    def __repr__(self):
        '''
        获取节点信息

        返回：
            节点信息
        '''
        if self.mode == 'meter':            return json.dumps({                'mode': 'meter',                'meter_id': self._id,                'logic_id': self.parent_id,                'values': self.values,
            }, indent=4, ensure_ascii=False)        else:            return json.dumps({                'mode': 'node',                'logic_id': self._id,                'parent_id': self.parent_id,                'name': self.name,                'order': self.order,                'values': self.get_values(),                'children': {child._id: json.loads(child.__repr__()) for child in self.children}
            }, indent=4, ensure_ascii=False)    def dump(self, json_file):
        '''
        保存节点

        参数：
            json_file：json 文件
        '''
        with open(json_file, 'w', encoding='UTF-8') as f:
            f.write(self.__repr__()) 

    @staticmethod
    def load(json_file, dates):
        '''
        加载节点

        参数：
            json_file：json 文件
            dates：日期

        返回：
            节点
        '''
        with open(json_file, 'r', encoding='UTF-8') as f:
            node_info = json.load(f)            return Node.create_node(node_info, dates)    @staticmethod
    def create_node(node_info, dates):
        '''
        创建节点

        参数：
            node_info：节点信息
            dates：日期

        返回：
            节点
        '''
        if node_info['mode'] == 'node':
            node = Node(node_info['logic_id'], node_info['parent_id'], dates, 'node', node_info['name'], node_info['order'])            for child_info in node_info['children'].values():
                node.add_child(Node.create_node(child_info, dates))        else:
            node = Node(node_info['meter_id'], node_info['logic_id'], dates, 'meter')
            node.values = node_info['values']        return node

# 根节点数据data_json = 'root.json'# 生成日期序列dates = [    str(date.fromordinal(i).strftime("%Y%m%d000000"))    for i in range(date(2021, 8, 1).toordinal(), date(2022, 3, 31).toordinal() + 1)
]# 加载根节点数据root = Node.load(data_json, dates)# 打印节点信息print({   'name': root.name, # 节点名称
   'order': root.order, # 节点序号
   'id': root._id, # 节点 id
   'parent_id': root.parent_id, # 父节点 id
   'children_ids': [child._id for child in root.children], # 子节点 id})

# 获取所有传感器meters = root.meters()# 获取所有传感器能耗数据meters_values = []for meter in meters:
    meters_values.append(meter.get_values())
meters_values = np.asarray(meters_values).transpose(1, 0)# 切分数据集split_num = 21 # 验证集大小train_dataset = meters_values[0: -split_num, :]
val_dataset = meters_values[-split_num: , :]
train_num = train_dataset.shape[0]
val_num = val_dataset.shape[0]# 数据预处理max_value = train_dataset.max()
train_dataset /= max_value
val_dataset /= max_value

import paddleimport paddle.nn as nnfrom paddle.optimizer import Adam# 构建 LSTM 模型net = nn.LSTM(626, 626, num_layers=1, direction='forward')# 配置 Adam 优化器opt = Adam(parameters=net.parameters(), learning_rate=0.0001)# 配置训练参数batch_size = 256 # 批处理大小steps = 20000 # 迭代次数days = 7 # 时间窗口log_iter = 20 # log 步幅keep_iter = 999999999 # 停止迭代步幅min_loss = 9999999999 # 最小 lossbest_step = 0 # 最佳迭代次数submit_csv = 'submit.csv' # 提交文件best_model = 'best_model.pdparams' # 最佳模型文件

for step in range(steps):    # 数据采样
    input_datas = []
    label_datas = []    for _ in range(batch_size):
        start = np.random.randint(0, train_num - days - 1)
        end = start + days
        input_datas.append(train_dataset[start: end, :])
        label_datas.append(train_dataset[end, :])
    input_datas = paddle.to_tensor(input_datas, dtype='float32')
    label_datas = paddle.to_tensor(label_datas, dtype='float32')    # 前向计算
    h = net(input_datas)[1][0][-1]    # 计算损失
    loss = nn.functional.mse_loss(h, label_datas)    # 反向传播
    loss.backward()    # 优化模型
    opt.step()    # 清除梯度
    opt.clear_grad()    # 模型评估
    if step % log_iter == 0:
        net.eval()        with paddle.no_grad():
            input_datas = paddle.to_tensor([train_dataset[-days:,: ]], dtype='float32') 
            predicts = []            for _ in range(val_num):
                h = net(input_datas)[1][0][-1].clip(0)
                predicts.append(h)
                input_datas = paddle.concat([input_datas[:, 1:, :], h[None,...]], 1)
            predicts = paddle.concat(predicts, 0)
            label_datas = paddle.to_tensor(val_dataset, dtype='float32')
            loss = nn.functional.mse_loss(predicts * max_value, label_datas * max_value).item()            # 模型保存
            if loss < min_loss:
                min_loss = loss
                best_step = step
                paddle.save(net.state_dict(), best_model)                print('saving best model, loss: %f step: %d' % (loss, step))
        net.train()    
    if (step - best_step) > keep_iter:        break

net.set_state_dict(paddle.load(best_model))
net.eval()with paddle.no_grad():
    input_datas = paddle.to_tensor([val_dataset[-days:,: ]], dtype='float32') 
    predicts = []    for _ in range(7):
        h = net(input_datas)[1][0][-1].clip(0)
        predicts.append(h)
        input_datas = paddle.concat([input_datas[:, 1:, :], h[None,...]], 1)
    predicts = paddle.concat(predicts, 0)
    predicts = (predicts * max_value).numpy().transpose(1, 0)
net.train()

dates = [    str(date.fromordinal(i).strftime("%Y%m%d000000"))    for i in range(date(2022, 4, 1).toordinal(), date(2022, 4, 7).toordinal() + 1)
]
root.reset_dates(dates)
meters = root.meters()for (meter, predict) in zip(meters, predicts):
    meter.set_values(predict.tolist())

publics = []
business = []for node in root.nodes():    if node.order in [2, 31, 72]:
        publics.append(node.get_values())    elif node.order in [29, 58, 60, 124]:
        business.append(node.get_values())

publics = np.asarray(publics).sum(0).tolist()
business = np.asarray(business).sum(0).tolist()with open(submit_csv, 'w', encoding='UTF-8') as f:
    f.write('c_order,c_logic_id,c_name,c_parent,2022/4/1,2022/4/2,2022/4/3,2022/4/4,2022/4/5,2022/4/6,2022/4/7\n')
    f.write('998,998,公共用电,998,'+','.join([str(_) for _ in publics])+'\n')
    f.write('999,999,商户用电,999,'+','.join([str(_) for _ in business])+'\n')

net.set_state_dict(paddle.load('baseline.pdparams'))
net.eval()with paddle.no_grad():
    input_datas = paddle.to_tensor([val_dataset[-days:,: ]], dtype='float32') 
    predicts = []    for _ in range(7):
        h = net(input_datas)[1][0][-1].clip(0)
        predicts.append(h)
        input_datas = paddle.concat([input_datas[:, 1:, :], h[None,...]], 1)
    predicts = paddle.concat(predicts, 0)
    predicts = (predicts * max_value).numpy().transpose(1, 0)
net.train()
dates = [    str(date.fromordinal(i).strftime("%Y%m%d000000"))    for i in range(date(2022, 4, 1).toordinal(), date(2022, 4, 7).toordinal() + 1)
]
root.reset_dates(dates)
meters = root.meters()for (meter, predict) in zip(meters, predicts):
    meter.set_values(predict.tolist())
publics = []
business = []for node in root.nodes():    if node.order in [2, 31, 72]:
        publics.append(node.get_values())    elif node.order in [29, 58, 60, 124]:
        business.append(node.get_values())

publics = np.asarray(publics).sum(0).tolist()
business = np.asarray(business).sum(0).tolist()with open('baseline.csv', 'w', encoding='UTF-8') as f:
    f.write('c_order,c_logic_id,c_name,c_parent,2022/4/1,2022/4/2,2022/4/3,2022/4/4,2022/4/5,2022/4/6,2022/4/7\n')
    f.write('998,998,公共用电,998,'+','.join([str(_) for _ in publics])+'\n')
    f.write('999,999,商户用电,999,'+','.join([str(_) for _ in business])+'\n')