import numpy as np import pandas as pd import pickle import os import sys # append the path of the parent directory sys.path.append("..") from abstractions import * from runtime_monitors import * # def monitors_offline_construction(network_name, network_folder_path, classes, layers_indexes, taus): # appendixes = ["_correctly_classified_features.csv", "_incorrectly_classified_features.csv"] # product = ((i, y) for i in layers_indexes for y in classes) # for i, y in product: # # load obtained features to creat reference # path_bad_features = network_folder_path +"Layer_minus_" + str(i) + "/class_" + str(y) + appendixes[1] # path_good_features = network_folder_path +"Layer_minus_" + str(i) + "/class_" + str(y) + appendixes[0] # bad_feat_clustering_results = [] # good_feat_clustering_results = [] # if os.path.exists(path_bad_features): # df_bad_features = pd.read_csv(path_bad_features) # bad_features_to_cluster = df_bad_features[df_bad_features.columns[3:]].to_numpy() # bad_features_index = df_bad_features["index"].to_numpy() # # load clustering results to partition the features # bad_feat_clustering_results_path = network_folder_path + "Layer_minus_" + str(i) + "/clustering_results_class_" + str(y) + appendixes[1] # if os.path.exists(bad_feat_clustering_results_path): # bad_feat_clustering_results = pd.read_csv(bad_feat_clustering_results_path) # if os.path.exists(path_good_features): # df_good_features = pd.read_csv(path_good_features) # good_features_to_cluster = df_good_features[df_good_features.columns[3:]].to_numpy() # good_features_index = df_good_features["index"].to_numpy() # # load clustering results to partition the features # good_feat_clustering_results_path = network_folder_path + "Layer_minus_" + str(i) + "/clustering_results_class_" + str(y) + appendixes[0] # n_dim = good_features_to_cluster.shape[1] # if os.path.exists(good_feat_clustering_results_path): # good_feat_clustering_results = pd.read_csv(good_feat_clustering_results_path) # for tau in taus: # good_loc_boxes = [] # bad_loc_boxes = [] # if len(bad_feat_clustering_results): # # load clustering result related to tau # bad_feat_clustering_result = bad_feat_clustering_results[str(tau)] # # determine the labels of clusters # bad_num_clusters = np.amax(bad_feat_clustering_result) + 1 # bad_clustering_labels = np.arange(bad_num_clusters) # # extract the indices of vectors in a cluster # bad_clusters_indices = [] # for k in bad_clustering_labels: # bad_indices_cluster_k, = np.where(bad_feat_clustering_result == k) # bad_clusters_indices.append(bad_indices_cluster_k) # # creat local box for each cluster # bad_loc_boxes = [Box() for i in bad_clustering_labels] # for j in range(len(bad_loc_boxes)): # bad_points_j = [(bad_features_index[i], bad_features_to_cluster[i]) for i in bad_clusters_indices[j]] # bad_loc_boxes[j].build(n_dim, bad_points_j) # if len(good_feat_clustering_results): # # load clustering result related to tau # good_feat_clustering_result = good_feat_clustering_results[str(tau)] # # determine the labels of clusters # good_num_clusters = np.amax(good_feat_clustering_result) + 1 # good_clustering_labels = np.arange(good_num_clusters) # # extract the indices of vectors in a cluster # good_clusters_indices = [] # for k in good_clustering_labels: # good_indices_cluster_k, = np.where(good_feat_clustering_result == k) # good_clusters_indices.append(good_indices_cluster_k) # # creat local box for each cluster # good_loc_boxes = [Box() for i in good_clustering_labels] # for j in range(len(good_loc_boxes)): # good_points_j = [(good_features_index[i], good_features_to_cluster[i]) for i in good_clusters_indices[j]] # good_loc_boxes[j].build(n_dim, good_points_j) # # creat the monitor for class y at layer i # monitor_y_i = Monitor("Box", network_name, y, i, good_ref=good_loc_boxes, bad_ref=bad_loc_boxes) # # save the created monitor # monitor_stored_folder_path = network_folder_path + "Monitors/" # if not os.path.exists(monitor_stored_folder_path): # os.makedirs(monitor_stored_folder_path) # monitor_stored_path = monitor_stored_folder_path + network_name + "_monitor_for_class_" + str(y) + "_at_layer_minus_" + str(i) + "_tau_" + str(tau) + ".pkl" # with open(monitor_stored_path, 'wb') as f: # pickle.dump(monitor_y_i, f) def monitor_construction_from_features(features, taus, clustering_results, class_name, monitor_saving_folder): # if os.path.exists(clustering_result_path): # clustering_results = pd.read_csv(clustering_result_path) # else: # raise RuntimeError("Please partition your data first!") for tau in taus: loc_boxes = [] if len(features): n_dim = features.shape[1] # load clustering result related to tau clustering_result = clustering_results[str(tau)] # determine the labels of clusters num_clusters = np.amax(clustering_result) + 1 clustering_labels = np.arange(num_clusters) # extract the indices of vectors in a cluster clusters_indices = [] for k in clustering_labels: indices_cluster_k, = np.where(clustering_result == k) clusters_indices.append(indices_cluster_k) # creat local box for each cluster loc_boxes = [Box() for i in clustering_labels] for j in range(len(loc_boxes)): points_j = [(i, features[i]) for i in clusters_indices[j]] loc_boxes[j].build(n_dim, points_j) else: raise RuntimeError("There exists no feature for building monitor!!") # creat the monitor for class y at layer i monitor = Monitor(good_ref=loc_boxes) # save the created monitor if not os.path.exists(monitor_saving_folder): os.makedirs(monitor_saving_folder) monitor_saving_path = monitor_saving_folder + "monitor_for_clustering_parameter" + "_tau_" + str(tau) + ".pkl" with open(monitor_saving_path, 'wb') as f: pickle.dump(monitor, f)