class_docstr: Desc: Data preprocessing,
        Here, e.g.    15 days for training,
                      3 days for validation,
                      and 6 days for testing
code: def build_graph_data(self, df_data):
      cols_data = df_data.columns[self.start_col :]
      df_data = df_data[cols_data]
      raw_df_data = self.raw_df_data[cols_data]
  
      data = df_data.values
      data = np.reshape(
          data, [self.capacity, self.total_size, len(cols_data)]
      )
      raw_data = raw_df_data.values
      raw_data = np.reshape(
          raw_data, [self.capacity, self.total_size, len(cols_data)]
      )
  
      border1s = [
          0,
          self.train_size - self.input_len,
          self.train_size + self.val_size - self.input_len,
      ]
      border2s = [
          self.train_size,
          self.train_size + self.val_size,
          self.train_size + self.val_size + self.test_size,
      ]
  
      self.data_mean = np.expand_dims(
          np.mean(
              data[:, border1s[0] : border2s[0], 2:],
              axis=(1, 2),
              keepdims=True,
          ),
          0,
      )
      self.data_scale = np.expand_dims(
          np.std(
              data[:, border1s[0] : border2s[0], 2:],
              axis=(1, 2),
              keepdims=True,
          ),
          0,
      )
  
      # self.data_mean = np.mean(data[:, border1s[0]:border2s[0], 2:]).reshape([1, 1, 1, 1])
      # self.data_scale = np.std(data[:, border1s[0]:border2s[0], 2:]).reshape([1, 1, 1, 1])
  
      border1 = border1s[self.set_type]
      border2 = border2s[self.set_type]
  
      self.raw_df = []
      for turb_id in range(self.capacity):
          self.raw_df.append(
              pd.DataFrame(
                  data=raw_data[
                      turb_id, border1 + self.input_len : border2
                  ],
                  columns=cols_data,
              )
          )
  
      data_x = data[:, border1:border2, :]
      data_edge = data[:, border1s[0] : border2s[0], -1]
      edge_w = np.corrcoef(data_edge)
  
      k = 5
      topk_indices = np.argpartition(edge_w, -k, axis=1)[:, -k:]
      rows, _ = np.indices((edge_w.shape[0], k))
      kth_vals = edge_w[rows, topk_indices].min(axis=1).reshape([-1, 1])
  
      row, col = np.where(edge_w > kth_vals)
      edges = np.concatenate(
          [row.reshape([-1, 1]), col.reshape([-1, 1])], -1
      )
      graph = pgl.Graph(num_nodes=edge_w.shape[0], edges=edges)
      return data_x, graph
  
imports: import os
  import time
  import datetime
  import numpy
  import pandas
  import paddle
  from paddle.io import Dataset
  import pgl
  from pgl.utils.logger import log
label_desc: Use image node_id 7 for calling the PGL4WPFDataset obj's underlying member method code with example usage: obj.build_graph_data(df_data) and returns: data_x,  graph