def get_column_minmax(self): """ Initial column_valid, column_min, column_max before normalize """ delta_thres = { 'generator_p': 0.1, 'generator_v': 0.001, 'load_p': 0.1, 'load_q': 0.1, 'station_pg': 0.1, 'station_pl': 0.1, 'station_ql': 0.1, 'dcline_p': 0.1, 'dcline_q': 0.1, 'dcline_acu': 0.001, 'ed': 0.00001 } self.column_min = np.nanmin(self.input_data, axis=0) self.column_max = np.nanmax(self.input_data, axis=0) max_min = self.column_max - self.column_min elem_info = load_elem_info(self.model_path + "/elem_info.dat") gens = elem_info[elem_info['type'] == 5] for i, (t, elem) in enumerate(self.input_layer): if t == 'generator_p': self.column_min[i] = gens['limit1'][elem] self.column_max[i] = gens['limit2'][elem] elif t == 'station_pg': sub_gens = gens[gens.station == elem] self.column_min[i] = np.sum(sub_gens['limit1']) self.column_max[i] = np.sum(sub_gens['limit2']) elif t == 'generator_v' or t == 'dcline_acu': self.column_min[i] = 0.9 self.column_max[i] = 1.15 # elif t=='station_pl' or t=='station_ql' or t=='ed_ed' # or t=='dcline_p' or t=='dcline_q': else: d80 = (self.column_max[i] - self.column_min[i]) / 8 self.column_min[i] -= d80 self.column_max[i] += d80 self.column_valid[i] = self.column_valid[i] \ & (not np.isnan(max_min[i])) \ & (max_min[i] > delta_thres[t])
def load_net(self, path, out_node=None, include_areas=[], exclude_names=[]): """ Load ghnet.dat :param path: str. Contains ghnet.dat, st_info.dat, elem_info.dat. :param out_node: str or None. Output node name. :param include_areas: [int]. Include areas, [] for all. :param exclude_names: [str]. Exclude station names. :return: """ self.ghnet = pd.read_table(path + '/ghnet.dat', encoding='gbk', sep=' ') self.ghnet.sort_values(by='layer', inplace=True) self.st_info = load_station_info(path + '/st_info.dat') self.elem_info = load_elem_info(path + '/elem_info.dat') self.gens = self.elem_info[self.elem_info['type'] == 5] self.ed_info = pd.read_table(path + '/ed_info.dat', encoding='gbk', sep=' ') self.trim_net(out_node, include_areas, exclude_names, inplace=True) # input stations self.nodes = [] used_input_names = set() upper_names = [] start = 0 input_layer_no = self.ghnet['layer'].min() for layer in range(input_layer_no, self.ghnet['layer'].max() + 1): lower_names = upper_names.copy() upper_names = [] used_subnet_names = [] nodes = [] for _, sub in self.ghnet[self.ghnet['layer'] == layer].iterrows(): # if sub['upper'] in self.st_info.index: # continue ss = sub['lower'].split('+') # ss.append(sub['upper']) # ss = list(set(ss)) node = Node(layer, sub['upper']) if layer == input_layer_no or layer == input_layer_no + 1: # 220kV and 500kV for name in ss: ret = self.get_station_input(name) self.input_layer.extend(ret) if name in used_input_names: print("station(%s) has been used as input" % name) else: used_input_names.add(name) node.in_begin = start node.in_end = len(self.input_layer) # node.inputs = list(range(node.in_begin, node.in_end)) start = node.in_end for name in ss: if name in lower_names: lower_node_name = node.make_name(layer - 1, name) lower_node = self.get_node(lower_node_name) if lower_node is not None: node.subnets.append(lower_node_name) used_subnet_names.append(name) if node.in_begin == node.in_end and len(node.subnets) == 0: print("node(%s) has no input, drop it" % node.name) continue nodes.append(node) upper_names.append(sub['upper']) not_used_lower = set(lower_names) - set(used_subnet_names) if not_used_lower: print("not used lower node: " + '+'.join(not_used_lower)) # raise NotImplementedError('%d node(s) are not connected'%len(not_used_lower)) self.nodes.append(nodes) print("load ghnet successfully")
input_fmts = [] output_fmts = [] lmd_indices = [] for mn in model_names: model_path = os.path.join(path, mn) input_fmt = load_input_fmt(os.path.join(model_path, 'input.txt')) output_fmt = load_output_fmt(os.path.join(model_path, 'output.txt')) net = GHNet("inf", input_types=None) net.reload_net(model_path) net.input_fmt = input_fmt net.build_multi_reg(len(output_fmt), activation=tf.keras.layers.LeakyReLU()) net.pre_model.load_weights(os.path.join(model_path, 'cct.h5')) nets.append(net) input_fmts.append(input_fmt) output_fmts.append(output_fmt) elem_info = load_elem_info(os.path.join(model_path, 'elem_info.dat')) # st_info = load_station_info(os.path.join(model_path, 'st_info.dat')) lmd_indices.append(get_lmd_indices(input_fmt, elem_info, None)) # online if sys.argv[1] == '-online': start_time = datetime.datetime.now() results = run_online(sys.argv[2], nets, input_fmts, lmd_indices) end_time = datetime.datetime.now() log_txt = 'online run: start_time = %s, end_time = %s\n' % ( datetime.datetime.strftime(start_time, '%Y-%m-%d %H:%M:%S')+'.%d'%start_time.microsecond, datetime.datetime.strftime(end_time, '%Y-%m-%d %H:%M:%S')+'.%d'%end_time.microsecond ) with open(os.path.join(path, 'online.log'), 'a') as fp: fp.write(log_txt) # trend