diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..eeb2f00 Binary files /dev/null and b/.DS_Store differ diff --git a/.gitignore b/.gitignore index 4dc5f4d..25a4441 100644 --- a/.gitignore +++ b/.gitignore @@ -175,4 +175,5 @@ cython_debug/ #Project specific output/ -version.py \ No newline at end of file +.DS_Store +version.py diff --git a/HEROS_Demo_Notebook.ipynb b/HEROS_Demo_Notebook.ipynb index c38848e..b54769d 100644 --- a/HEROS_Demo_Notebook.ipynb +++ b/HEROS_Demo_Notebook.ipynb @@ -98,11 +98,16 @@ "stored_model_iterations = '10,50,100' # Specified Phase II iterations where the current {MP} is archived for external evaluation (e.g. '10,50,100', or None)\n", "verbose = True # Run in 'verbose' mode - display run details\n", "\n", + "# Phase Alternation and Tree Initialization Hyperparameters ------------------------------------------------------\n", + "rule_pop_init = 'dt_bstrap' # Specifies rule population pre-initialization method (None, 'load','dt', or 'dt_bstrap') Experimental - recommended to leave to None\n", + "alternate = 5 # Specifies number of alternations - (e.g. 0 or 5, where 0 is original HEROS with no alternation)\n", + "alternate_mode = 'equal' # Specifies method for allocating resources across alternating phases (if alternate > 0) ('limit', 'converge', or 'equal') Experimental - recommended to leave to 'equal'\n", + "\n", "# In-Development HEROS Hyperparameters (Recommend not changing) -------------------------------------------------\n", "outcome_type = 'class' # Only 'class' (i.e. classification outcome) is operational in current implementation\n", "fitness_function = 'pareto' # Fitness function for Phase I rule discovery ('accuracy' or 'pareto') Pareto is strongly recommended unless analyzing clean problems.\n", "feat_track = 'end' # Feature tracking strategy applied (None, 'add', 'wh', 'end') Experimental - recommended to leave to None\n", - "rule_pop_init = None # Specifies rule population pre-initialization method (None, 'load', or 'dt') Experimental - recommended to leave to None" + "feedback = False # TBD - recommended to leave False\n" ] }, { @@ -129,6 +134,15 @@ } ], "source": [ + "import sys\n", + "import os\n", + "\n", + "# Add the project root so Python sees src/skheros/*\n", + "project_root = os.path.abspath(\"./src\")\n", + "if project_root not in sys.path:\n", + " sys.path.insert(0, project_root)\n", + "\n", + "\n", "# Load heros algorithm ---------------------------------------------------------\n", "if load_from_cloned_repo: # Load HEROS algorithm locally from cloned github repository\n", " from src.skheros.heros import HEROS\n", @@ -188,24 +202,30 @@ " train_data_path = 'evaluation/datasets/partitioned/multiplexer/A_multiplexer_6_bit_500_inst_CV_Train_1.txt'\n", " test_data_path = 'evaluation/datasets/partitioned/multiplexer/A_multiplexer_6_bit_500_inst_CV_Test_1.txt'\n", " excluded_column = 'Group'\n", + " rule_pop_path = 'A_multiplexer_6_bit_500_inst_CV_Train_1/rule_pop.csv'\n", "elif example_dataset == 'MUX11': # 11-bit Multiplexer\n", " train_data_path = 'evaluation/datasets/partitioned/multiplexer/B_multiplexer_11_bit_5000_inst_CV_Train_1.txt'\n", " test_data_path = 'evaluation/datasets/partitioned/multiplexer/B_multiplexer_11_bit_5000_inst_CV_Test_1.txt'\n", " excluded_column = 'Group'\n", + " rule_pop_path = 'B_multiplexer_11_bit_5000_inst_CV_Train_1/rule_pop.csv'\n", "elif example_dataset == 'MUX20': # 20-bit Multiplexer\n", " train_data_path = 'evaluation/datasets/partitioned/multiplexer/C_multiplexer_20_bit_10000_inst_CV_Train_1.txt'\n", " test_data_path = 'evaluation/datasets/partitioned/multiplexer/C_multiplexer_20_bit_10000_inst_CV_Test_1.txt'\n", " excluded_column = 'Group'\n", + " rule_pop_path = 'C_multiplexer_20_bit_10000_inst_CV_Train_1/rule_pop.csv'\n", "elif example_dataset == 'GAM_A': # GAMETES Dataset A (additive)\n", " train_data_path = 'evaluation/datasets/partitioned/gametes/A_uni_4add_CV_Train_1.txt'\n", " test_data_path = 'evaluation/datasets/partitioned/gametes/A_uni_4add_CV_Test_1.txt'\n", + " rule_pop_path = 'A_uni_4add_CV_Train_1/rule_pop.csv'\n", "elif example_dataset == 'GAM_C': # GAMETES Dataset C (epistasis)\n", " train_data_path = 'evaluation/datasets/partitioned/gametes/C_2way_epistasis_CV_Train_1.txt'\n", " test_data_path = 'evaluation/datasets/partitioned/gametes/C_2way_epistasis_CV_Test_1.txt'\n", + " rule_pop_path = 'C_2way_epistasis_CV_Train_1/rule_pop.csv'\n", "elif example_dataset == 'GAM_E': # GAMETES Dataset E (heterogeneous)\n", " train_data_path = 'evaluation/datasets/partitioned/gametes/E_uni_4het_CV_Train_1.txt'\n", " test_data_path = 'evaluation/datasets/partitioned/gametes/E_uni_4het_CV_Test_1.txt'\n", " excluded_column = 'Model'\n", + " rule_pop_path = 'E_uni_4het_CV_Train_1/rule_pop.csv'\n", "else:\n", " print(\"Specified Example Dataset Not Found!\")" ] @@ -340,7 +360,7 @@ "text": [ "Loading MultiSURF Scores\n", "['A_0', 'A_1', 'R_0', 'R_1', 'R_2', 'R_3']\n", - "[0.0653628803320886, 0.0917736536553188, 0.069767762335029, 0.0134458939320383, 0.0229747192062444, 0.0148895858857669]\n" + "[0.0653628803320886, 0.0917736536553188, 0.0697677623350289, 0.0134458939320383, 0.0229747192062444, 0.0148895858857668]\n" ] } ], @@ -422,332 +442,416 @@ "Feature Types: [1, 1, 1, 1, 1, 1]\n", "Missing Values: 0\n", "Quantiative Feature Range: [[inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf]]\n", - "Categorical Feature Values: [[1, 0], [0, 1], [1, 0], [0, 1], [1, 0], [1, 0]]\n", + "Categorical Feature Values: [[np.int64(1), np.int64(0)], [np.int64(0), np.int64(1)], [np.int64(1), np.int64(0)], [np.int64(0), np.int64(1)], [np.int64(1), np.int64(0)], [np.int64(1), np.int64(0)]]\n", "Average States: 2.0\n", "Rule Specificity Limit: 6\n", - "Classes: [1, 0]\n", - "Class Counts: {1: 225, 0: 225}\n", - "Class Weights: {1: 0.5, 0: 0.5}\n", + "Classes: [np.int64(1), np.int64(0)]\n", + "Class Counts: {np.int64(1): 225, np.int64(0): 225}\n", + "Class Weights: {np.int64(1): 0.5, np.int64(0): 0.5}\n", "Majority Class: 1\n", "Expert Knowledge Weights Used: True\n", "--------------------------------------------------------------------\n", + "Beginning Decision Tree Rule Inititialization...\n", + "\n", + "One-hot encoding 6 categorical features...\n", + " Original features: 6, After one-hot encoding: 12\n", + " One-hot mapping created for 12 encoded features\n", + " Quantitative feature mapping: 0 features\n", + "Random Seed Check After RF: 0.6394267984578837\n", + "\n", + "Extracting rules from all decision tree branches in all forests...\n", + "Random Seed Check After Rule Extract: 0.025010755222666936\n", + "Deduplicating rules...\n", + "Random Seed Check After Deduplication: 0.27502931836911926\n", + "\n", + "Converting extracted rules to HEROS format and checking for redundancy...\n", + "Random Seed Check After Convert to HEROS rules: 0.8601666658261801\n", + "\n", + "Summary: Converted rules to HEROS format and added to population.\n", + "Total Population Numerosity: 667\n", + "Unique HEROS Rules: 290\n", + "PopSize After Tree Initialization 290\n", + "Micro PopSize After Tree Initialization 667\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 290\n", + "Post-Cleaning Population Size: 279\n", + "27 rules subsumed with a specificity of 2\n", + "80 rules subsumed with a specificity of 3\n", + "75 rules subsumed with a specificity of 4\n", + "20 rules subsumed with a specificity of 5\n", + "1 rules subsumed with a specificity of 6\n", + "Post-Subsumption Compaction Population Size: 76\n", + "HEROS Evolution Beginning!\n", "Archiving: 500\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 1000 0.813 176 500 0.602\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 1000 0.891 202 500 0.934\n", "Archiving: 1000\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 2000 0.895 200 500 1.283\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 3000 0.905 207 500 1.973\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 4000 0.898 219 500 2.664\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 5000 0.896 213 500 3.774\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 2000 0.899 211 500 1.614\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 3000 0.902 217 500 2.285\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 4000 0.897 213 500 2.978\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 5000 0.908 228 500 3.646\n", "Archiving: 5000\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 6000 0.904 220 500 4.983\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 7000 0.903 211 500 6.206\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 8000 0.893 225 500 7.366\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 9000 0.894 210 500 8.523\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 10000 0.91 210 500 9.683\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 6000 0.92 227 500 4.336\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 7000 0.897 225 500 5.012\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 8000 0.902 234 500 5.675\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 9000 0.911 225 500 6.331\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 230\n", + "Post-Cleaning Population Size: 229\n", + "13 rules subsumed with a specificity of 2\n", + "57 rules subsumed with a specificity of 3\n", + "64 rules subsumed with a specificity of 4\n", + "1 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 94\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 10000 0.91 94 499 7.001\n", "Archiving: 10000\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 11000 0.877 206 500 10.89\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 12000 0.895 203 500 12.054\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 13000 0.904 208 500 13.22\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 14000 0.901 213 500 14.364\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 15000 0.902 208 500 15.52\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 16000 0.9 209 500 16.677\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 17000 0.9 222 500 17.819\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 18000 0.892 207 500 18.946\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 19000 0.903 200 500 20.085\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 20000 0.897 217 500 21.227\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 21000 0.909 211 500 22.358\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 22000 0.896 202 500 23.496\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 23000 0.893 214 500 24.625\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 24000 0.905 214 500 25.748\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 25000 0.891 204 500 26.872\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 26000 0.896 206 500 27.997\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 27000 0.903 207 500 29.148\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 28000 0.898 206 500 30.29\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 29000 0.894 213 500 31.408\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 30000 0.907 209 500 32.531\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 31000 0.907 209 500 33.684\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 32000 0.899 221 500 34.815\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 33000 0.909 209 500 35.94\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 34000 0.888 213 500 37.053\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 35000 0.902 206 500 38.187\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 36000 0.902 209 500 39.316\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 37000 0.899 214 500 40.462\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 38000 0.896 212 500 41.587\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 39000 0.902 218 500 42.716\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 40000 0.894 217 500 43.853\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 41000 0.902 209 500 44.964\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 42000 0.909 213 500 46.062\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 43000 0.898 227 500 47.182\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 44000 0.9 218 500 48.309\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 45000 0.906 222 500 49.393\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 46000 0.909 216 500 50.528\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 47000 0.895 218 500 51.66\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 48000 0.899 223 500 52.803\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 49000 0.904 218 500 53.949\n", - " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", - "0 50000 0.906 214 500 55.092\n", - "Archiving: 50000\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:10000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 1 0.904 0.904 11 0.522\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 2 0.904 0.904 11 0.956\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 3 0.904 0.904 11 1.41\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 4 0.927 1.0 38 1.803\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 5 0.927 1.0 38 2.246\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 6 0.927 1.0 38 2.686\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 7 0.927 1.0 38 3.085\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 8 0.936 1.0 23 3.515\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 9 0.936 1.0 23 3.881\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 10 0.944 1.0 24 4.27\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 11 0.944 1.0 24 4.605\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 12 0.953 1.0 19 4.983\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 13 0.953 1.0 18 5.328\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 14 0.953 1.0 18 5.614\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 15 0.953 1.0 18 5.907\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 16 0.953 1.0 18 6.313\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 17 0.956 1.0 17 6.597\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 18 0.969 1.0 14 6.961\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 19 0.969 1.0 14 7.311\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 20 0.969 1.0 14 7.635\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.1923035034118793\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 11000 0.886 204 500 15.749\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 12000 0.918 221 500 16.385\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 13000 0.905 224 500 17.05\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 14000 0.909 219 500 17.703\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 15000 0.898 219 500 18.346\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 16000 0.908 219 500 18.988\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 17000 0.9 225 500 19.651\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 18000 0.912 224 500 20.297\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 19000 0.909 221 500 20.947\n", "--------------------------------------------------------------------\n", - "Original Population Size: 214\n", - "Post-Cleaning Population Size: 214\n", - "16 rules subsumed with a specificity of 2\n", - "55 rules subsumed with a specificity of 3\n", - "50 rules subsumed with a specificity of 4\n", + "Original Population Size: 233\n", + "Post-Cleaning Population Size: 232\n", + "15 rules subsumed with a specificity of 2\n", + "69 rules subsumed with a specificity of 3\n", + "59 rules subsumed with a specificity of 4\n", "3 rules subsumed with a specificity of 5\n", - "Post-Subsumption Compaction Population Size: 90\n", + "Post-Subsumption Compaction Population Size: 86\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 20000 0.905 86 499 21.609\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:10000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 21 0.969 1.0 14 7.923\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 22 0.984 1.0 14 8.268\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 23 0.984 1.0 14 8.534\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 24 1.0 1.0 9 8.901\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 25 1.0 1.0 9 9.218\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 26 1.0 1.0 9 9.455\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 27 1.0 1.0 9 9.755\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 28 1.0 1.0 9 10.094\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 29 1.0 1.0 9 10.498\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 30 1.0 1.0 9 10.838\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 31 1.0 1.0 9 11.163\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 32 1.0 1.0 9 11.483\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 33 1.0 1.0 9 11.859\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 34 1.0 1.0 8 12.194\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 35 1.0 1.0 8 12.597\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 36 1.0 1.0 8 12.874\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 37 1.0 1.0 8 13.211\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 38 1.0 1.0 8 13.549\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 39 1.0 1.0 8 13.901\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 40 1.0 1.0 8 14.27\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.12363543840117786\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 21000 0.909 202 500 28.884\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 22000 0.9 209 500 29.527\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 23000 0.911 216 500 30.192\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 24000 0.902 209 500 30.92\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 25000 0.891 218 500 31.569\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 26000 0.894 225 500 32.324\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 27000 0.893 219 500 33.027\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 28000 0.908 226 500 33.785\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 29000 0.897 222 500 34.516\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 225\n", + "Post-Cleaning Population Size: 225\n", + "12 rules subsumed with a specificity of 2\n", + "60 rules subsumed with a specificity of 3\n", + "62 rules subsumed with a specificity of 4\n", + "3 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 88\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 30000 0.917 88 500 35.297\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:10000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 41 1.0 1.0 8 14.588\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 42 1.0 1.0 8 15.035\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 43 1.0 1.0 8 15.434\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 44 1.0 1.0 8 15.824\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 45 1.0 1.0 8 16.219\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 46 1.0 1.0 8 16.607\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 47 1.0 1.0 8 17.048\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 48 1.0 1.0 8 17.466\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 49 1.0 1.0 8 17.901\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 50 1.0 1.0 8 18.243\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 51 1.0 1.0 8 18.57\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 52 1.0 1.0 8 18.986\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 53 1.0 1.0 8 19.397\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 54 1.0 1.0 8 19.732\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 55 1.0 1.0 8 20.091\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 56 1.0 1.0 8 20.543\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 57 1.0 1.0 8 20.935\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 58 1.0 1.0 8 21.342\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 59 1.0 1.0 8 21.745\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 60 1.0 1.0 8 22.193\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.051236907929415376\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 31000 0.895 195 500 43.956\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 32000 0.908 204 500 44.686\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 33000 0.905 206 500 45.348\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 34000 0.895 211 500 45.984\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 35000 0.896 218 500 46.675\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 36000 0.897 213 500 47.436\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 37000 0.911 221 500 48.173\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 38000 0.9 217 500 48.882\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 39000 0.91 224 500 49.655\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 222\n", + "Post-Cleaning Population Size: 222\n", + "15 rules subsumed with a specificity of 2\n", + "63 rules subsumed with a specificity of 3\n", + "53 rules subsumed with a specificity of 4\n", + "4 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 87\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 40000 0.897 87 500 50.378\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:10000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 61 1.0 1.0 8 22.701\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 62 1.0 1.0 8 23.054\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 63 1.0 1.0 8 23.513\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 64 1.0 1.0 8 23.937\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 65 1.0 1.0 8 24.33\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 66 1.0 1.0 8 24.788\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 67 1.0 1.0 8 25.206\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 68 1.0 1.0 8 25.625\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 69 1.0 1.0 8 26.024\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 70 1.0 1.0 8 26.441\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 71 1.0 1.0 8 26.869\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 72 1.0 1.0 8 27.28\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 73 1.0 1.0 8 27.78\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 74 1.0 1.0 8 28.217\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 75 1.0 1.0 8 28.631\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 76 1.0 1.0 8 29.012\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 77 1.0 1.0 8 29.451\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 78 1.0 1.0 8 29.779\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 79 1.0 1.0 8 30.205\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 80 1.0 1.0 8 30.605\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.6845892083633415\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 41000 0.897 199 500 59.52\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 42000 0.904 216 500 60.159\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 43000 0.896 217 500 60.806\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 44000 0.91 224 500 61.447\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 45000 0.893 236 500 62.106\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 46000 0.915 228 500 62.755\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 47000 0.897 232 500 63.423\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 48000 0.9 236 500 64.072\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 49000 0.899 221 500 64.719\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 230\n", + "Post-Cleaning Population Size: 230\n", + "13 rules subsumed with a specificity of 2\n", + "60 rules subsumed with a specificity of 3\n", + "65 rules subsumed with a specificity of 4\n", + "1 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 91\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 50000 0.902 91 500 65.366\n", + "Archiving: 50000\n", "HEROS (Phase 1) run complete!\n", "Number of Unique Rules Identified: 0\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 1 0.973 0.973 16 1.489\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 2 0.973 0.973 16 2.186\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 3 0.973 0.973 16 2.854\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 4 0.973 0.973 16 3.494\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 5 0.973 0.973 16 4.034\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 6 0.973 0.973 16 4.587\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 7 0.973 0.973 16 5.021\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 8 0.973 0.973 16 5.63\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 9 0.973 0.973 16 6.12\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 10 0.973 0.973 16 6.592\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 11 0.973 0.973 14 7.116\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 12 0.991 0.991 16 7.64\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 13 1.0 1.0 17 8.137\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 14 1.0 1.0 16 8.728\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 15 1.0 1.0 13 9.277\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 16 1.0 1.0 13 9.684\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 17 1.0 1.0 11 10.362\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 18 1.0 1.0 11 10.892\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 19 1.0 1.0 11 11.544\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 20 1.0 1.0 10 12.104\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 21 1.0 1.0 10 12.545\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 22 1.0 1.0 10 13.114\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 23 1.0 1.0 10 13.621\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 24 1.0 1.0 10 14.09\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 25 1.0 1.0 10 14.602\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 26 1.0 1.0 9 15.035\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 27 1.0 1.0 9 15.498\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 28 1.0 1.0 9 16.039\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 29 1.0 1.0 9 16.624\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 30 1.0 1.0 9 17.173\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 31 1.0 1.0 9 17.635\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 32 1.0 1.0 9 18.278\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 33 1.0 1.0 9 18.834\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 34 1.0 1.0 9 19.349\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 35 1.0 1.0 8 19.824\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 36 1.0 1.0 8 20.369\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 37 1.0 1.0 8 20.895\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 38 1.0 1.0 8 21.48\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 39 1.0 1.0 8 22.091\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 40 1.0 1.0 8 22.642\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 41 1.0 1.0 8 23.178\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 42 1.0 1.0 8 23.643\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 43 1.0 1.0 8 24.22\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 44 1.0 1.0 8 24.786\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 45 1.0 1.0 8 25.298\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 46 1.0 1.0 8 25.86\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 47 1.0 1.0 8 26.469\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 48 1.0 1.0 8 27.02\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 49 1.0 1.0 8 27.689\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 50 1.0 1.0 8 28.266\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 51 1.0 1.0 8 28.745\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 52 1.0 1.0 8 29.339\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 53 1.0 1.0 8 29.875\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 54 1.0 1.0 8 30.484\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 55 1.0 1.0 8 31.088\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 56 1.0 1.0 8 31.583\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 57 1.0 1.0 8 32.149\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 58 1.0 1.0 8 32.698\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 59 1.0 1.0 8 33.226\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 60 1.0 1.0 8 33.756\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 61 1.0 1.0 8 34.271\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 62 1.0 1.0 8 34.84\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 63 1.0 1.0 8 35.551\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 64 1.0 1.0 8 36.144\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 65 1.0 1.0 8 36.657\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 66 1.0 1.0 8 37.113\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 67 1.0 1.0 8 37.632\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 68 1.0 1.0 8 38.353\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 69 1.0 1.0 8 39.015\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 70 1.0 1.0 8 39.69\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 71 1.0 1.0 8 40.313\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 72 1.0 1.0 8 40.919\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 73 1.0 1.0 8 41.517\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 74 1.0 1.0 8 42.105\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 75 1.0 1.0 8 42.697\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 76 1.0 1.0 8 43.179\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 77 1.0 1.0 8 43.798\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 78 1.0 1.0 8 44.429\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 79 1.0 1.0 8 45.022\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 80 1.0 1.0 8 45.668\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 81 1.0 1.0 8 46.138\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 82 1.0 1.0 8 46.788\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 83 1.0 1.0 8 47.317\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 84 1.0 1.0 8 47.826\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 85 1.0 1.0 8 48.525\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 86 1.0 1.0 8 49.178\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 87 1.0 1.0 8 49.813\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 88 1.0 1.0 8 50.537\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 89 1.0 1.0 8 51.101\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 90 1.0 1.0 8 51.817\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 91 1.0 1.0 8 52.483\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 92 1.0 1.0 8 53.132\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 93 1.0 1.0 8 53.699\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 94 1.0 1.0 8 54.191\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 95 1.0 1.0 8 54.701\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 96 1.0 1.0 8 55.221\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 97 1.0 1.0 8 55.874\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 98 1.0 1.0 8 56.431\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 99 1.0 1.0 8 57.025\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 100 1.0 1.0 8 57.597\n", + "Number of Iterations Used:10000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 81 1.0 1.0 8 31.004\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 82 1.0 1.0 8 31.399\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 83 1.0 1.0 8 31.721\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 84 1.0 1.0 8 32.164\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 85 1.0 1.0 8 32.524\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 86 1.0 1.0 8 32.957\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 87 1.0 1.0 8 33.304\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 88 1.0 1.0 8 33.68\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 89 1.0 1.0 8 34.124\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 90 1.0 1.0 8 34.472\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 91 1.0 1.0 8 34.841\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 92 1.0 1.0 8 35.249\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 93 1.0 1.0 8 35.591\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 94 1.0 1.0 8 35.953\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 95 1.0 1.0 8 36.308\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 96 1.0 1.0 8 36.619\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 97 1.0 1.0 8 37.046\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 98 1.0 1.0 8 37.412\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 99 1.0 1.0 8 37.731\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 100 1.0 1.0 8 38.087\n", "HEROS (Phase 2) run complete!\n", - "Random Seed Check - End: 0.37661169893523605\n" + "Random Seed Check - End: 0.8362786118187231\n" ] } ], @@ -756,7 +860,8 @@ "heros = HEROS(outcome_type=outcome_type,iterations=iterations,pop_size=pop_size,cross_prob=cross_prob,mut_prob=mut_prob,nu=nu,beta=beta,theta_sel=theta_sel,\n", " fitness_function=fitness_function,subsumption=subsumption,rsl=rsl,feat_track=feat_track, model_iterations=model_iterations,\n", " model_pop_size=model_pop_size,model_pop_init=model_pop_init,new_gen=new_gen,merge_prob=merge_prob,rule_pop_init=rule_pop_init,compaction=compaction,\n", - " track_performance=track_performance,model_tracking=model_tracking,stored_rule_iterations=stored_rule_iterations,stored_model_iterations=stored_model_iterations,random_state=random_state, verbose=verbose)\n", + " track_performance=track_performance,model_tracking=model_tracking,stored_rule_iterations=stored_rule_iterations,stored_model_iterations=stored_model_iterations,\n", + " random_state=random_state,verbose=verbose, alternate=alternate,alternate_mode=alternate_mode,feedback=feedback)\n", "\n", "heros = heros.fit(X, y, row_id, cat_feat_indexes=cat_feat_indexes, ek=ek)" ] @@ -828,11 +933,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "11 non-dominated models on Pareto-front.\n", + "7 non-dominated models on Pareto-front.\n", "----------------------------------------\n", - "Model testing accuracies: [1.0, 0.94, 0.96, 0.9, 0.76, 0.6200000000000001, 0.5800000000000001, 0.5800000000000001, 0.6799999999999999, 0.54, 0.5]\n", - "Model testing coverages: [1.0, 0.98, 0.94, 0.88, 1.0, 1.0, 1.0, 1.0, 1.0, 0.48, 0.48]\n", - "Model rule counts: [8, 7, 7, 6, 5, 4, 3, 3, 2, 1, 1]\n", + "Model testing accuracies: [1.0, 0.96, 0.88, 0.8, 0.76, 0.76, 0.5]\n", + "Model testing coverages: [np.float64(1.0), np.float64(0.94), np.float64(0.86), np.float64(0.74), np.float64(1.0), np.float64(1.0), np.float64(0.52)]\n", + "Model rule counts: [8, 7, 6, 5, 4, 2, 1]\n", "----------------------------------------\n", "Best model testing accuracy: 1.0\n", "Best model testing coverage: 1.0\n", @@ -840,44 +945,44 @@ "Best model index: 0\n", "----------------------------------------\n", " Condition Indexes Condition Values Action Numerosity Fitness \\\n", - "0 [0, 4, 1] [1, 0, 0] 0 3 0.997857 \n", - "1 [1, 5, 0] [1, 1, 1] 1 5 0.997429 \n", - "2 [2, 1, 0] [0, 0, 0] 0 8 1.000000 \n", - "3 [1, 3, 0] [1, 1, 0] 1 7 0.998143 \n", - "4 [2, 1, 0] [1, 0, 0] 1 3 0.998714 \n", - "5 [4, 1, 0] [1, 0, 1] 1 7 0.997857 \n", - "6 [3, 1, 0] [0, 1, 0] 0 7 0.997714 \n", - "7 [0, 5, 1] [1, 0, 1] 0 5 0.996857 \n", + "0 [0, 1, 2] [0, 0, 0] 0 5 1.000000 \n", + "1 [0, 1, 3] [0, 1, 1] 1 7 0.998143 \n", + "2 [0, 1, 5] [1, 1, 1] 1 7 0.997429 \n", + "3 [0, 1, 4] [1, 0, 0] 0 6 0.997857 \n", + "4 [1, 2, 0] [0, 1, 0] 1 6 0.998714 \n", + "5 [0, 1, 5] [1, 1, 0] 0 7 0.996857 \n", + "6 [0, 1, 4] [1, 0, 1] 1 6 0.997857 \n", + "7 [0, 1, 3] [0, 1, 0] 0 7 0.997714 \n", "\n", " Useful Accuracy Useful Coverage Accuracy Match Cover Correct Cover \\\n", - "0 1.0 27.5 1.0 55 55 \n", - "1 1.0 26.0 1.0 52 52 \n", - "2 1.0 34.0 1.0 68 68 \n", - "3 1.0 28.5 1.0 57 57 \n", + "0 1.0 34.0 1.0 68 68 \n", + "1 1.0 28.5 1.0 57 57 \n", + "2 1.0 26.0 1.0 52 52 \n", + "3 1.0 27.5 1.0 55 55 \n", "4 1.0 30.5 1.0 61 61 \n", - "5 1.0 27.5 1.0 55 55 \n", - "6 1.0 27.0 1.0 54 54 \n", - "7 1.0 24.0 1.0 48 48 \n", + "5 1.0 24.0 1.0 48 48 \n", + "6 1.0 27.5 1.0 55 55 \n", + "7 1.0 27.0 1.0 54 54 \n", "\n", " Mean Absolute Error Prediction Outcome Range Probability Birth Iteration \\\n", - "0 None None None 538 \n", - "1 None None None 938 \n", - "2 None None None 147 \n", - "3 None None None 459 \n", - "4 None None None 182 \n", - "5 None None None 248 \n", - "6 None None None 181 \n", - "7 None None None 477 \n", + "0 None None None 0 \n", + "1 None None None 0 \n", + "2 None None None 0 \n", + "3 None None None 0 \n", + "4 None None None 104 \n", + "5 None None None 0 \n", + "6 None None None 0 \n", + "7 None None None 0 \n", "\n", " Specified Count Average Match Set Size Deletion Probabiilty \n", - "0 3 87.337309 0.002396 \n", - "1 3 96.095497 0.007325 \n", - "2 3 99.853940 0.019436 \n", - "3 3 92.333984 0.013786 \n", - "4 3 99.660789 0.002731 \n", - "5 3 95.647239 0.014285 \n", - "6 3 100.720970 0.015045 \n", - "7 3 93.752155 0.007151 \n" + "0 3 93.127103 0.004923 \n", + "1 3 88.732769 0.010573 \n", + "2 3 86.089364 0.013973 \n", + "3 3 84.024844 0.010015 \n", + "4 3 94.375813 0.011239 \n", + "5 3 90.676391 0.014726 \n", + "6 3 83.373389 0.009937 \n", + "7 3 94.056982 0.015261 \n" ] } ], @@ -1029,7 +1134,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1093,7 +1198,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1123,7 +1228,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB+X0lEQVR4nO3dd3gUVRfH8e9sSW8kFBEQQRBEqkhRxEaTIh0sFOldOqhYX1RUmiK9I0XpRVFEFEREQaVJUaT3TkjPZst9/9gwISRAgGQnm5zP8/Do3TYnkGR/e8/MvZpSSiGEEEKIXMtkdAFCCCGEMJaEASGEECKXkzAghBBC5HISBoQQQohcTsKAEEIIkctJGBBCCCFyOQkDQgghRC4nYUAIIYTI5SQMCCGEELmchAEhhBAil5MwIIQQQuRyEgaEEEKIXE7CgBBCCJHLSRgQQgghcjkJA0IIIUQuJ2FACCGEyOUkDAghhBC5nMXoAkTOppQTXBdB2YAkwAc0HzDlQ9PMRpcnhBACCQMikynnJbD/hbL/C/Z94NgHKh5Q1zxKA80fZSkN1rJo1lJgrYJmzmtU2UIIkatpSil164cJcWNKKbDvQiUsg8R1QAJgAuUEzYI7c2rXPgNwJN9vAuUCzQ/8aqH5NwdrZTRNS+9QQgghsoCEAXFXlO1nVOxUcOxPflM3A77uN/kMv4gLsKWEA8sDaIHdwLe2hAIhhPAACQPijihXJCpmDCR+l/wm7gtY4W7evNXVGYNEdyjwrYsWPBTNHJFZZQshhEiHhAFx21TiBlTMCHCed58MiM/dhYB0D2ID7GCKQAt+Dc2vbua+vhBCCJ2EAZFhSimI/wIVOz55NiDg9toBt31Al/vkQ83kbhsEdpe2gRBCZAEJAyJDlFIQNxkVNx33yYD+mT8bcMODJwBOCGiPFjRAAoEQQmQyWXRIZEz8F8lBwJQ8I+DBN2TNHzBD/FyIm+a54wohRC4hYUDckrL94m4NJK8PYIjkQKDipqIS1xlTgxBC5FDSJhA3pVxRqEutwXkWtCDPzgikxxUL5gi08MVylYEQQmQSmRkQN6VixiYHgUDjgwC4WxSui6iYkUiOFTmVPcnOyf9Oc2T3MU4eOIPD7jC6JJHDyXLE4oaU7VdI/AY0a9ZeNXA7NBMoH7D9ALY64Ffb6IqEyBRXLkSx/stf2bzyD47/cwp7oh2FQkPD6melWNki1GhWjWdeqkFIeLDR5YocRtoE4oZcl18B+04gG7QHrueKAWtptPCFcnWB8GpJNjtLRn3NygnfkRhnQymwWM2YLWbQNJRSuBxOnA4nAP5BfrQa1Jhm/RpgscrnOZE5JAyIdCn7PtTltoAleWGhbEYlAQ60PDPQfB4xuhoh7sjZo+cZ8fI4juw+hmYy4Rvgi8l043DrcrmwxSehXC5KVi7OG/P7ka+wnDsj7l42mfsV2Y1KWA64AKvRpdyAFZTLvTmSEF7o7NHzDGswgiO7j+Eb4It/kN9NgwCAyWTCP8gPH39fDmw7zJsNR3Dx1CUPVSxyMpkZEGkoVzTq4nPJewQE3PzBx09j+u8IKjAA9Vil2z9YbDzayTMQEwcxcWguF65HykJ4aAYKTQAsaHm/le2PRfZ3eA5s6agPnS6NqBhf/jlckMU/VOHsxQx8zyd7+IFTPFHpAA8WPUf+iASswfnQIh6Fcu9AeOUsKF7kdDIzINKybwcVB/je8qHa6fPu/8bFQ1RMxo+hEtz7D0THwPlLYLFkLACk4usOLPZtt/k8IQxUfTbfnx7BW5/W4vtfy/Dow8f5X69vCPS3Zfgl6j72D/kjYvlu08O8O+4ptp5tD4nnYW11OLs+C4sXOZWcfSLSsu/HvdKg+eaPi45Bi41D5c2DdjES7fQ5VGhGznJ2gYoFFBSwoApWcJ+XcO4S2sXIjNepmQATyv4vml+9jD9PCAPFuO5n5uhN2BIKcvhsMSwWjdb1tlHl4aP8/FepDL3GzBU1iI5zLwCWEJPAkQ8vMXP3KgJ/Lg97R8A9z2bllyByIJkZEGkoxz/uTYJuQTvlnhVQJYq6Q8DZi+B0ZuAA8UByd0pzgooCVyQo+x0U6wT7vtt/nhAG+euHXSTG2fANcJ+Ye+iku8UVGpyQ4de4GgQAfAN8iYuOZ+Py3RBaBuJPZG7BIleQMCBSUUqBfc+tZwWcTjh3ARUSBEGBqHsLoDmdcO5WJzO5knv913MA8cn/n4QeFm5Fs4DjH1QGwosQ2cHfG/eilPtkQID84e722pkLt9smczOZTSgF29dsgsvbIfThTKtV5B7SJhCpqVhwXQFuEQbOX0JzOHHdW8A9LpAX9d9hd6vg3vw3fJrTEY/LAe6dD1MzOTRMgCMpHpUYCZqfe8Gjm9A00Ijh4JYtOJ15bl6zEAYKiz1NYeDUgVOYzWFYSKB08fM0f3YHew8WYMvOQrhcqVcaNJlNmMy3/sxmtph4uvgClCMOreybWfQViJxMwoBITSXi/lR+819A2qlzKJMJ7kk+i99ihvx50c6cR8UnQEDKNKZSCofdidXHREKMDVtC+kHDJ9ZEKBAfY8LuAkhM/nNjFqvCbFV8+MInnDuZDddDECJZ3ZpHGdIdRg7+LtXtx04F8+bIasTFx6V5jn+QH1Y/K2aL+aaLa7VtvIsnKh0k9oGPCZKrCcQdkDaBuE4G+vbxCXAlGvLmcecGuwPsDlQB9+In2ulzqR4eFx1P9MVoIs9FYUvI3NUClXLPMVh9pU0gvMMnk6vQ++1nGfzhk6z+qThFC8UwrPfWdB9rt9mJvhhDfHR8uvcDtKyzjVbP/c38rysRk69DFlUtcjqZGRDXufWna+30efck//lLaOfTOUfg9Hl4oChoGnabHVuc+5IplzPzl7TQtOQ8YpNcK7zD8dPB/HckHIBd/+THZFI0eOYINaucZNOfhVM91mF3n5Bri0/Cx88Hq2/qtlnLOttoVXc7C7+ryNIfylH/U5kdE3dGwoBITfPD/Vn7Bm/cSsGZ8yh/P9RDJdI+/eJltOOnURcjUXnzEHsl7dQnuN/Eg8KcqbY8MLncn+4Dgl2osFtdlWACzQ/NpKGheHPR6zidYbf88oQwSljsCrj8FwEhAfgF+uLj537jXrj2MWpWPUXHF/7h7yOlUcr9Q+GwO4iPTjnZNi4qntB8IXq7oHnt7bSqu51lP1biq9VlCQoLIE+BOzsJUQgJAyI1LRBM4eC6QLqLDl2MRLMl4SpRNN1FglRQAJw8g3b6HLFWX1zO9KfvlQJboongIDtccgcGLc59foAlLh5wgNkEEYE3KNQJxAEaaKGUqlYZk0k+FYls7PBW2AJFHirEvwdisfi4f/3anBZWbahI20Z/8FS1o/y6vSQAFh8LTocLW/zVmTUX8dHxBIYG0ujJv3mh3jZ2/FuYHf8UoUSR85Su+gCmy3+4j5W3uiFfovBeEgZEKpqmoazlIPHH9E74d18toGlw9SqC6/lYIV8EnL9EUp4I98qCgMkMrus+7CclaNiVC989Z1PdbjpyGQDlZ0E9XuwWFStQV+BSQ1RQT/BrjKbJt7XIvio+/TDrvtmKy+XSLy/8fvPD1Kuxjxa1t7N5xwMo5b49MMQfu82uh+qr7YJHyhwHoFLpk1QqfTLlxX+Y5P7vy7LKvLg9sjeBSEPFzUDFTgAC72jrYpfLRdSF6FSzAoEhTuKi015FoJkgLK8DU2a1/M33oQX2BP/GaLe4LFEII8RExtLl4QEkxCXiH+R/y8c7kuxEX4rVxyaTRmj+UL1dEB+TQHCeQGbu/TRDrydEeuSsK5GW5eqSqHd2hn58dEKqIOAX4MJ8gw/rykW6IeGOOY+jot9AXXwOFb8UdSerGgqRhYLzBNFqcGOUS+knCN6MxceKX0BKy87lUsRHua8ucCQ5QCleeqO5BAFxVyQMiLSslUALAjK+ccpVSYlJ7h6nUqAUJrOJgKBgUGb9NpTCZFLXPEfDlpi5lxziPIGKHoa6WA8Vv1hCgchWmr5an1JVSpCUYEsVnDVNYTK50vwJCvPFYgWTKbldkOD+OUtKTKLsEw/RoGsto74UkUNIm0CkyxX9McR/5Q4FGWwVXNseCD16DJ/4G18b7fKxcKlkyZQtCkwQFuHAlImTBKmYCqEFdQf/5mianGgojHfx9GXebDiC0wfP4uPvg8Vq0S8VvJm2/etz7mIgaPBAhfv56Pu3yJNfriIQd0fCgEiXsh9AXX4R9yV8t97KGCD2Spx+5rPZZsPX14p/kPu5DruDuCsp4SAwj4kks5WEuJTJKR8/RfAtLym8S6Z70YJ6SCgQ2cLF05cZ9coE9m35D03TuOceBxF5brzqZkJMAvsPBOJwun9unmr1GG8tGuipckUOJmFA3JDrcmdI+itDswNJiUnEXE45yclsMae6Jtqe5F5J7aqQvMFYrBB1IRanI+VbMCjMia+fB74lTQWTZwpaSigQhnI6nHw9aS2LR60i9kocSrn3GjBbzMmraimcDidOh7tF4Eiy6/8PMHzVazz2/KNGlS9yCAkD4oZU0h+oyJ64r+X3u+Hj0rt6ICRvCFaflLMG0wsDVh8rDruDqIvRnmsXXM90D1pgNwhohZbBGRAhskJcdDyblm3l96//5OCOI8RFx7t/LjQICg2kZOViPN64KhGFwnm97vtc/dUdfk8Y0/eMJSQ82NgvQHg1CQPiplzRIyBhERBww22NYyJjSUpI0sd+QX4EhgSkesyNwgC4L41KiElZac3HTxEU6ryTqxrvnKlAcihoLaFAGM7lcnHlfBRJiXZ8/KzkKRCWaqOiaUPmsmTMN/q4VpuavD6vrxGlihxCwoC4KeWKRV16AVwngbTtglu1B666WRhQShF1MRrnNZdZBYWZ8PVLwuNM+a8JBTeeDRHCSLYEGz0rv8aJf0/pt723fAg1mlY1sCrhzeTSQnFTmikILeQdwArEuy8NTOZyuYi9kvqKgaCwwJtutZruMTSNoLDUCxzFRStcKox0l0TOSq7zqJgPUBdqo+LmoNTNt1AWwgi+/r4Mmd0bkynlZ+azHtPcLTch7oCEAXFLmm81tOChuNcnTtADQVxUPMqVcp6Af5Cfvt767bJYLfgHpXwSVy5FbJQNTCGghePxlbNd51ExI1AXaqHiZqNUwq2fI4QHPVStJK0GN9bHV85HMaHvLAMrEt5MwoDIEC2gNVpQv+RRPLYEW6rzBMxWM/7Bd7cCmn+QH2brNScdJtqxJdiAJPfljQGvgF990t00Iau4LqBiPkoOBTNRrhuvnSCEp7V/rzVFy6Rse/zzws38svR3AysS3krCgMgwLfAVtOA3cCkTLmdMyiqC2p21B9K8vqYRFBagtws0k8LliMXlAi1oIKaQNzGFjUOLWA1+DfBsKLiIivkEdVFCgcg+fPx83O0Cc8qv8s97TSfyfJSBVQlvJGFA3B7/lsz/7GnOHvPBL1Dh4+dytwesmTONb7FaCAj2db9uoOL8KStzP30cAtrqj9GsJTGFfYaW91vwa4RnQ8Gl5FDwLCp2OsoV57ljC5GOUlVK8OJrTfVx1MUYxveZYVxBwitJGBC3ZePi31gw8jgDGpfg27nhmC0m/AMdoGypTi68I0qBsuEX4MRiNbF2YR76P1+Sr0af44cvfk7zcM1SAlPY2ORQ8Dwe/XZ2XUbFjkJdeBYVOxXlir31c4TIIm3ebsn9ZYvo401Lt7Bx8W8GViS8jVxaKDLs8tlIupQdqF9KaLaYmb79JQrd+w3Yd4ByJK9F4It7GeOUT+w3vLRQKdy7I9qS/2sGa3nOXWxC5/KLsCc5AAgI8WfGnk/JVzjihvUpx2FU7CRIXM2d7rh4x7QwtMBOENAWzRTk2WMLARzYfpg+1d7QF/8KiQhmxp6x5CkQZmxhwivIzIDIEKUU43pOT7WmwMvDmlOkbBNM4TPQwhdCYBvQAoAEIA5cMaDiQNnQNDsWq8Lq48Lq68KkJbrvJ879eM0f/Fujhc/HFD6bgg82pf3/XtCPFR+dwNiuk7lZdtUsxTGFjUbLuwb8muLRb291BRU7NnmmYLLMFAiPK/lIcV4e1lwfR1+KYVyv6Tf9mRHiKpkZEBny04JNfNzuc338QMX7Gb9lhL5w0FXKFQv2XeD4F2X/B+y7wXUJp8NJQmwCCg0U+ATkxzekMpq1DFhKgbUimin1cqpOh5P+Nd/m360H9NsGTOtBgy4Z265VOY6iYidD4tdAFm+AdD0tFC2wAwS0T/N1CZFV7El2+lR7g8O7jum3vTG/L8++XNPAqoQ3kDAgbunSmUi6lh1ATKT7ZDmzxczEPz/mgQr3Z+j5yhXLv1t3M7zlx9iTNOw2Ex9+9wFlnyhzy+ce//cUPSoNwW6zAxAQ7M/03WPIf1++DNevHMdRcZMhYSWeDwUh14SCEM8eW+RKB3ceoU/VN3A63N/rwXkCmb7nUyIK5jG4MpGdSZtA3JRSis96TNWDAEDbt1tmOAiAexVDpzOMi2d8iLpkJT7WTEavALivdCE6vv+iPo6PSWBMl5u3C9Ic33IfptCP0PKuBf+WeHQBIxWNiv0cdeEZXDGfo1yyQpzIWiUqFqPNWy30cUxkHJ/1mCrtAnFTEgbETf047xe2fLNNH5d8pBgvvt7UozU0H9CQMo89qI+3/7ibb6f9eNuv4w4FI5JDQSs8GwpiIG4C6sLTuGLGoVxyHbjIOi+90YwSlYrp4y3fbOPH+b8YWJHI7iQMiBu6eOoSE/ulLG9qsZoZMqdPpq0pkFFms5khs3vj45dyfsLUwV9w5si5O3o9zVIEU+iHaHl/AP8XcO+74CEqFuImJs8UfIZyXfHcsUWuYbFaGDqnNxZryk6jk/rN5uLpywZWJbIzCQMiXUopPu0+lbiolJX22r3bmmJl7zOknsIP3kvnEW30cWKcjbFdJuNy3fklhJqlMKbQ99Hy/QD+L+H5UDApORSMRbkiPXdskSsUK1eUtu+00sexV+L4rLu0C0T6JAyIdK2d8zN/fLdDHz/46AO8MLSJgRVB0771KftEaX28c8NeVk9Zd9evq5kLYQr9H1q+deD/Mp4NBXEQNwV14VlcMaNRLvnkJjLPi681pWTl4vp467fb013ASwgJAyKN8ycuMnnAbH1s9XFPOZot5ps8K+uZTCYGz+qFr7+Pftv0ofM4c/jO2gXX08z3Ygp9Dy3fTxDQBs+HgmnJoWCUhAKRKcwWM0Pn9MF6zW6ik/rP5sLJSwZWJbIjCQMiFaUUn3abQnx0ypa9rwx/kaJlitzkWZ5TqERBunycsk9BYryNUZ0m3lW74Hqa+R5MIe8mh4K2gM8tn5NpVDzETU8OBSNRTvmlLe7O/Q8Xue0FvETuI2FApLJm5nr+WrtLHz9UvSQtBzUysKK0GveuR/mnUtYo2P3LP6ya8H2mH8cdCt5JDgXtcS+z7CEqHuJmoC4+iyv6Y5TzoueOLXKcVoOep3S1kvr4r7W7+H7WegMrEtmNhAGhO3fsAlMHfaGPrb5WBs/qjdlsbHvgeiaTicEze+EXmPLmPPONBZw8cCZLjqeZC2AKeSs5FHTAs6EgAeJnuWcKoj9COS947tgixzBb3FfkWH1TWl9TBn7B+ePy/STcJAwIwN0eGNNlMvExKe2Bjh+8xH2lCxlY1Y0VLF6Arp+008e2hCRGd5qI05l1Kwxq5vyYQoah5VufHAr8suxYaSVC/OzkUDAC5TzvwWOLnCAzFvASOZeEAQHA6qnr2PHTbn1c5vFSNO/fwMCKbq1RjzpUfLasPt67eT8rP1+T5cfVzPmuCQWd8GwosEH8HNSFWriiP0A5M+fkSZE7ZNYCXiLnkTAgOHPkHNOGzNXHvv4+DJnVK9u1B65nMpkYNKMn/kEpb8az3vySE/tPeeT4mjkvppDX0fJtgMAu7p0XPcYG8XOTQ8H7KOdZDx5beKv0FvCaNmQuZ4/KTFNuJ2Egl3O5XIztMpnEOJt+W6cPX6bwg/caWFXG3XN/frqPbq+PkxLtjO40KUvbBdfTzBGYgocmh4Kuyds4e0oSxM9DXaiNK/p/EgrELRV+8F46ffiyPk6ITWTMXS7gJbyfhIFc7pvJP7Bzw159XK7mQzTtW9/Aim5fg661eaROeX287/f/WP7ptx6vQzOFYwoe4m4fBHYDLdCDR0+C+AXumYKo91DOrDmZUuQMaRbwWr8nUxbwEt5LwkAudvrQWWa8Nl8f+wX4MmhmT0wm7/q20DSNQdN7EBCcMk0/++2FHPvnpDH1mMIxBQ9ODgU9PBwK7JDwpXumIOpdlPO0B48tvIXZbM7SBbyE9/Gu3/oi07hcLkZ3nkRifEp7oPPHbShUoqCBVd25/Pflo8fYV/Sx3WZndMeJ+p7uRtBMeTAFD0wOBT0NCAVfoS7UwRX1NsrpmfMohPfwxAJewntIGMilVk34nt2//KOPKzz9MI171TOworv3XKdnqfJcRX387x8HWTL6a+MKSuYOBQOSzynoDVqQB49uh4RFyaHgLZTDmNkSkT2lt4DX1xPXGliRMIqEgVzo5IEzzHxjgT72C/TO9sD1NE1jwLQeBIamnMA3973FHNlz3MCqUmimMEzB/ZJDQR/Qgj14dAckLEZdrIsrahjKkT3+ToSx0lvAa8br8zl1UM45yW28+7e/uG1Op5PRnSZiS0jSb+s2sh0FixUwsKrMk69wBD0/7aCP7UkORnWciMPuMK6o62imUEzBfdHybUALehW0EA8e3QEJS1EX6+GKekNCgUh3Aa9RHbN2AS+R/UgYyGVWjPuOvZv36+NKtcrRsHsdAyvKfHVfeZpqDR/Rxwe2HWbRyFUGVpQ+zRSCFvRqcijoB1qoB4/uhIRlyaHgdZTjmAePLbIboxbwEtmHhIFc5MT+U8x+6yt97B/kx6AZ3t8euJ6mafSf2p2gsJQT9uYPX8Lhv7PnG55mCkYL6p0cCgaAFubBozshYTnq4nO4rgxFOY568Ngiu7jRAl4n/5OrUXKLnPUuIG7I6XQyquNEkhLt+m3dR7enQNF8BlaVdfLeG07vzzvpY4fdme3aBdfTTEFoQT3R8q03JhQkrkwOBYNRjsMePLbIDu65Pz/dRqVewEvaBbmHhIFcYtnY1fyz5YA+fqROeRp0rW1gRVmvVpuaPNb4UX18cMcRvvpohYEVZUzqUDDIw6HABYlfoy42SA4Fhzx4bGG0ht1q80jtcvrYqAW8hOdJGMgFju07wZx3FunjgBB/Bs3oiaZpBlaV9TRNo/+UbgSHp1zKt+CDZRzcecTAqjLOHQq6J7cPhoCWx4NHvzYUDEQ5Dnrw2MIomqYxaEbPbLOAl/AcCQM5nNPhnh6321LaAz3HdiB/kbwGVuU54ffkoc/4zvrY6XAyqsNE7En2mzwre9FMgWhBXd0zBcFDwRTuwaMrSFyNutgQ15X+KPuBWz9FeLXsuICXyHoSBnK4JaO/Zv+fKVO9VepXol7HZwysyPOeebEGTzSvpo8P/32MBR8sM7CiO6OZAtECu6DlXY8W/BqYIjx4dAWJ36EuNcJ1pR/K/p8Hjy08Ld0FvMZ8Y1xBIstJGMjBjuw5ztz3FuvjwNAABkztnuPbA9fTNI2+k7oSmjdlkZ+vPlrBge3eeZKcZgpAC+ycPFPwBpg8OcujIHGNOxRE9kXZ99/6KcLrpLuA17uLOLr3hIFViawkYSCHctjdi+3Yk1LOnu/1WUfyFfbkp8nsI0/+UF6d0EUfu5wuRnaYQJLNe9oF19M0f7TAjmj5fkILHgYmD18ZYvsedel5XJF9UPZ/bv144VXSW8BrZIcJ2fqKHHHnJAzkUIs+WcWBbSmffKs3qkyd9k8ZWJHxnmr9OE+2ekwfH91zgvnDlxhYUeZwh4IOyaHgLTDl92wBth9Ql5rgiuyNsu/z7LFFlvKWBbzE3ZMwkAMd/vsY899PeZMLzhNIvyndcl17ID2vTuhMWL6U5X8XfbKS/X/mjDPlNc0PLbB9cih4G0weXmLatg51qSmuyJ4SCnKIGy3gdWR39lzAS9w5CQM5jMN+dSov5czfXuM6kfdeT56Bnn2F5Qul76Su+tjlUu52QWLSTZ7lXTTNFy2wHVq+H9GC3zEgFPyUHAp6oOx7PHtskeny3htOr3Ed9bHD7mRkh+y9gJe4fRIGcpivRqzg0M6j+vjxJlWo1aamcQVlQzVbVOfpF2vo4+P/nEp1omVO4Q4Fbd0zBSHvgamgZwuwrUddao4rsjvKvtuzxxaZqnbbJ71yAS+RcRIGcpCDO4+w4MOUS+aCw4PoN7mrtAfS8er4zuQpkLIx0JLRX7NvS868XE7TfNACXkbLtw4tZDiY7vVsAbYNqEstcEV2RSXt8uyxRabw9gW8xK1JGMgh7El2RnVIvTDIqxO6EH6PJ1et8x4hEcH0n9JdH7tcitEdJ2JLsBlYVdZyh4IX0fL9kBwKCnm2ANtG1OVWuC53RiXt9OyxxV1LdwGvjt61gJe4MQkDOcSCD5al2pXviebVePqFxw2sKPt7vEkVarVNaaGc2H+aOW8vuskzcoaUULAWLeQDMBf2bAFJm1CXWyeHgh2ePba4K8+8WIMazarq48O7jvHlh8sNrEhkFgkDOcB/2w6l6t+F5g2m7yRpD2REr886El4wZfZk2aer2ftb7lhIxx0KWqPlXYsW8qFBoeAFXJc7opK2efbY4o5omka/SV0JiUhZwOvLEcu9dgEvkULCgJdLsrnbAy6nS7/t1YldyZM/9CbPEleFhAczYGpKu0ApxaiOE0mMz7ntgutpmhUtoFVyKPgIzPd5toCkzajLL+G6/Aoq6U/PHlvctjwFwug7MWct4CUkDHi9+cOXpFoi9KnWj/HUNQvriFur3qgydV5JWZDp1IEzzH7zKwMrMoY7FLRAy/s9WujHBoSC31GX2+C63F5CQTaX3gJeC95famBF4m5JGPBi+/88yKJPVurjsHwhqU7wERnX69OORNyb0i5Y8fl3/P1L7lw4R9MsaP7Nk0PBJ2C+37MFJG1JDgXtULatnj22yLDrF/BamIMW8MqNJAx4qaTEJEZ2mIDLpfTb+k7qSlg+aQ/ciaCwQAZO76mPlVKM7jSJhLhEA6syljsUNEPL+x1a6CgwF/NsAUlbUZHtcF1qi7JtQSl16+cIj0mzgJfTxaiOE3PUAl65iYQBL/XFu4s5/s8pffzMSzWo2aK6gRV5v6r1K/HcNds7nzl8jllvfGlgRdmDOxQ0SQ4FYzwfCux/oCLboy63Qdl+k1CQjVy/gNexfSdz5AJeuYGEAS+0b8t/LB3ztT7OUyCUPp9LeyAz9Bj7SqqdHVdOWMOun/caWFH2oWlmNP/nk0PBWDA/4NkC7H+hIjugLr+Esm2WUJBN5KYFvHIyCQNexpZgY3THianaA/2ndE91qY+4c4GhgQyc0TPVbaM7TSQhNsGgirIfdyhohJZ3NVrop2Ap4dkC7NtRkR2TQ8GvEgoMlu4CXp0m5egFvHIiCQNeZs7bizix/7Q+rtW2Jo83qWJgRTnPo3Ur0LBrbX189ugFpg+db2BF2ZM7FDREi1iNFjYOLCU9W4B9OyqyE+ryCyjbLxIKDHT9Hign/j3FF+/k/AW8chIJA15kz+Z/Wfbpan0cXjAPvT7reJNniDvVbXR7ChTNp4+/mfID23+SzXbSo2kmNL/6aBHfoIV9DpZSni3AvhMV2QV1uTXKtlFCgUF6jetI+D1h+njp2NyzgFdOIGHASyTG2xjVcWKqX3QDpnYnJFzaA1khINg/TbtgTOdJxEXHG1RR9ucOBc+hRaxCCxsPltKeLcC+CxXZFXW5JSpxg4QCDwsJD6Z/Ll/Ay5tJGPASs9/8itMHz+rjuh2epnqjygZWlPM9Uqscz/eoq4/PH7/I9CHzDKzIO7hDQT20iJVoYRPB8pBnC7DvRl3pjrrUApW4XkKBBz32/KNpFvCa81buW8DLG0kY8AJ//7KPFZ9/p4/zFgqn59gOxhWUi3Qd2ZZ77k9pF3w7/Uf++kG24c0IdyiokxwKJoGljGcLcOxBXemButQclfiThAIPuX4Br+XjvmP3pn8MrEhkhISBbC4hLpHRnSalbg9M60FQWKCBVeUe/kH+DJ7VO9VtY7tMJi4qzqCKvI+maWh+tdEiVqCFTQFLWc8W4NiLutITdakZKnGdhIIsFhQWyIBpPfSxewGvibl6AS9vIGEgm5v5+gLOHD6nj5/r9CxV61cysKLcp8LTD9Ok93P6+MLJS0wZNNfAiryTOxQ8ixaxDC1sqgGhYB/qSm/UpSaoxLUo5br1c8QdqdbgkVQLeJ0+JAt4ZXcSBrKxXT/vZdXE7/VxviIR9BjT3sCKcq/OH7ehYPEC+vj7Wev5Y80OAyvyXu5Q8Iw7FOSZBtbyni3A8S/qyqsSCrJYugt4bZQFvLIrCQPZVEJsAqM7TUx126AZPQkMlfaAEfwD/Rgyuzeapum3je06mZjIWAOr8m6apqH5Po0WvgQtzwywVvRsAY79yaGgMSpxjYSCTJb+Al6TZAGvbErCQDY1feh8zh69oI8bdq1N5ToVDKxIlKv5EM36NtDHl05HMnngHOMKyiHcoeBJtPBFaHlmgdXDbTDHf6gr/VCXnkclfItSTs8ePwd7tG4FGnSppY/PHjnP9NcWGFiRuBEJA9nQ9h//5pspP+jjAkXz0W20tAeyg44fvkShkgX18bovNrJl9TYDK8o53KHgCbTwhWh5ZoP1Ec8W4DiAihqAutgIlbBaQkEm6Ta6Pfnvy6uPv5m8VhbwyoYkDGQzcdHxjOkyOdVtA2f0JCDY36CKxLX8AnwZPKtXqnbBp92nEn05xsCqchZ3KKiBFv4VWp45YH3UswU4D6GiBqIuNkQlfCOh4C4FhgQw6Lp2wdguk4mPkXZBdiJhIJuZPmQe549f1MfP96zHI7XKGViRuF7ZGqVpMaCRPr58JpJJ/WcbWFHO5A4Fj6OFL0DLMxesHt6Dw3kYFTUIdbEBKmEVSjk8e/wc5JHa5VMt4HXu2AWmyQJe2YqEgWzkrx928e30H/XxPcXy0/WTNgZWJG6kw/svUKTUvfr4p/mb2LzyDwMryrncoaA6pogFaHnmgU81zxbgPIKKGpIcClZKKLhDaRbwmrZOFvDKRiQMZBNxUXGMva49MHhmL/yDpD2QHfn6+zJ4dm9MppR2wbie04i+JO2CrKT5VsMUPg8tfAH4VPfswZ1HUVFDURfroxKWSyi4Tf5B/gya2SvVbWO7ygJe2YWEgWxiysAvuHDykj5u2qc+FZ5+2MCKxK2Uqf4gLQc11seR56KY0HemgRXlHppPFUzhc5NDwWOePbjzGCrqddTF51Dxy1DK7tnje7GKz5RNvYDXCVnAK7uQMJAN/LFmB9/P3qCP732gAJ0+etnAikRGvfK/1tz3UCF9vOGrzWxatsXAinIXdyj4Ai38K/Cp4dmDO4+jot9IDgVLJRRkUHoLeP35vSzgZTQJAwaLiYxlbNeU9oCmaQye1Rv/QD8DqxIZ5ePnw9A5fTCZU36UPu81nSsXogysKvfRfCpjCp+NFr4IfGp69uDOE6joYaiL9VDxiyUU3IJ/oB+DZ13fLphC7BVpFxhJwoDBJg+cw6XTkfq4Wd8GlKvp4S1fxV0pVaUELwxtoo+vXIhmfB9pFxhB86mEKXwmWvhiA0LBSVT0W6gLdVHxC1EqybPH9yLlnyyTagGvi6cuywJeBpMwYKDfv/mLdV9s1MeFShak44cvGViRuFNt32nF/WWL6ONflvzOxsW/GVhR7qb5VEwOBUvA9ynPHtx1ChX9joSCW+g04mXuLXGPPv5hzs9s/VYW8DKKhAGDRF+O4bMe0/SxpmkMmd0bvwBfA6sSd8rH18qQ2b1Ttwt6zyDy3BXjihJoPhUw5ZmOFrEUfJ+59RMyk+t0ciiog4r/UkLBdfwCfNPu99Ftquz3YRAJAwaZ1H82l8+ktAdaDmzEw4+XMrAicbcerPwAL73RTB9HX4phXK/pKKUMrEoAaNbymPJMRYtYBr7PevbgrjOo6PdQF2qj4uajlM2zx8/GZAGv7EPCgAE2r/yDn+Zv0sdFSt3LK8NfMLAikVnavNWC4uWL6uPNK/5gw8LNBlYkrqVZy2HKMwUtYgX41rr1EzKT6ywqZnhyKJgnoSDZ9Qt4/TjvF35b9aeBFeVOEgY8LPpSDON6prQHTCaNwbN74+sv7YGcwOpjZcic3pgtZv22Ca/O5PLZyJs8S3iaZn0YU57JaBErwbeOZw/uOoeKeR91oRYqbi5KJXr2+NlMegt4fdZjqizg5WESBjxsQt+ZRJ5Lueys1eDGlKn+oIEVicxWomIx2rzZQh/HXI5lXE9pF2RHmrUMpjwT0SJWgW/dWz8hM7nOo2I+SJ4pmJOrQ0F6C3hN7DfLwIpyHwkDHrRp2RY2fJUyZVy0TGHav9fawIpEVnlpWDMeqHi/Pv5t1Z/8tGDTjZ8gDKVZH8KUZwJaxNfg+9ytn5CZXOdRMSOSZwpmo1Tu3M3v+gW81n/5K5uWbzWwotxFwoCHXLkQxee9putjk9nEkNm98fHzMbAqkVUsVgtD5/TBYk1pF0zsO4uLpy8bWJW4Fc1aGlOez9EiVoNffUC75XMyjesCKuaj5FAwE+WK99yxswEfPx/3FTnXtAs+7zlNFvDyEAkDHjK+z0yuXIjWxy8MbUKpKiUMrEhkteLli9L2nVb6OPZKHJ91nyrtAi+gWR/EFDYuORQ0wLOh4CIq5hPUxVqouBm5KhSUrlqS1kOb6uMrF6KZ8Kos4OUJEgY8YOPi3/hlye/6+P6yRVK9SYic68XXmlKycnF9vPXb7aybu/EmzxDZiWYtiSnsM7S834JfIzwbCi6hYkaiLj6Lip2OcuWO5XrbvduK+x9OWcBr4+Lf2XjN70+RNSQMZLHIc1f4vPcMfWwymxg6pw8+vlYDqxKeYraYGTqnD1Yfi37bpP6zU+1QKbI/zVICU9hYtLzfgV9jPPqr03UZFTsKdeFZVOxUlCtnL8rj4+u+IufaBbzG955O5HlpF2QlCQNZSCnFuF7TU10i89IbzSj5SPGbPEvkNPc/XCTViaJxUfF82m2KtAu8kGZ5AFPYaGNCgYpExY5JDgWTc3QoeLDyA7z0esoCXlEXYxjfW67IyUoSBrLQhoWb2bziD31cvHxR2rzV4ibPEDlVq8GNKV015RyRP7/fyfez1htYkbgbmqV4cihYA35N8WwouIKK/TTHh4I2b6dewGvTsq38vEj2+8gqEgayyOWzkalOfDFbzAyZ0xurj7QHciOzxczg2b2xXtMemjLoC84fv2BgVeJuaZZimMJGouVdC/7NAfMtn5Np9FDwDCp2IsqVsxbpsfq49/u4dgGv8X1myAJeWUTCQBZQSjGu53RiLqck9jZvtaBExWIGViWMVvShwnS4Ztnp+OgExnSVdkFOoFmKYgr9ODkUtMCzoSAKFTsuORSMR7mib/0cL1Gikizg5SkSBrLATws2pVpbu0SlYqk2sBG5V4uBjXioekl9vH3d33w3/UcDKxKZSbPchyn0o+RQ0BKw3PI5mUZFu8PAhWdwxXyeY0JBegt4rf/yV+MKyqEkDGSyi6cvM7FvyjKaFquZoXN6Y7F68JeCyLbMZnPyYlMp7YKpg+dy9uh5A6sSmc0dCkYkh4LWeDYUxEDcBNSFp3HFjEO5vPss/PQX8JopC3hlMgkDmUgpxWfdpxJ7JeV64LbvtKJYuaI3eZbIbYqUKkSnD1/WxwmxiYzpMhmXy2VgVSIraJYimEI/QMv7A/i/AHjwnCEVC3ETk2cKPkO5rnju2JmsePmitH07ZW2WmMg4xvWYJu2CTCRhIBOtm7uRrd9u18clKxfnxdeaGleQyLaa9q1P2SdK6+Od6/fw7dR1BlYkspJmKYwp9H20fD+A/0t4PhRMSg4FY1Eu7zwB74XXmqRawGvL6m38OO8XAyvKWSQMZJILJy8xqf9sfWz1cU9tXXsmrBBXmc1mBs/qha9/yt4U04bO48zhcwZWJbKaZi6EKfR/aPnWgf/LeDYUxEHcFNSFZ3HFjEa5vGua3WK1MGR271QLeE3sN4uLp2QBr8wgYSATKKX4tNsU4qJS1hBv/17rVEtqCnG9QiUK0vmjNvo4Mc7G6M6TpF2QC2jmezGFvoeW7ycIaIPnQ8G05FAwyqtCQbGy99Hu3dQLeI3tJvt9ZAYJA5ng+1nr+fP7nfq4dNUStBrc+MZPECJZkz7PUe7Jh/Tx3xv38fXEtQZWJDxJM9+DKeTd5FDQFvDgLqYqHuKmJ7cPRqKc3vEJu/WQxpSq8oA+/nPNDtbO3mBgRTmDhIG7dP74BaYM/EIfW32tDL5uoQwhbsRkMjFkVm/8An3122a+sYBTB88YWJXwNHcoeCc5FLQHfG/5nEyjEiBuBuris7iiP0Y5L3ru2HfAbHFfkXPtAl6TB87h/InsXXd2J2HgLiilGNN1CvExCfptHd9/kaIPFTawKuFtChYvQJeP2+rjxHgboztJuyA30swFMIW8lRwKOuDxUBA/y90+iP4I5cy+q2MWLVMkzQJeY2UBr7siYeAufDf9R7av+1sfl3nsQZoPaGhgRcJbPd+zLhWfeVgf7/n1X1Z+vsbAioSRNHN+TCHD0PKtTw4Ffh48eiLEz04OBSNQzuy5Bsb1C3ht+2EXa2b8ZGBF3k3CwB06e/Q8UwfP1cc+flYGz+qF2SztAXH7TCYTg2b2wj8o5Zf+zGELOPnfaQOrEkbTzPmuCQWd8GwosEH8HNSFWriiP0A5s9eVLukt4DVl0BecO5Z9ZzSyMwkDd8DlcjGmy2QSYhP12zp9+DJFShUysCrh7e65Pz/dRrXXx0mJdkZ1nIjT6TSwKpEdaOa8mEJeR8u3AQK7gObvwaPbIH5ucih4H+U868Fj31yRUoXo+MFL+vjqAl7SLrh9EgbuwLdT17Fz/R59XPaJ0jTtW9/AikRO0bBbbR6pXU4f7/v9P5Z/9p2BFYnsRDNHYAoemhwKuoIW4MGjJ0H8PNSF2rii/5dtQkGzfg14uEYpfbzjp92slgW8bpuEgdt05vA5pg2dp499/X2kPSAyjaZpDJrRk4DglE9+s9/6iuP/njKwKpHdaKZwTMFD3O2DwG6gBXrw6EkQv8A9UxD1Hspp7JUv7gW8eqdewGvIXM4cyV5tjexOwsBtcLlcjO48icQ4m35b54/aUKhEQQOrEjlN/vvy0X3MK/rYbrMzqsMEnA5pF4jU3KFgcHIo6OHhUGCHhC/dMwVR76Kcxp3fUrhkQTqNSNnvIzHOxpjOst/H7ZAwcBu+nriWvzfu08flnnyIJn2eM7AikVPV7/wsj9aroI///eMgS8Z8Y2BFIjvTTHkwBQ9MDgU9DQgFX6Eu1MEV9TbKacwsVtNX61OuZsoCXrt+3svXk2QBr4ySMJBBpw6eYeYbC/SxX6AvQ2b1xmSSv0KR+TRNY+D0ngSGpvSE5767iGP7ThhYlcju3KFgQPI5Bb1BC/Lg0e2QsCg5FLyFcpz04LHdV+QMntULv4BrFvB6fQGnD2WPcxuyO3knywCXy8XoTpNIjE9pD3T9pB0FixcwsCqR0+UrHEGPsR30sT3JwcgOE6VdIG5JM4VhCu6XHAr6gBbswaM7IGEx6mJdXFHDUI7jHjvyvQ/cQ5dPZAGvOyFhIANWfr6GPb/+q48rPvMwjXrUMbAikVvU6/A0VRtU0sf//XWIRSNXGViR8CaaKRRTcF+0fBvQgl4FLcSDR3dAwlLUxXq4ot7wWCh4vmddKjydsoDX7k3/sHK8LOB1KxIGbuHkf6eZOSylPeAf5Megmb2kPSA8QtM0BkztTlBYSg943v8Wc2T3MQOrEt5GM4WgBb2aHAr6gRbqwaM7IWFZcih4HeXI2u9d9wJePVPt9zFr2JecPCD7fdyMvKPdhNPpZFSnSSQl2vXbuo1qzz335zewKpHb5C0UQa9xHfWxw+5kZIeJOOwOA6sS3kgzBaMF9U4OBQNAC/Pg0Z2QsBx18TlcV4aiHEez7EgFixVItYCXLSGJ0Z1kAa+bkTBwE8s/+459v+3Xx4/ULkfDbrUNrEjkVrXbPsljjR/Vxwd3HGHhxyuNK0h4Nc0UhBbUEy3femNCQeLK5FAwGOU4nCVHadS9TqoFvPZu3s+KcbKA141IGLiB4/+eYvZbX+njgGB/Bs3oiaZpBlYlcitN0+g3uRvBeVLaBfPfX8rBnUcMrEp4u9ShYJCHQ4ELEr9GXWyQHAoOZeqrX70iRxbwyhgJA+lwOpyM6jABuy2lPdB9zCvkvy+fgVWJ3C6iYB76jO+sj50OJ6M6TsSeZL/Js4S4NXco6J7cPhgCWh4PHv3aUDAQ5TiYaa9coGg+uo+W/T4yQsJAOpaM+YZ//0j5hny0XgXqd37WwIqEcHvmpSeo0ayqPj686xhffrjcwIpETqKZAtGCurpnCoKHgincg0dXkLgadbEhriv9UfYDmfKq9bvUonLdaxbw2nqApWNWZ8pr5yQSBq5zbN8J5r67SB8HhgYwcLq0B0T2oGka/SZ1JSQi5brxrz5awYHtWdN3FbmTZgpEC+yClnc9WvBrYIrw4NEVJH6HutQI15V+KPt/d/Vq7nZBDwJCUtoFX8gCXmlIGLiG0+E+S9uelHKWds9PO5CvsCd/EIS4uTwFwnh1Qtp2QZJN2gUic2mmALTAzskzBW+AKa8Hj64gcY07FET2Rdn33/opN5C/SF56fppyRY7dltwukAW8dBIGrrFo5Cr++yvlJJZqDR+h7itPG1eQEDfwVOvHqdmyuj4+svs4C95famBFIifTNH+0wI5o+X5CCx4GJg+fP2X7HnXpeVyRfVD2f+7oJa5fwGv/n4dYPOrrzKrQ60kYSHZk9zHm/W+xPg4KC6T/lG7SHhDZkqZp9J3YhbB8KSvKLfxkJfv/zLyTr4S4njsUdEgOBW+BycNrrth+QF1qgiuyN8q+79aPv8bVBbxS7ffx3iKO7PHccsnZmYQBwGF3MKrjRBz2lCmjXuM6kreQtAdE9hWWL5S+k7rqY5fT5W4XJCYZWJXIDTTNDy2wfXIoeBtMHt6nxbYOdakprsietxUK8haKoPe4TvrYYXcm/+6/+QJeSimU4yQqcT0qYTkqfqH7T8JylO1nlPMMSqk7/nKyA4vRBWQHCz9eyYHtKddrP9b4UWq3fdLAioTImJotqvP0izX4eeFmAI7tO8m8/y2h80dtDK5M5Aaa5guB7SCgNcQvQcVNBdc5zxVg+wll+wnl+yxaUB80a9lbPqV2uyf5ZdnvbPlmGwAHth1m0SeraPNWi1SPU46j7nMW7HvAvhdUDOAABVydMVau5P+3gCkMZXkYzacC+D2HZi6UqV9qVsv1MwMHdx5h/jW91uA8gfSbLO0B4T36fN6JsPwpa80vHrWKf7ZmzmVZQmSEpvmiBbZ1zxSEvAemgp4twLYedak5rsjuKPvumz5U0zT6T+l+3QJeSzi06yhK2VGJ63FF9kJdauEON7ZNoKIBMxAIpmD31tBaEJhC3LdhBlck2DaiYsejLjbFdWUAyrYZpbzjJMVcHQbsSWnPKO0zvjMRBT254IYQdyc0bwj9Jl/TLnApRnWciC3BdpNnCZH5NM0HLeBltHzr0EKGg+lezxZg24C61AJXZFdU0q4bPiyiYB56f55yRY7D7mT1+HdxXWyCihoItt9wvz0Gut/wtQDQfEBL5y1TMyXfF+AOCgQCyl3LlT6oS61QSdsy+yvNdLk6DHw1YgWHd6XsoFWjWVWeeekJAysS4s480awatdrU1Mcn/j3FF+8suskzhMg67lDwIlq+H5JDgYenzG0bUZdb4brcGZW0M92HPPvyE9RoWoXAECe9R5yk09CtOBKPAX5gCgLNN6UdcDs0DTQ/98wBPuA4jIrshit6DMoVfzdfVZbKtWHgwPbDfDkiZeW2kIhg+k3qKu0B4bV6jetI+D1h+njp2NXs/e3Or80W4m6lhIK1aCEfgLmwZwtI2oS63Do5FOy4rjaNgZMqM37NIeq0isTlhOjLCkdmbgaqWUFLbkfEz0VdfumWbQyj5MowkJTOghN9J3YhT4Ew44oS4i6FhAfTf2p3fayUu12QGC/tAmEsdyhojZZ3LVrICINCwQu4LnfUp+xV4lqCtGHcc5+ThDiNJJsJFMReicvcKwM0DTR/dxvBcRQV2R1l+y3zXj+T5MowsOD9pRzZnXJtac2W1Xmq9eMGViRE5njs+Uep0/4pfXzqwBnmXLP7phBG0jQrWkDL5FDwEZjv82wBSZtRl1/CdaEhKuo1UDbMlhCsvr76Q5x2JwmxiZl/bM3sbh244lDJJxdmJ7kuDOz/6xALP1mpj8PyhdB3YhfjChIik/X8tAMR96acBLt83Hfs3nRnq7YJkRXcoaAFWt7v0UI/BnNRzxbgPAAqHkgCHASGBqCZUt4OE2ITbrn2wB3RNHcgUDZU1JAbns9ghFwVBpJsdkZ1mIDL6dJv6zupK2H5Qm/yLCG8S3CeIAZM66GPlVKM7jyJhLgs+LQjxF3QNAuaf3O0vGvQQkeC+X4PV+AAdQUTUQTn8Um5OSvaBVdpmvs8AlccKup1lCs6849xB3JVGJj33mKO7Tupj59+sQY1W1S/yTOE8E7VGjzCcx2f0cenD55l1rAvDaxIiBtzh4KmaHm/QwsdBeZiHq7AjtUaS2heF1YfdwBw2p0kxCRkzeE0zX0OgesMKubTrDnGbcoRKxA6nU7OHDrH4b+PceV8NEopQvMGU6zcfRQqWRCL1cI/Ww+weNQq/Tlh+UPp83mnm7yqEN6tx9hX2Lbuby6cvATAyvFreKJ5NSo89bDBlQmRPk2zgH8T8Gvk3sY4diI4Pbc9t8XiIiQc7EkaCbEmEmIT8fHzweKTBW+VmhmUFRJXofxqofkae1m7V4eBi6cv8+PcjXw/ZwNXzkXhsDswJfd9XC6F2WIiODyIWi/XZMPCzbhcKVM+/SZ3JTRvyI1eWgivFxgayIDpPRhW/0P9ttGdJjFt12j8g/xv8kwhjKVpZvB/HvwauJcEjp0IzkO3fmImsfoorOFO7EkaiXExBFrDsuiyc19QsajoDyDvSjTNLwuOkTFe2SZwuVx8N+Mneld5nQUfLuPS6UhMFjMBwQH4B/vjH+xPQLA/FquF6IsxLBq1ijOHU9bLrtWmJk80q2bgVyCEZ1SpV5EGXWrp47NHzjP9tQUGViRExmmaGc2/EVre1Wihn4KlhEePb/VRBIXacTkugbLh3pggE13TLiDxx8x97dvkdWEgKTGJT9qPZ/KA2cRHJ+Af5H7jt/pY0EwpyU0zaVh8LFh9rTiv2Y3Q6mOhwwcvGlG6EIboNro9+e/Lq4+/mbyWHeuz58InQqTHHQoaokWsRgsbB5YHPXp8s9kFKsq9/0BmhwLNDApUwmJDdz70qjBwdavh31b9idXXSkCIf6oAkIZSxF6JS32bSWNcj+mybrvINQJDAhg0o2eq28Z0nkx8Vp0cJUQW0TQTml99tIiv0cLGg6WUhytwZE0o0HzBvgccGd+OObNl73MGDs+BLR31oUmZ6PmkD08Vuocl66py9uLNLwmMj0nQLyN84L4rdH5xH/cXiSIkcDEs/Qjyl4MHe0Oxtln5VQhhuEdql6dR9zqsnroOgHPHLjBtyDz6T+lmcGVC3D5NM4FfPfCtA7Z17nMKHP/e/QufuILpwAVUoA+q2s3WPkgOBcrivkxQ8wGSP5jGJ6IdOAKRUaAUhAajStwPIUE3eT0rkIRKWIVmNeYEX++YGag+m/Olv+Z/E+vx7c+lqVL2BP/r9Q2B/jf+dO9IcpAYl3J/UJCdK7EhLPy+Cu9PqsXo6dWITsoLv7eDPR944qsQwlBdR7bjnvvz6eNvp61j27ob7+wmRHbnnimohxaxEi1sIlgeurvXOxPl/m9cEkRlZF0OB6hrZp+T7GjbdkN8IqpMSVS5UuBSaNv2QNxNNinSNPckQ9Kfd1X/3fCOMBBaluULLrN9dzjfbHqUVRsqEhacQJWHj6b/+HTaA4fPFmPGipr8ur0k/528jy07CjJ5aV2IqAYHp2X91yCEwQKC/Rk0s1eq28Z0mUxcdPbdSU2IjHCHgjrJoWAyWMrc/otEJ6LFJqEiAtyvmRwMbn3wQK7OCmjHTkGSHVXxIcgfAXnD3f9v0tAOH7/F61jAeRLlir392jOBV4SBhLhENiz8FZPZhKZpHDrpPhkqNDj9nue17QEAX38frL5WfaxpGmaLma3fbidJhbj/EYTIBSo+U5YmvZ/TxxdOXGLqoLkGViRE5tE0Dc2vFlrECrSwKWDK+N4H2hn3SoDqgbyoUD84FwvXvI+kz5LcIkh2/hKEh4L/NZcIWizuYHAhElw3O8fAAjjA8V+Ga85MXhEGju07SXxMov6Gnj88BoAzF9KeM+BIsqdqD5hMGgGhAfpY0xQmk4uICCe1q+3Bcnk9lHkti78CIbKPzh+3oWDxAvp4zcyf+PP7HTd5hhDexR0KngX/ZoAvtzw9zumCczGoYF8I8kUVDEFzuuD8LT6lXzMrgNMJCYkQFJjmYSooEM3lct9/Q2bABQ5jth33io/Epw+cxGRy4e/v5KFip2leawf7Dt3DX/uuO8FDKWKvpJ7y9AvyS3VpYbfWv1Gvhvsv2243sW5fCwrd9ySck41cstLhv4/ddCw8q0X/hkzoO0sff/LKBF6b0xv/YFmMSOQc9+T9j9AQDZcrGJQDVALgTPM40/k4rA4X9vyhuJI0yBOCj/kCnIrGHpH6Q6dSuPv7Glj9fNCvZ3M40ACXNZ231au32e3ADX7GNA2UGeW8QFYsb3QrmjLywsZbue5qgqtOngvj7QmNiU/0TXW7y+kk5nIcTkfaf+yr8kXEkyckkbAQG9UrnaHBs4eZsbAcS7/z9CUqQgghslL/0Sd4pmkkcdHmmz4u9OgxrAkJXHqwJMrsfmzQ6dP4X4ni8gMP4PT1SfMci1UjKDwEc/LjsdkwbfoLV4micH/h1A8+ewHTnv9wVSkPocE3LkTFQcDLmIKH3NbXmRm8Ymbgx0Nd+G7RKcLCTTxW4RB1HvuXvm3W8/HM+qkeZzKbCc0XTPSlWBxJ6W8/eeFSABcuudsGf+wqCEDn1ntYt+l+omJ8032OEEII72M23/qzrikpCWt8PEnB7jdpzen+MJkUHIL/lSj8rlwhrkD+tE/UzJjN13TaLRb3hIHdkXb1gavbIVsy8JarbnWeQtbwijCQaC7GwROJ+Ef6s/fQvZhMilrV9lOt3GG27i5+3aM1rD6WG4aB6+0/HM7ztQ9TMH+shAEhhMhB7DYTSt180t0/8goa4BsTg+/+mDT3+0ZFEZc/n3sa/xqOJAdOhwuzJXlmwGyGAD+IjUvzGlpsHMpkSn1i4Y1oaWchPMErwkDBBwrgcu5FuRSaSWPBt9WoVu4orett4489xdL8Y/sG+Ka6eiA9Sils8TYat/BBYaLXjPdxmsOz8svI1Q7/fYzxfWbq41cndKZ4+Zst6iE8ZdWE7/l58W/6+NF6FWjzZgsDKxIic+SPmIOP/xosvjfo0yuFz8GDKD9f7CXvA5UEyklSkobDruETHUvA5cv4xMbqMwdX+QX6pQSBq/JFwPHTkGgDv+QPlw4HnL8M+cLhZivmJtO0my1OlHW8IgzcV7oQFqsFe5IDHz8rcQm+rFxfgbaN/qBGpYP8ur1kqsebzCZM5tQXSnRtsYkEm5WDx/MRFRtAoG8c1csf5sGIY/DQEB6qVMOTX1KuV7x8Uco+cXcLhIjMUbJycQ7uPMLJ/84A8NfaXTzfsx6PN65icGVC3B0VXw0V/T1msyXNJ3sALlxGS7LjKlEUU768JMQmuq9GsyqwgsPHF//ISPyuXEkVBsxWMwEhaQOGKloI7cx5tJ37UMXvA5MJ7ehJcLlQxYvcolgX4PL4ZkxXecWlhfkK5+Wh6g/iSLLrt32/+WEuRAbRovZ2NO3WPZYDx/JTosgFOjf7jbe6fUvPFzZToIALV/UvoNLIrCxfiGzN19+XIXP6YLrmU8u4HtOIvpR2ylQIr2It5d4IiPTbxtrpcyhNIz44mMhzUSTGJiZfLuCmLBaSQoLwiYlFcyS/hqYRFBaY/pbGPlbUo+XA3w9t7wG0v/8Fk4aqXBYCA9I+PhUHYHHXbIDsfTXBNX5dsZWRr0zA4mvF6nN3ExoOu5OkhCR6ftoh1fauIuvs+fUfBjz5jj7+9JfhMjOQzUx/bT6LR63Sx8++/ARvzO9nYEVC3B2lbKjzTwIO0FJ/knc5Xe6ZgHhbqgBwldlixj/YD1uCDXtiSpjwD3bvlJv5xcaDKRQt7/r0g0YW84qZAYDHm1ShUq1y2BOTUDddxenmlFIkJdh48NHi1H3lqUysUAjv9sr/WnPfQ4X08fovf2XT8q0GViTE3dE0X/e0u0p5M3c5XcRFxRN5PorEuMQ0QcBsNROUJ4iw/CEAqYKA2WrBPygDJwHeESdYyhkSBMCLwoDJZKL3uI6E5gshITZBDwRXVxS82Z+rlFIkxCQQEBJA34ldsKS3OIQQuZSPnw9DZvdO1S74vOc0rlzI4BrtQmRDmp/7EnSX05GxEJAvBF9/H1xORVxU8iJ2yY8NCvVHU7iXFb72z91OsCtncq317u517oJXvRvmvy8f7ywZxPCWY4i6GI2Pvy8vNthJq7rbb/q8PiNe5OyFAGzxNvyD/Rm2oB9Fy9ziZA4hcqHSVUvSemhTFn68AoArF6KZ8OpM3lo40ODKhLgzFy8/hr9Nw+W6gi0+7edfs9VMQLA/Pn5W9KWFUcRGxekfOkOPHccn/sYbeik/X9QTj95FlYlgCgc/49rWXhUGAB6s/AAj1rzJuJ7T+O+vQ6z+sSh/7S6MyZL+JIfL6eLUKQ2Hw0bRMoXpP6U7JSoV83DVQniPdu+2Yss3f3F07wkANi7+nZotfuepVo8ZXJkQGXf+xEUWfrSC72etp+s7/tRtnYi+jjA3CgFutvgk7IkpJ6wnFCmMOdTvxssEm+5ikl0pUC40/+ZoWla1IG7N68IAuC81/OSHt1k9dR3fTF7LPwcugeZ+4zcl/6O4XAqTWUO5FHkKhNGwWx2a9a2Pj58xCzoI4S18fK0MmdObV6sP03f/HN97OuWfKkOe/Gk3BxMiOzl37AJffbSCtbPX40jel+aHReHUahGJj6/C6bLcMARA8jkF127rrWkEFAxHu35NgUyT6F5oyK9pFr1+xnhlGACwWC007VOfRt3rsP3H3ez7fT8Hth/h0pnL4II894RS8pHilK5akkefq4jPLRYhEkKkeLDyA7z0ejMWfLgMgKiLMYzvPZ23Fw8y7AQnIW7m7NHzLPxoBWvnbNBDwFUHdwew87ciPFb3LGZLUPLlhulJ3R4ACAhOZ3GhzKKcgAMCOqJZjG1de20YuMpitVC1fiWq1q9kdClC5Cht3m7B79/8pe8wuWnZVn5e9BvPvCgLdIns48yRc3w1YgU/fPFzupvUlaxcnPbvtqZq/eJw+QVwngOC0l2EKPG69oDFx4JfVl09oJR7F0VLcbSg7llzjNvg9WFACJE1rD5WhszuTZ9qb+i/ZMf3mUGFp8sQfk8eg6sTud2Zw+f48sNlrJv3S7ohoFSVB2j3TiuqNnhEn81SIcNQVwYCNiD1m7zT6ST+uvZAUFggWpZtKJwImgUt5F00zfitw73m0kIhhOeVqFQs1T4FMZdjGddzOl6yVpnIgU4fOsvoTpPoUKov38/ekCYIlK5Wkg+/Hcb4LR9RrWHlVG0tzfdpd29e2d37EOgUcVfir2sP+Gdhe8AGONECO6L5VMyaY9wmmRkQQtzUS8OasXnVHxzaeRSA31b9yfovf6VWm5rGFiZylVMHz7Dgw2X8NH+TfmLrtR6qXpJ277bm0boVbnpeixbyBkpFQuKG5Bt83O0B2/XtgSzaxVbZADv4NYHAnllzjDsgYUAIcVMWq8XdLqj6un5i1sS+M6nwzMPkvVd2+hRZ6+R/p1nw4TLWL9iEK53VZ8s8Xop277Sicp3yGTq5VdOsEPoRSr0Gtp9xupzERyVe+4CsaQ8ohbs9YQe/59FC3kLTss/kfPapRAiRbT1Q4X7avt1KH8dExjGuxzRpF4gsc2L/KT5u/zmdy/Tnx3m/pAkCZZ8ozSc/vM1nm96/5WzA9TTNDy1sFPg1wp6YgF+gE01zv35ASBa0B5QLVCzgAv92aCH/c4eSbERmBoQQGfLCa03YvOoPDmw7DMCW1dv4cd4v1Gkve3yIzHP831Ms+GApPy/cnO5MQLmaD9Hu3VZUfKbsXV3mqmk+fPNlTXat/YPOb50mNNyJy2nCPzAT2wNXZwOUHcwF3LMBvk9m3utnIgkDQogMudou6P3oa9iT3Ju3TOw3i0q1ypK3UITB1Qlvd2zfCeZ/sIyNi35Ld8ap/FNlaPdOKyo8/XCmrHVx5vA5pg+dT2J8GLu3BNLj/bM8+XwiuGJBswK+6V5+mCF6S8ABmMC/CVrwIDRT9l20S8KAECLDipW9j3bvtmbWm18CEBcVz9huU/lw9RuyGJG4I0f3nmDBB0vZuPj3dENAhacf1kNAZnG5XIzuPMm9fTEQecFKtO0dzOEhqPjFkPQbEAdKA6yABW7V31cuwOG+SkED8AHfOmgBrdF8qmRa7VlFwoAQ4ra0HtKYzSu3sv/PQwD8uWYHa2dv4LlOzxpcmfAmR/YcZ/77S9m0dEu6IaDis2Vp904ryj9ZJtOP/fXEtfy9cZ8+Lv9UGRr3fg7NZELzfQLlOI5KWAmJq8B1BfdUvyl5xcDrQ4FKnkFQgAXM96D5N3PPBpjvyfTas4qEASHEbTFbzAyZ3ZuelV/TL8eaPHAOj9QpT/4ieQ2uTmR3h/8+xvz3l7Bp2dZ073+kdjnavdOKsk88lCXHP3XwDDNen6+P/QJ9GTyzl76vDYBmuQ8tuC8qqA84T4NjPzj2o+z7wBUJKhHQQPMFcz40S2mwlAJraTDd45WzZBIGhBC3rWiZInQY/gLTX3P/Uo2PTmBs1yl8tOZNr/xFKLLeoV1Hmf/+Un5dfoMQUKe8OwTUKJ1lNTidTkZ1nIgtIWXBoa6ftKNg8QLpPl7TTGAp7P5DrSxbizA7kDAghLgjLQY24tcVW/lnywEAtv2wizUzfqJB19oGVyayk4M7jjD//SVsXvlnuvc/Wq8C7d5pRZnHSmV5LSs/X8Pezfv1ccVny9KoR50sP643kDAghLgjZrO7XdCj0hCSkjd3mTLoCyrXrUCBovkMrk4Y7cD2w8x/fym/rUo/BFSpX4m2b7ekTPUHPVLPyf9O6ye+AvgH+TFoRs9U7YHcTP4WhBB3rEipQnT84CV9nBCbyJguk2Uxolzsv22HeLvJx/R69LV0g0DVBpUYv2UEI74d5rEgcLU9kHTNjoTdR7fnnvvze+T43kBmBoQQd6VZvwb8umKrPv2646fdrJ66jud71DW4MuFJ+/88yLzhS9j67fZ076/eqDJt325JqSolPFwZLP/0W/b9/p8+fqROeWlnXUfCgBDirpjNZgbP6k2PioP1E7OmDZnLo/UqULBY+idmiZzj3z8OMG/4Ev74bke69z/W+FHavt2SBys/4OHK3I79c5LZby/UxwHB/gya3kNOdL2OtAmEEHetcMmCdBrxsj5OjLMxpvNkXK60u8uJnGHflv8Y1uBDXq0+LN0g8HiTKkz66xOGr3zNsCDgdDgZ3XFiqh0Je4x9hfz3yTkt15OZASFEpmj6an1+Xb6V3Zv+AWDXz3v5etJamvapb3BlIjPt/W0/84YvYdsPu9K9v0azqrR9uyUlKhbzcGVpLRnzDf/+cVAfV3muoiyOdQMSBoQQmcJkMjF4Vi+6VxisL/M68/UFVK1fiXsf8J6V2ET69mz+l3nDl7B93d/p3l+zRTXavNWSByrc79nCbuDo3hPMfXeRPg4MDWDANGkP3Ii0CYQQmebeB+6hyydt9XFivI3RnSZJu8CL7d70D0PrDGdAzbfTDQI1W1Zn6s7RvLNkcLYJAk6H++qBqxtqAfT8tAP5CsuGWjciMwNCiEz1fM+6bFq2hV0/7wXcbyYrx6+heb+GBlcmbseujXuZP3wJOzfsTXOfpmk82ao6bd5qSbGy9xlQ3c0tGrmK//46pI+rNXyEuq88bVxBXkDCgBAiU5lMJgbN7Em38oNIjHO3C2YN+5KqDR6hcMmCBlcnbmXXz3uZN3yJHuaupWkaT73wOG3ebMH9DxcxoLpbO7L7GPP+t1gfB4UF0n9qd2kP3IK0CYQQma5gsQJ0G9VeH9sSkhjdaSJOp9PAqsSNKKXYsX43A59+h8HPvpcmCGiaxjMv1WD67jG8+WX/bBsEHHYHIztMxGFP+T7r/Xkn8t4bbmBV3kFmBoQQWaJR9zr8unwL23/cDcDezftZMe47Wg583uDKxFXuELCHef9bzJ5f/01zv8mk8cxLT/Dymy24r3QhAyq8PV99tIKDO47o48caP0qtNjUNrMh7SBgQQmQJTdMYON3dLoiPSQBg9ltfUbXBI17xxpKTKaXY/uPfzBu+JNXGPVeZTBrPtqnJy8OaU6SUd/xbHdx5hAUfLNPHweFB9J/STdoDGSRtAiFElilQNB/dR6e0C5IS7YzqKO0Coyil+HPtTvo/8Rav1/sgTRAwmTTqtH+Kmfs+47UvXvWaIGBPSv6+cqR8X/UZ35nwe/IYWJV3kZkBIUSWqt+lFr8s26IvUvPv1gMsHbOaF4Y2Mbiy3EMpxV9rdzL3f0v4d+uBNPebzCZqt3uSl4c1p1AJ7zvJ88sPl3N41zF9/ETzajzzYg0DK/I+EgaEEFnK3S7oQddyA4mPdrcLvnh3EdUbPULRMtnzRLScQinFH2t2MH/4klQr8V1lMpuo2/4pXhrW3GsXhjqw/TBfjliuj0Miguk7sYu0B26TtAmEEFkuf5G89Py0oz6229JO64rMo5Riy+ptvFr9Dd5q9FGaIGC2mHmu07PM2f85g2b28togkGSzM7LDBFzOlEWt+k7sQp4CYcYV5aVkZkAI4RH1OjzNpmW/65va7P/zEItHfc1LbzQzuLKc42oImDd8CQe2HU5zv9lipl6Hp3nxjWY5YkfJBe8v5eieE/r4yVaP8VTrxw2syHtJGBBCeISmaQyY2p0uZQcSFxUPwNz3FlH9+crZchU7b6KU4vev/2L++0s4sP1ImvstVjP1Oj7LS280o0DRnLFj3/4/D7Lwk5X6OCxfCK9O6GxcQV5O2gRCCI/JWyiC3uM66WOH3b2GvMPuuMmzxI24XC5+XbGVnpWH8m6zkWmCgMVqplH3OnxxYDz9p3TLMUEgKTGJUR0npm4PTOpKWL5QA6vybjIzIITwqNrtnuSXZb+z5ZttABzYdphFn6yizVstDK7Me7hcLjav/JP5w5dw+O9jae63+lh4rnMtXny9KfmL5DWgwqw1973FHNt3Uh8//WINaraobmBF3k/CgBDCozRNo/+U7nT9dQAxkXEAzH9/CdWfr5xtdr3LrlwuF78u38r895dyZPfxNPdbfSzU71KLF19vlmN36Ptn6wGWjP5aH+cpEMqr46U9cLekTSCE8LiIgnno/XnKL/Cr7QJ7kt3AqrIvl8vFxsW/0b3iYN5vPTZNELD6Wmnapz5zD03g1QldcmwQsCXY3O0Bl9Jv6z+lOyERwQZWlTPIzIAQwhDPvvwEm5b9zuaVfwJwaOdRvhqxgvbvtTa4suzD6XSyaekW5r+/NNW0+FU+flYadqtD66FNcsVmPF+8s4gT/57Sx7Xa1uTxJlUMrCjnkDAghDCEpmn0m9yN3Zv+JfpSDABfjljO402qUKJSMYOrM5bT6WTj4t9Z8MFSjv9zKs39Pn5WGnWvS+uhTYgomDuW3N37236Wjl2tj8PvCaPXZx1v8gxxO6RNIIQwTJ4CYakuB3M6nIzsMCHXtgucTic/LdhE13KD+KjNuDRBwNffhxYDGjHv8ER6ftoh1wSBxHh3e0Cpa9oDU7sTEi7tgcwiMwNCCEM91fpxfln6O5uWbQXgyO7jLHh/GR3ef9HgyjzH6XCyYeFmFnywlJP/nUlzv1+AL8/3rEurwY1z5ep6c976ilMHUv5e6rzyFI89/6iBFeU8EgaEEIbSNI1XJ3bl7437iLrobhd89fEKHmtShVKPPmBwdVnL6XCy/stfWfDhslRvdlf5BfjSuFc9Wg5uTJ78ufMa+t2b/mH5uO/0ccS9eej1qbQHMpu0CYQQhsuTP5RXJ3bVxy6ni9EdJ5Jky5ntAqfDydo5G+hUpj8jO0xIEwT8An15YWgT5h2ZSNeR7XJtEEiIS2R0p9TtgYHTexIUFmhgVTmTzAwIIbKFp1o9xq/LH+fnRb8BcHTvCeb9bwmdR7xscGWZx2F38OP8TXz54TLOHD6X5n7/ID+a9KlPy4GNCM0bYkCF2cusN77k9KGUv6fnOj5D1fqVDKwo55IwIITINvqM78zODXu5cj4KgMUjV1KjaRVKVy1pcGV3x2F3sG7uRr4csZyzR86nuT8g2J8mfZ6j5cDn5Zr5ZLs27mXlhDX6OF/hCHqMfcXAinI2aRMIIbKN0Lwh9Jt8TbvApRjZYSJJiUkGVnXn7El2vpv+Ix1L9WVs1ylpgkBAsD9t3mzBvCMT6fThyxIEkiXEJjC606RUtw2c0ZPAUGkPZBWZGRBCZCtPNKvGsy8/wfovfwXgxL+n+OKdRXQd2c7gyjLOnmTnhzk/89VHKzh37EKa+wNC/GneryHN+zckOE+QARVmb9NfW5AqODXsWptH61YwsKKcT8KAECLb6T2uEzvX7+Hy2SsALB37DTWaVaXMY6WMLewWkmx21s7ewMKPV3D++MU09weGBtC8X0Oa9WsgIeAGtv+0m28mr9XH+e/LS9dR3hMEvZWEASFEthMSEUy/Kd14t+lIwN0uGNVxIlN2jMLX39fg6tJKstn5fuZ6Fn6yggsnLqW5PygskOb9G9KsbwM5E/4m4mMSGNtlcqrbBs3oSWBIgEEV5R4SBoQQ2dLjjatQu92T/DjvFwBO/neG2W8tpMeY7HMSWVJiEmtmrmfhxyu4eOpymvuD8wTSvH8jmvWtL/3uDJg2ZF6qtsrzPerySO3yBlaUe0gYEEJkW70+68j2H3dz+UwkAMs/+5YnmlWl7BMPGVpXUmIS303/iYWfrODS6cg09weHB9FiQCOavlpfPtVm0F8/7OLbaev08T3356PryLYGVpS7SBgQQmRbwXmCGDitO289/zEASilGdZrE1J2j8QvwfLvAlmDj22k/smjkKj2gXCskIpiWA5+nSZ/nCAj293h93iouKo6xXVO3BwbP6o1/kPwdeoqEASFEtlatYWXqdXiGtXM2AHD64FlmDfvSozvW2RJsfDv1RxaNXKmf1HitkIhgWg16nsa9JQTciSmD5qY616JJ7+eo8PTDBlaU+0gYEEJkez3GvsK2dbv0vvyKz7+jRrOqVHgqa98wEuNtrJ7yA4tHrSLyXFSa+0PzBtNqcBMa96orn2Lv0J/f7+D7Wev1ccHiBej8cRsDK8qdJAwIIbK9oLBABk7vwbAGI/TbxnSezNSdo7LkTTghLpHVk39g8eiv9dUQrxWWP5TWgxvTqGdd/AP9Mv34uUXslTjGdp2ijzVNY8js3vJ3agAJA0IIr1DluUrU71yLNTN/AuDM4XPMeH0Br07okmnHSIhL5JtJa1ky+muuXIhOc39Y/lBaD2lCox515A0rE0weOCfVVRjN+jagXE1jTw7NrSQMCCG8Rvcx7fnrh516f/nrSWup2aI6FZ8pe1evmxCbwKqJa1k65mt9G+Vrhd8TRushTWjYvY4hJy7mRFu/3cYPc37Wx4VKFqTjhy8ZV1AuJ2FACOE1AkMCGDyzF6/VfV+/bUznSUzdNeaOTtyLj0lg1YTvWTr2G6IvpRMCCubhhaFNaNitdrZc7MhbxUTGMrbbVH2saRqDZ/WSoGUgCQNCCK/ySO3yNOxWR78m/ezRC0wfOo9+k7tl+DXiouP1EBBzOTbN/RH35uGFoU1p0LWWhIAsMKn/7FSXZrYY0IiyNUobWJGQMCCE8DrdRrXjr7U79dXqVk9dR80W1W+5Wl1cdDwrP1/Dsk+/ISYyLs39eQuF88JrTWnQpRY+fj5ZUntu99uqP/VVJQGKlLqXDu+/YGBFAiQMCCG8UECwP4Nm9mRo7eH6bWO6TGba32PSXfEvLiqOFZ+vYflnq9MNAfkKR/Di6814rtMzEgKyUPSlGD7rkdIeMJk0Bs/uLbMv2YCEASGEV6r0bDka96rH15PcO9ydP36RaYPnMmBaD/0xsVfiWDHuO5aP+5bYK+mEgCIRvPR6M+p1ehYfX6vHas+tJvSdmWq9hpaDGlOm+oMGViSukjAghPBaXT5uwx9rdnD2yHkAvpvxE0+0qE7pqiVY/tm3rPj8O+Ki4tM8L/99eXnpjebU7fC0hAAP2bR8Kxu+2qyP73uoEK/8r7WBFYlrSRgQQngt/yB/Bs/qxeBn3tNve7/1WECREJOY5vEFiubj5WHNqfPKU1h9JAR4ypULUXzec5o+NplNDJ3TR1oy2YiEASGEV6vw1MM06Fqb76b/CEBCTEKax9xzfz5eGtaCOu2flBBggAmvzky1iFPrIU0oVaWEgRWJ60kYEEJ4raiL0Swdu5r1X25K9/6CxQvw8rDm1G73JBar/LozwsYlv7Nx8e/6+P6Hi9Du3VYGViTSIz8dQgivE3UxmqVjvmHVxO9JiE3bDgD3fgbjfvuAPPnDPFuc0EWej2J87+n62GQ2MWRObzlPIxsyGV2AEEJk1JULUUx/bT5ti/Vi4Scr0wSBwNCUywpjr8Qxfeh8T5cokimlGN97eqrlnV96oxkPVn7AwKrEjUgYEEJke5Hno5g2ZC7tivVm8ahVJMbZUt1f+MGCDP2iDwuOTabwgwX129fN3cjv3/zl6XIF8POi39i0bKs+Ll6+KG3eamFgReJmpE0ghMi2Is9dYfGor1k95QcS421p7i9S6l7avNWSp198HLPZDMCQ2b0ZUPNtXC4FwGfdp/JwjVKEhAd7tPbc7PLZSMb3maGPzRYzQ+b0lpM3szGZGRBCZDuXz0YyZeAc2hXvzdKx36QJAkVKF+KN+X2ZvmcstdrU1IMAQJnHStFy4PPXvNYVJvWb7bHaczulFON6Tk+150ObN1tQomIxA6sStyIzA0KIbOPSmUgWfbKSb6etIynRnub+omUK0+atljzZqnqqAHC9V4a/wO+rt3Hi31MA/LRgE080r8YTzaplWe3Cbf2Xv/Lbqj/18QMV7+elYc0MrEhkhIQBIYThLp6+zKJPVvLd9B/TDQH3P1yEtm+3pGbL6phMt57Q9PHzYcjs3vSv8abeLhjXczrlaj5EaN6QTK9fuF08fZmJfWfqY4vVzNA5feSyTi8gbQIhhGEunrrEhFdn0v6BPqwcvyZNELi/bBHeWjSQqbtG81TrxzMUBK56qFpJWg9poo+vnI9iQt9ZmVa7SE0pxbge01JtBNX27VYUL1/UwKpERklcE0J43PkTF1n48Uq+n/kT9iRHmvuLly9K27dbUqNZ1dsKANdr915rtqzextG9JwD4eeFmajavxpMtH7vj1xTpWzd3I1tWb9PHJSsX54XXmtzkGSI7kTAghPCY8ycusvCjFXw/a336IaBCUdq904rHm1S5qxBwlY+vlcGze9P3sWG4nC4APu81nXJPliFP/tC7fn3hdvHUJSb1TzlJ0+pjYcjs3tIe8CLSJhBCZLlzxy7wWY9pvFKiD99M+SFNEHig4v28t3wIk7eN5Ilm1TIlCFxV6tEHePG1pvo46mIM43tPRymVacfIzZRSjO02NdXukO3fa02xsvcZWJW4XRLbhBBZ5uzR8yz8aAVr52zAYXemub/kI8Vo+04rHnv+UTRNy7I62rzdkt+/+Ysju48DsGnZVjYu/o2nX6iRZcfMLdbO3sCfa3bo49JVS9BqcGMDKxJ3QsKAECLTnTlyjq9GrOCHL37G6UgnBFQuTvt3W1Ot4SNZGgKu8vG1MmR2b16tPkyvZ3yfmVR4+mHyFAjL8uPnVOdPXGTywDn62OprZfCsXpgtN77sU2RP0iYQQmSaM4fPMabzJDqW6seamT+lCQKlqjzAB9+8zsQ/PqZ6o8oeCQJXlXykOC8Pa66Poy/FMK6XtAvulFKKsV2nEB+dsmV0h+EvULRMEQOrEndKZgaEEHft9KGzfPnhctbN26ifqHet0tVK0u6dVlR5rqJHA8D1XhrWjM2r/uDwrmMAbF7xBxu++pVnX65pWE3eas2Mn9j2wy59/FD1krQY2MjAisTdkDAghLhjpw6eYcGHy/hp/qZ0Q8BD1UvS7t3WPFq3gqEh4Cqrj5Whc/rQu8rr+qzFhFdnUuGZskQUzGNwdd7j3LELTBn0hT728XO3YW62KqTI3qRNIIS4bSf/O80nr4ynU+l+rPsi7WxAmcdL8dH3bzFu84dUqWfsbMD1HqhwP23fbqmPYyLj+KzHVGkXZJBSijFdJqfaPrrjBy9RpFQhA6sSd0tmBoQQGXZi/ykWfLiMDV/+qi/ze62yT5Sm3TutqFSrXLYKANd78fWm/LbqDw5sPwLAlm+28eP8X6jT7imDK8v+Vk9dx46fduvjh2uUolm/BgZWJDKDhAEhxC0d//cUCz5Yys8LN6cbAsrVfIh277ai4jNls3UIuMpitTBkTh96VR6qX/I4qd9sKj1blryFIgyuLvs6c+Qc04bM1ce+/j4MniXtgZxA2gRCiBs6tu8EH778GV0eHsD6dGYDyj9VhlE/vcuYn/9HpWez92zA9YqVvY9277bWx7FX4vi0u7QLbsTlcjGm82QS41K2k+78URsKlyxoYFUis8jMgBAijaN7T7Dgg6VsXPx7um+OFZ5+mHbvtKLC0w8bUF3meWFoEzav/IP//joEwB/f7WDtnJ95ruMzBleW/Xw9aS27ft6rj8s9+RBN+jxnYEUiM0kYEELojuw5zvz3l7Jp6ZZ0Q0DFZ8vS7p1WlH+yjAHVZT6zxczQOb3p+chQfYnkyQNmU7lOefIVlnbBVacPnWXm6wv0sV+AL4Nn9srUZaOFseRfUgjB4b+PMbzVaLqVH8QvS9LOBjxSuxyf/jKcUT++m2OCwFVFyxThleEv6uP46ATGdp0s7YJkLpeL0Z0mkRif0h7o8klb7n3gHgOrEplNZgaEyMUO7TrK/PeX8uvyrene/0id8rR7pxVla5T2cGWe1XJQI35dsZV/tx4A4K+1u1gzcz0NutQyuDLjrRy/ht2b/tHHFZ95mOd71jWwIpEVJAwIkQsd3HGE+e8vYfPKP9O9/9F6FWj3TivKPFbKw5UZw2w2M2R2b3pUGoLdZgdg6qAveLRuefLfl8/g6oxz8r/TzBr2pT72D/JjkLQHciT5FxUiFzmw/TDvNP2EnpWHphsEqtSvxLjfPuSjNW/lmiBw1X2lC9Hxg5f0cXxMAmO65N52gdPpZFSnSdgSkvTbuo5sxz335zewKpFVZGZAiFzgv22HmDd8CVu+2Zbu/VUbVKLdO60oXbWkhyvLXpr3b8CvK7ay77f9AGz/cTffTvuRRt3rGFyZ560Y953+9wDu80Zy499DbiFhQIgcbP+fB5k3fAlbv92e7v3VG1Wm7dstKVWlhIcry57MZjNDZvWiR6Uh+ifiqYO/oHLd8hQsVsDg6jzn+L+nmP3WV/o4INifgdN7etU6EuL2SJtAiBzon60HGNZwBH2qvZFuEHis8aNM/PNj3v/6dQkC1yn84L10+vBlfZwYZ2Nsl8m4XGk3YsqJnE4nozpOJCnRrt/WfcwrFCiae8+dyA1kZkCIHGTflv+YP3wJf36/M937H29ShbZvt6TkI8U9W5iXadq3Pr+u2KqfRb9zw16+mfwDTXrn/EV2lo5ZrV9VAe6TSet3ftbAioQnSBgQIgfY+9t+5g1fkmp/+WvVaFaVtm+3pETFYh6uzDuZTCYGzexJj4pD9OvrZ7w2n6r1K1GweM5tFxzbd4Iv3lmojwNC/BkwrYe0B3IBaRMI4cX2/PoPr9UdTv8n3ko3CNRsUY0pO0bx3rIhEgRuU6ESBen8cRt9nBhvY1SniTm2XeB0uNsDV1diBOj5aUfyF8lrYFXCU2RmQAgvtHvTP8wbviTVVrLXqtmyOm3faknx8kU9XFnO0rhXPX5dvlVfk3/3L/+wasL3NOub87bsXTzqa/b/eUgfV21QiXodnjauIOFREgaE8CK7Nu5l/vAl7NywN819mqbxZKvqtHmrJcXK3mdAdTmPyWRi0IyedKswSN+tb+YbC6hSv1KO2q3vyO5jzH1vkT4ODA1gwNTu0h7IRaRNIIQX2PXzXgY98y6Dn3kvTRDQNI2nX6zBtL/H8NbCgRIEMlnB4gXoNrKdPrYlJDG600ScTqeBVWUeh93BqI4TcdhTvp7e4zqRt5Bs1JSbyMyAENmUUoqdG/Ywb/gSdv/yT5r73SHgcdq82YKiZYoYUGHu0bB7HTYt36q3ZfZu3s/Kz9fQYkAjgyu7e4s+WcWB7Uf0cfXnK1O73ZMGViSMIGFAiGxGKcWO9XuY97/F7Pn13zT3m0waz7z0BC+/2YL7ShcyoMLc52q7oGu5gSTEJgIw680vqdqgEkVKee+/gXujqiX6ODhPIP2nSHsgN5I2gRDZhFKKbet2MeDJt3mtzvA0QcBk0qjd7klm7P2U1+f1lSDgYQWK5qP76Pb6OCnRzqiO3tsusCfZ07QH+ozvTETBPAZWJYwiMwNCGEwpxV8/7GL+8CXs+/2/NPebzCZqtanJy8OaU/jBew2oUFzVoGttflm2he3r/gbgny0HWDZ2Na2HNDG4stv31YgVHNp5VB/XaFqFZ156wriChKEkDAhhEKUUf63dydz/LUm14ttVJrOJ2u2e5OVhzSlUIuecue7NNE3T2wXx0QkAzHlnEdUaVaboQ4UNri7jDu44wpcjluvjkIhg+k3uJu2BXEzaBEJ4mFKKrd9tp+9jwxjWYESaIGAym3iu4zPM/nccQ2b1liCQzeQvkpeeYzvoY7vNzuiOE3E6vKNdYE+yM7LDhFT1vjqhM3kKhBlXlDCczAwI4SFKKbZ+u515w5fw31+H0txvtpip0/4pXh7WPEcveZsT1Ov4DL8s28Kfa3YA8O8fB1ky+mtefL2ZwZXd2oL3l3Fk93F9XLNldZ5q/biBFYnsQMKAEFlMKcWW1duYN3wJB7YdTnO/2WKmXoenefGNZrlqm1xvpmkaA6Z2p2u5gcRFxQMw973FVGtUOVuv87D/r0N89fEKfRyaN5hXJ3SR9oCQNoEQWUUpxW+r/qR3ldd4p8knaYKAxWqmYbc6fHFgPAOm9ZAg4GXyFY6g12cd9bE96eriPY6bPMs4ScntDJczZW+FVyd2JU/+UAOrEtmFzAwIkclcLhe/rfqT+e8vTXW29lUWq5nnOj3LS280I/99ske8N6vT/ik2LdvCltXbADiw7TCLRq6izZstDK4srXn/W8LRvSf08dMvPM5TrR4zsCKRnUgYECKTuFwuNq/8k/nDl3D472Np7rf6WHiucy1efL2p7ASXQ2iaRr8p3dhbbiAxkXEAzB++hMeefzRbbRL17x8HWDxypT4Oyx9Kn/GdjStIZDvSJhDiLrlcLn5Z+js9Kg1heMvRaYKA1cdC4171+OLgBPpO7CJBIIfJe284vcZ10scOuzNbtQuSEpMY2WEiLpfSb+s3uSuheUMMrEpkNzIzIMQdcrlcbFq6hfkfLOXonhNp7rf6WmnYtTYvvNZENn3J4Wq1qcmmZVv4bdWfgPs6/q8+WkG7d1oZXBl88c4iTvx7Sh8/+/ITPNGsmoEViexIwoAQt8npdLpDwPtLObbvZJr7ffysNOxWh9ZDm5D33nADKhSepmka/SZ3Zfemf4i5HAvAgg+W8VjjRylRsZhhde37fT9Lx36jj8PvCaP3NbMYQlwlbQIhMsjpdLL+q1/pVn4QH770WZog4ONnpXm/hsw9NJFen3WUIJDLhN+Th1cndNHHToeTUR0mYk+yG1KPLcHGqI7XtQemdCMkItiQekT2JjMDQtyC0+nk54W/seDDZammW6/y9fehUY+6tB7SmPB7ZJOX3OzpFx7nl6W/8+vyrQAc/vsYCz5YRofhL3q8ltlvLeTkf2f0cZ32T/F44yoer0N4BwkDQtyA0+Fkw8LNLPhgaapfqlf5BfjyfM+6tBrcWJZyFYC7XdB3Uld2/7KPqIsxAHz10Qoeb1KFBys/4LE69vz6D8s/+1YfR9ybh56fdvDY8YX3kTaBENdxOpysm7uRzg8P4JP249MEAb8AX1oPbszcwxPpNqq9BAGRSp78obw6sas+djldjOo4kSSbZ9oFifE2RnWahFIp7YEBU7sTnCfII8cX3klmBoRI5nQ4+XH+L3w5YjmnD55Nc79foC9Nej9Hy0HPE5ZPVm0TN/ZUq8fYtOwxNi7+HYCje04wf/gSOn34cpYfe9awL1N9/9br8AzVGlbO8uMK7yZhQOR6DruDH+dv4ssPl3Hm8Lk09/sH+dGkT31aDmwk12aLDHt1Qhd2/byPK+ejAFj0yUpqNK1KqSolsuyYuzbuZcXn3+njfIUj6DH2lSw7nsg5pE0gci2H3cGamT/RsXQ/xnSelCYIBAT789IbzZh/ZBKdR7wsQUDcltC8IfSddE27wKUY2WECSYlJWXK8hNgExnSenOq2AdN7EBQWmCXHEzmLzAyIXMeeZGfdFxv56qPlnD16Ic39AcH+NOvbgOYDGhISLpdhiTtXs3k1nnmpBhu+2gzA8X9OMfe9xXT5uG2mH2vG6wtSBdr6nWtRpV7FTD+OyJkkDIhcw55k54c5P/PVRys4dyydEBDiT/N+DWnev6GcbCUyTZ/PO7Nz/R4iz7nbBUtGf83jTatSpvqDmXaMnRv28PWktfo4X5EIuo9pn2mvL3I+CQMix0uy2Vk7ewMLP17B+eMX09wfGBpA834NadavgYQAkelCIoLpP6U77zYbCbjbBaM7TmTy9pH4+vve9evHxyQwpvOkVLcNntmLwJCAu35tkXtIGBA5VpLNzvcz17PwkxVcOHEpzf1BYYE079+QZn0bSF9VZKnHm1ShVtua/DR/EwAn9p9mztuL6D767j+9Tx86L1W7q1H3OjxSu/xdv67IXSQMiBwnKTGJNTPXs/DjFVw8dTnN/cF5AmnevxHN+tYnMFRCgPCMXp91ZMdPe7h8JhKAZZ+upkazqpStUfqOX3P7j3+zeuo6fVygaD66jmx317WK3EfCgMgxkhKT+G76Tyz8ZAWXTkemuT84PIgWAxrR9NX6MoUqPC4kPJgBU7vzduOPAVBKMbrTJKbsGIVfwO23C+Ki4xnTJfXVA4Nm9iQg2D9T6hW5i4QB4fVsCTa+nfYji0au0j91XSskIpiWA5+nSZ/n5BelMFT1RpWp2+FpfpjzMwCnDpxh9ptf3dFSwdMGz011DkzjXvWo9Gy5TKpU5DYSBoTXsiXY+HbqjywauZLLZ6+kuT8kIphWg56ncW8JASL76Dm2A9vX/a23sFZ8/h01mlWl/JNlMvwaf67dyXczftLHBYsXoMvHbTK9VpF7SBgQWSYuOp5dP+/l8K5j7N70T6r7/v5lH8XK3XdHPfvEeBurp/zA4lGr9Mu1rhWaN5hWg5vQuFdd/IMkBIjsJSgskAHTevBmwxFASrtg6q7RuBxOdqzfw5G/j3Piv9PYEmz4BfhSpFQhilcoSoWnHwal+LTrlFSvOWhmT/leF3dFU9fuZiFEJrh0JpLln33L+i83EXslDs2k4UhyYr9moxYfPytBeYJ4+oXHadG/Ifnvy3fL102IS2T15B9YPPprfYnXa4XlD6X14MY06lkX/0C/TP2ahMhsY7pM5vtZ6/XxAxWKEnk+ivjoBDSThsvhAk0DwGTWUC5FUFggwXmCOLLnuP68pq/Wp/e4Th6vX+QsEgZEplFK8fOi35jx+nyiL8eiaRq+/j6YzCYcSQ6iL8Xojw3KE4jL6cLldBEUFkiH91+k7itPoyX/8rtWQlwi30xay5LRX3PlQnSa+8Pyh9J6SBMa9agjIUB4jbioOLqUG8jFkylXvPgG+OAf5I/JnHaleJfTRUJMAraElOWMCz5QgKk7R8v3vbhr0iYQmUIpxfz3l7J0zDe4XC78g/zRTGnf2K8ymUz4+PmgXIrYqDgm9pvFif2n6TziZT0QJMQmsGriWpaO+VrfG/5a4feE0XpIExp2r3NHZ2MLYST/YH8efrw0Gxf/pt9mtzkIDEn/50bTtDTbIFd8+mH53heZQsKAyBQrPv+OJaO/xmQ2ERCU8cv2NJNGQHAAtoQkVk1YQ1BoAI17P8eqCd+zdOw3qWYTrgovmIcXhjahYbfambKCmxBGWPTJKrZ+uw2LjxlHkhNwf/qPi04gMDTtz1BcdDzKlTKRa/Gx8POi37i/7H0079fQY3WLnEnaBOLOHJ4DWzrqQ6dTIyrWj3+PFGTR2kc5ezE01cOvbxOERARj8UnJor4+dlrW2kKNR44RHGjjxOlgFn5Tmp+3FNEfE3FvHl4Y2pQGXWtJCBDe5wY/M/8cLsiMr0px8nTKybTB4UFYfa362J5oJyYyVh8HBjrp9OJBihS4SPH7LhMaZIOy70L59zzxlYgcSGYGxF1R1Wbx+bBfOXvwOOXLRNK81k7KPHCGgaNaEZeQsTdspRQD2qylRNGLzFxUjpNngnj28RO82WcrmqbYfbwiL7zWlAZdauHj55PFX5EQWctVdSafDv6ZiyfO6D8zD791mo6D6xIb7/7+jouKJzRfCJqmoVwuYqPiUr3GPfeaqVV9P8dOh7NlR2Hq1TyEQnHjxpwQNydhQNyVw8eDWb/WjtlahMNni2E2Qet626jy8FF+/qvUTZ+rlCIxNpFyJY5SqcwZRkysyobf7wNg1z/5KVzIzoCehzC3+Bkff7lsSuQM/x0MYOMGhdU39c/MU4+f59sfCwPudkF8dDyBoYHERSekag/4BfoSGetPp3faAxp+1ljq1TzExZOXyCdbEog7lPaUVSFuw7a1u3A5XVisZgAOncwLQGhwwk2fZ4u3ceVcFAmxidSofIr4BAsbt7p/EaLBQ9UfpEzbEfibLuETuyNLvwYhPOnP73egXAqzJfXPTP58zlRXEdjik0iISSDpmqsHTBZT8gJaWvIfsCS/zpHdKZcbCnG7JAyIu3Jw5xHQNP0KgPzh7vMCzlwIvdnTsCUkcfV0lfsLR3H8dDBoFgJDA/AP9CMmMhZz3kruB0ftybovQAgPO7zrKJrJlPZn5mIoQWGpTxxMiE1MNQ4KC9TXHrjq6uucP5F2e24hMkrCgLgrV85H4uOj4etjp8KDJ2heawf7Dt3DX/uKpnrczc5TDQlOIt7mT1j+EHwDfDFbLVw5F0VUdHIXy5Z2+2EhvFXclVisN/iZsfhYb3ipoF+QHxbrjTu7sVfiiYuOz6qyRQ4n5wyIuzJy8HepxifPhTFqTl1crtQ5M73FhExmE/5BfpjMJjSTiavTniaze8XC2MhYwtzPzpLahTDCyCE3/5kJCPEnyWbH5XTpjzFbTAQE3WJhIaWIuRwrO3KKOyJhQNyVz76owakL4QQHuXiswiHqPPYvfdus5+OZ9VM9zmQ24Rvggy0+CU3T8A/ywy/IF9CIjfcjOMCW5rVNzuQlh33DPfCVCOEZn86pwZlL4QQF3uBnRtMICgvElpCEf5AfCbEJ+Ab4pmkPpCe90C1ERkgYEHfl1Pk8HDgWjq+/D3sP3YvJpKhVbT/Vyh1m6+7i+uNMZhOBoYH4+Plg9bVw7af942fCqVHxECaTC5fLhMvpwmQ2EeabfEJUaFkPf1VCZJ1T58M4dCIcH78b/8xYfCz6OhwZ3cxLM2mE5A3OsrpFzibnDIi7kq9IBE67Ux8v+LYasfG+tK63DU1Le56AeyGV1J9e/txzP/5+dqqVOwKA0+4kX+EIAs4vBv97IaJaln4NQnhSWP6Q2/qZyajg8GDZo0DcMQkD4q48WLk4oPQTBOMSfFm5vgKFC1yhRqWDGXqNnfuLsOu/QnRpvplnq/5D2ZJn6NfxLzjzPVQcCSZzFn4FQnjWg4+WQKm7+5kBqFjqBNXKHeaRMscAKF0qCY4vdf9xyImE4vZIGBB3pWqDRzBbzNhtDv227zc/zIXIIFrU3o6muW7y7BRjvqjDL9tK0LruNv7XdwMlipyHx7+CYm2yqnQhDFG1wSP6Tp5X3cnPTOfmvzKw/U/0euEXAIqH/QG/tnL/STyfJbWLnEv2JhB37X8tR/PX2p233KnwVpRSJMQkUK7mQ3z47TA5GUrkSEophjUYwZ5f/8E/2P+uvs+VS5EQm8Cj9Sry7tLBmVilyG1kZkDctR5jXiEwNICE2ISbridwM+4gkIh/kB+9xnWSICByLE3T6D2uI36BfiTEJN7dz0xsAkFhgfQY80omVylyGwkD4q4VKJqPnp92xGwxkxCb8stN0xQmk+umfyBljwKzxUTXke0oXLKgkV+OEFmu8IP30m1UO8xmE4l3+DOTEJuI2WKmx9gOFCiaz8gvR+QAcmmhyBRPtXqMpMQkJvefQ0KM+7roF+rvpFXd7Td9Xs/3W3PypBWL1UKXj9tQp91THqpYCGPVafcUSQlJzHh9gftnJtCPF57bceufmeGtOHnKB6uPlZ6fdeCpVo95qGKRk8k5AyJT7dvyHxP6zODE/tOEh8aTP78Ds8WUatpfKYXL4cKeZOfoyTDy3X8vr47vQrmaDxlYuRDG2L3pH8a/OoMzh84RHhpPgfwOTOn8zDgdLhzJPzMFSxShz4QulKn+oIGVi5xEwoDIdInxNn6c9wvfzfiRUwfO4HS4MJndv9g0NJxOF2aLiYLFC1C/cy3qtH8qeSc2IXKn+JgE1s3dyJoZP3HmyDmcDhdmswmF+9ezy6kwW0wUKlmQBl1qU7vdkzfcw0CIOyFhQGQZl8vFsX0nOfL3MU7sP01Soh2rr4XCD95L8fJFKfpwYcxmWUNAiKucTifH9p7k8N/HOPnfaew2Bz5+VoqUupdi5YtStExhTCY51UtkPgkDQgghRC4nEVMIIYTI5SQMCCGEELmchAEhhBAil5MwIIQQQuRyEgaEEEKIXE7CgBBCCJHLSRgQQgghcjkJA0IIIUQuJ2FACCGEyOUkDAghhBC5nIQBIYQQIpeTMCCEEELkchIGhBBCiFxOwoAQQgiRy0kYEEIIIXI5CQNCCCFELidhQAghhMjlJAwIIYQQuZyEASGEECKXkzAghBBC5HISBoQQQohcTsKAEEIIkctJGBBCCCFyOQkDQgghRC4nYUAIIYTI5SQMCCGEELmchAEhhBAil5MwIIQQQuRyEgaEEEKIXO7/KM4PVDeRJcEAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1155,7 +1260,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1193,7 +1298,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1244,15 +1349,82 @@ "Making Prediction on Testing Instance Index: 0\n", "PREDICTION REPORT ------------------------------------------------------------------\n", "Outcome Prediction: 0\n", - "Model Prediction Probabilities: {0: 1.0, 1: 0.0}\n", + "Model Prediction Probabilities: {np.int64(0): 1.0, np.int64(1): 0.0}\n", "Instance Covered by Model: Yes\n", "Number of Matching Rules: 1\n", "PREDICTION EXPLANATION -------------------------------------------------------------\n", "Supporting Rules: --------------------\n", - "8 rule copies assert that IF: (A_0 = 0) AND (A_1 = 0) AND (R_0 = 0) THEN: predict outcome '0' with 100.0% confidence based on 68 matching training instances (15.11% of training instances).\n", + "5 rule copies assert that IF: (A_0 = 0) AND (A_1 = 0) AND (R_0 = 0) THEN: predict outcome '0' with 100.0% confidence based on 68 matching training instances (15.11% of training instances).\n", "Contradictory Rules: -----------------\n", "No contradictory rules matched.\n" ] + }, + { + "data": { + "text/plain": [ + "{'outcome_prediction': np.int64(0),\n", + " 'prediction_probabilities': {np.int64(0): 1.0, np.int64(1): 0.0},\n", + " 'covered': True,\n", + " 'num_matching_rules': 1,\n", + " 'whole_rule_population': False,\n", + " 'target_model_index': 0,\n", + " 'selection_reason': None,\n", + " 'algorithm': {'outcome_type': 'class',\n", + " 'classes': [np.int64(1), np.int64(0)],\n", + " 'voting_scheme': 'top_model_rule_set',\n", + " 'numerosity_sum': 5.0,\n", + " 'tie_breaking': {'majority_class': False, 'random': False}},\n", + " 'features': [{'feature_index': 0,\n", + " 'feature_name': 'A_0',\n", + " 'value': np.int64(0)},\n", + " {'feature_index': 1, 'feature_name': 'A_1', 'value': np.int64(0)},\n", + " {'feature_index': 2, 'feature_name': 'R_0', 'value': np.int64(0)},\n", + " {'feature_index': 3, 'feature_name': 'R_1', 'value': np.int64(1)},\n", + " {'feature_index': 4, 'feature_name': 'R_2', 'value': np.int64(0)},\n", + " {'feature_index': 5, 'feature_name': 'R_3', 'value': np.int64(0)}],\n", + " 'supporting_rules': [{'rule_id': 2,\n", + " 'action': np.int64(0),\n", + " 'instance_outcome_proportions': {np.int64(1): 0.0, np.int64(0): 1.0},\n", + " 'numerosity': 5,\n", + " 'fitness': 1.0,\n", + " 'accuracy': 1.0,\n", + " 'match_cover': 68,\n", + " 'correct_cover': 68,\n", + " 'average_match_set_size': 93.12710349360862,\n", + " 'deletion_probability': 0.004922776942145527,\n", + " 'birth_iteration': 0,\n", + " 'conditions': [{'feature_index': 0,\n", + " 'feature_name': 'A_0',\n", + " 'type': 'categorical',\n", + " 'operator': '=',\n", + " 'value': 0,\n", + " 'human_readable': 'A_0 = 0'},\n", + " {'feature_index': 1,\n", + " 'feature_name': 'A_1',\n", + " 'type': 'categorical',\n", + " 'operator': '=',\n", + " 'value': 0,\n", + " 'human_readable': 'A_1 = 0'},\n", + " {'feature_index': 2,\n", + " 'feature_name': 'R_0',\n", + " 'type': 'categorical',\n", + " 'operator': '=',\n", + " 'value': 0,\n", + " 'human_readable': 'R_0 = 0'}],\n", + " 'vote_contribution': {np.int64(1): 0.0, np.int64(0): 5.0},\n", + " 'selected_action_matches_prediction': True}],\n", + " 'contradictory_rules': [],\n", + " 'per_rule_contributions': [{'rule_id': 2,\n", + " 'numerosity': 5,\n", + " 'action': np.int64(0),\n", + " 'vote_contribution': {np.int64(1): 0.0, np.int64(0): 5.0}}],\n", + " 'match_set_rule_ids': [2],\n", + " 'narrative': \"Instance is covered by 1 rule(s); 1 support the predicted class '0' and 0 contradict. Prediction made via top_model_rule_set.\"}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -1283,7 +1455,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1316,7 +1488,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1353,7 +1525,13 @@ "rule_pop_df.to_csv(output_path+'/rule_pop.csv', index=False)\n", "# Save Model Population as .csv\n", "model_pop_df = heros.get_model_pop()\n", - "model_pop_df.to_csv(output_path+'/model_pop.csv', index=False)" + "model_pop_df.to_csv(output_path+'/model_pop.csv', index=False)\n", + "# Save Tree-Initialized Rule Population as .csv\n", + "if rule_pop_init == 'dt' or rule_pop_init == 'dt_bstrap':\n", + " heros.rule_population.change_rule_pop(0) #Change rule population to tree-initialized rule population (if applicable) for export\n", + " tree_init_rule_pop_df = heros.get_pop()\n", + " heros.rule_population.restore_rule_pop() #Return to original rule population after export\n", + " tree_init_rule_pop_df.to_csv(output_path+'/rule_pop_tree_init_only.csv', index=False)" ] }, { @@ -1374,7 +1552,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1388,7 +1566,7 @@ "rule_tracking_df = heros.get_performance_tracking()\n", "rule_tracking_df.to_csv(output_path+'/rule_pop_tracking.csv', index=False)\n", "# Plot Rule Learning Tracking\n", - "heros.get_rule_tracking_plot(show=True,save=True,output_path=output_path)" + "heros.get_rule_tracking_plot(show=True,save=True,output_path=output_path)\n" ] }, { @@ -1407,7 +1585,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1484,17 +1662,17 @@ "name": "stdout", "output_type": "stream", "text": [ - " Global Phase 1 Phase 2 Rule Initialization Rule Covering \\\n", - "0 112.969556 55.13536 57.620265 0.002 0.010007 \n", + " Global Phase 1 Phase 2 Rule Initialization Rule Covering \\\n", + "0 72.893525 179.742275 38.109141 0.30137 0.00489 \n", "\n", " Rule Equality Rule Matching Rule Evaluation Feature Tracking \\\n", - "0 2.651981 4.242108 50.264746 0.0 \n", + "0 1.910461 3.157734 30.833623 0.0 \n", "\n", " Rule Subsumption Rule Selection Rule Mating Rule Deletion \\\n", - "0 0.779568 1.609595 10.405899 7.52196 \n", + "0 0.544725 1.167442 4.690816 5.287506 \n", "\n", " Rule Compaction Rule Prediction \n", - "0 0.007518 1.430173 \n" + "0 0.030122 0.800956 \n" ] } ], @@ -1531,7 +1709,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1561,7 +1739,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1595,7 +1773,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1636,12 +1814,12 @@ "HEROS Whole Rule Population Testing Data Performance Report:\n", " precision recall f1-score support\n", "\n", - " 0 0.92000000 0.85185185 0.88461538 27\n", - " 1 0.84000000 0.91304348 0.87500000 23\n", + " 0 0.92000000 0.82142857 0.86792453 28\n", + " 1 0.80000000 0.90909091 0.85106383 22\n", "\n", - " accuracy 0.88000000 50\n", - " macro avg 0.88000000 0.88244767 0.87980769 50\n", - "weighted avg 0.88320000 0.88000000 0.88019231 50\n", + " accuracy 0.86000000 50\n", + " macro avg 0.86000000 0.86525974 0.85949418 50\n", + "weighted avg 0.86720000 0.86000000 0.86050582 50\n", "\n" ] } @@ -1674,44 +1852,44 @@ "output_type": "stream", "text": [ " Condition Indexes Condition Values Action Numerosity Fitness \\\n", - "0 [0, 1, 4] [1, 0, 0] 0 3 0.997857 \n", - "1 [0, 1, 5] [1, 1, 1] 1 5 0.997429 \n", - "2 [0, 1, 2] [0, 0, 0] 0 8 1.000000 \n", - "3 [0, 1, 3] [0, 1, 1] 1 7 0.998143 \n", - "4 [0, 1, 2] [0, 0, 1] 1 3 0.998714 \n", - "5 [0, 1, 4] [1, 0, 1] 1 7 0.997857 \n", - "6 [0, 1, 3] [0, 1, 0] 0 7 0.997714 \n", - "7 [0, 1, 5] [1, 1, 0] 0 5 0.996857 \n", + "0 [0, 1, 2] [0, 0, 0] 0 5 1.000000 \n", + "1 [0, 1, 3] [0, 1, 1] 1 7 0.998143 \n", + "2 [0, 1, 5] [1, 1, 1] 1 7 0.997429 \n", + "3 [0, 1, 4] [1, 0, 0] 0 6 0.997857 \n", + "4 [0, 1, 2] [0, 0, 1] 1 6 0.998714 \n", + "5 [0, 1, 5] [1, 1, 0] 0 7 0.996857 \n", + "6 [0, 1, 4] [1, 0, 1] 1 6 0.997857 \n", + "7 [0, 1, 3] [0, 1, 0] 0 7 0.997714 \n", "\n", " Useful Accuracy Useful Coverage Accuracy Match Cover Correct Cover \\\n", - "0 1.0 27.5 1.0 55 55 \n", - "1 1.0 26.0 1.0 52 52 \n", - "2 1.0 34.0 1.0 68 68 \n", - "3 1.0 28.5 1.0 57 57 \n", + "0 1.0 34.0 1.0 68 68 \n", + "1 1.0 28.5 1.0 57 57 \n", + "2 1.0 26.0 1.0 52 52 \n", + "3 1.0 27.5 1.0 55 55 \n", "4 1.0 30.5 1.0 61 61 \n", - "5 1.0 27.5 1.0 55 55 \n", - "6 1.0 27.0 1.0 54 54 \n", - "7 1.0 24.0 1.0 48 48 \n", + "5 1.0 24.0 1.0 48 48 \n", + "6 1.0 27.5 1.0 55 55 \n", + "7 1.0 27.0 1.0 54 54 \n", "\n", " Mean Absolute Error Prediction Outcome Range Probability Birth Iteration \\\n", - "0 None None None 538 \n", - "1 None None None 938 \n", - "2 None None None 147 \n", - "3 None None None 459 \n", - "4 None None None 182 \n", - "5 None None None 248 \n", - "6 None None None 181 \n", - "7 None None None 477 \n", + "0 None None None 0 \n", + "1 None None None 0 \n", + "2 None None None 0 \n", + "3 None None None 0 \n", + "4 None None None 104 \n", + "5 None None None 0 \n", + "6 None None None 0 \n", + "7 None None None 0 \n", "\n", " Specified Count Average Match Set Size Deletion Probabiilty \n", - "0 3 87.337309 0.002396 \n", - "1 3 96.095497 0.007325 \n", - "2 3 99.853940 0.019436 \n", - "3 3 92.333984 0.013786 \n", - "4 3 99.660789 0.002731 \n", - "5 3 95.647239 0.014285 \n", - "6 3 100.720970 0.015045 \n", - "7 3 93.752155 0.007151 \n", + "0 3 93.127103 0.004923 \n", + "1 3 88.732769 0.010573 \n", + "2 3 86.089364 0.013973 \n", + "3 3 84.024844 0.010015 \n", + "4 3 94.375813 0.011239 \n", + "5 3 90.676391 0.014726 \n", + "6 3 83.373389 0.009937 \n", + "7 3 94.056982 0.015261 \n", "HEROS Top 'Default' Model Testing Data Performance Report:\n", " precision recall f1-score support\n", "\n", @@ -1756,48 +1934,48 @@ "output_type": "stream", "text": [ " Condition Indexes Condition Values Action Numerosity Fitness \\\n", - "0 [0, 1, 5] [1, 1, 1] 1 5 0.997429 \n", - "1 [0, 1, 2] [0, 0, 0] 0 8 1.000000 \n", - "2 [0, 1, 3] [0, 1, 0] 0 7 0.997714 \n", - "3 [0, 1, 4] [1, 0, 1] 1 7 0.997857 \n", - "4 [0, 1, 3] [0, 1, 1] 1 7 0.998143 \n", - "5 [0, 1, 2] [0, 0, 1] 1 3 0.998714 \n", - "6 [0, 4, 5] [1, 0, 0] 0 8 0.998000 \n", - "7 [0, 1, 5] [1, 1, 0] 0 5 0.996857 \n", - "8 [0, 1, 4] [1, 0, 0] 0 3 0.997857 \n", + "0 [0, 1, 2] [0, 0, 0] 0 5 1.000000 \n", + "1 [0, 1, 3] [0, 1, 1] 1 7 0.998143 \n", + "2 [0, 1, 5] [1, 1, 1] 1 7 0.997429 \n", + "3 [0, 1, 3] [0, 1, 0] 0 7 0.997714 \n", + "4 [0, 1, 2] [0, 0, 1] 1 6 0.998714 \n", + "5 [1, 3, 5] [1, 0, 0] 0 5 0.996714 \n", + "6 [0, 1, 4] [1, 0, 1] 1 6 0.997857 \n", + "7 [0, 1, 5] [1, 1, 0] 0 7 0.996857 \n", + "8 [0, 1, 4] [1, 0, 0] 0 6 0.997857 \n", "\n", " Useful Accuracy Useful Coverage Accuracy Match Cover Correct Cover \\\n", - "0 1.0 26.0 1.0 52 52 \n", - "1 1.0 34.0 1.0 68 68 \n", - "2 1.0 27.0 1.0 54 54 \n", - "3 1.0 27.5 1.0 55 55 \n", - "4 1.0 28.5 1.0 57 57 \n", - "5 1.0 30.5 1.0 61 61 \n", - "6 1.0 28.0 1.0 56 56 \n", + "0 1.0 34.0 1.0 68 68 \n", + "1 1.0 28.5 1.0 57 57 \n", + "2 1.0 26.0 1.0 52 52 \n", + "3 1.0 27.0 1.0 54 54 \n", + "4 1.0 30.5 1.0 61 61 \n", + "5 1.0 23.5 1.0 47 47 \n", + "6 1.0 27.5 1.0 55 55 \n", "7 1.0 24.0 1.0 48 48 \n", "8 1.0 27.5 1.0 55 55 \n", "\n", " Mean Absolute Error Prediction Outcome Range Probability Birth Iteration \\\n", - "0 None None None 938 \n", - "1 None None None 147 \n", - "2 None None None 181 \n", - "3 None None None 248 \n", - "4 None None None 459 \n", - "5 None None None 182 \n", - "6 None None None 450 \n", - "7 None None None 477 \n", - "8 None None None 538 \n", + "0 None None None 0 \n", + "1 None None None 0 \n", + "2 None None None 0 \n", + "3 None None None 0 \n", + "4 None None None 104 \n", + "5 None None None 0 \n", + "6 None None None 0 \n", + "7 None None None 0 \n", + "8 None None None 0 \n", "\n", " Specified Count Average Match Set Size Deletion Probabiilty \n", - "0 3 96.095497 0.007325 \n", - "1 3 99.853940 0.019436 \n", - "2 3 100.720970 0.015045 \n", - "3 3 95.647239 0.014285 \n", - "4 3 92.333984 0.013786 \n", - "5 3 99.660789 0.002731 \n", - "6 3 98.934327 0.010854 \n", - "7 3 93.752155 0.007151 \n", - "8 3 87.337309 0.002396 \n", + "0 3 93.127103 0.004923 \n", + "1 3 88.732769 0.010573 \n", + "2 3 86.089364 0.013973 \n", + "3 3 94.056982 0.015261 \n", + "4 3 94.375813 0.011239 \n", + "5 3 96.028050 0.002865 \n", + "6 3 83.373389 0.009937 \n", + "7 3 90.676391 0.014726 \n", + "8 3 84.024844 0.010015 \n", "HEROS Top 'Default' Model Testing Data Performance Report:\n", " precision recall f1-score support\n", "\n", @@ -1843,40 +2021,40 @@ "output_type": "stream", "text": [ "Rule population evaluation at iteration 500\n", - "Run Time: 0.27213478088378906\n", + "Run Time: 0.6062235832214355\n", " precision recall f1-score support\n", "\n", - " 0 0.80000000 0.76923077 0.78431373 26\n", - " 1 0.76000000 0.79166667 0.77551020 24\n", + " 0 0.92000000 0.82142857 0.86792453 28\n", + " 1 0.80000000 0.90909091 0.85106383 22\n", "\n", - " accuracy 0.78000000 50\n", - " macro avg 0.78000000 0.78044872 0.77991196 50\n", - "weighted avg 0.78080000 0.78000000 0.78008804 50\n", + " accuracy 0.86000000 50\n", + " macro avg 0.86000000 0.86525974 0.85949418 50\n", + "weighted avg 0.86720000 0.86000000 0.86050582 50\n", "\n", "Rule population evaluation at iteration 1000\n", - "Run Time: 0.6061739921569824\n", + "Run Time: 0.9378507137298584\n", " precision recall f1-score support\n", "\n", - " 0 0.92000000 0.79310345 0.85185185 29\n", - " 1 0.76000000 0.90476190 0.82608696 21\n", + " 0 0.92000000 0.85185185 0.88461538 27\n", + " 1 0.84000000 0.91304348 0.87500000 23\n", "\n", - " accuracy 0.84000000 50\n", - " macro avg 0.84000000 0.84893268 0.83896940 50\n", - "weighted avg 0.85280000 0.84000000 0.84103060 50\n", + " accuracy 0.88000000 50\n", + " macro avg 0.88000000 0.88244767 0.87980769 50\n", + "weighted avg 0.88320000 0.88000000 0.88019231 50\n", "\n", "Rule population evaluation at iteration 5000\n", - "Run Time: 3.782489061355591\n", + "Run Time: 3.649895429611206\n", " precision recall f1-score support\n", "\n", - " 0 0.92000000 0.82142857 0.86792453 28\n", - " 1 0.80000000 0.90909091 0.85106383 22\n", + " 0 0.92000000 0.85185185 0.88461538 27\n", + " 1 0.84000000 0.91304348 0.87500000 23\n", "\n", - " accuracy 0.86000000 50\n", - " macro avg 0.86000000 0.86525974 0.85949418 50\n", - "weighted avg 0.86720000 0.86000000 0.86050582 50\n", + " accuracy 0.88000000 50\n", + " macro avg 0.88000000 0.88244767 0.87980769 50\n", + "weighted avg 0.88320000 0.88000000 0.88019231 50\n", "\n", "Rule population evaluation at iteration 10000\n", - "Run Time: 9.69053840637207\n", + "Run Time: 7.004157543182373\n", " precision recall f1-score support\n", "\n", " 0 0.92000000 0.82142857 0.86792453 28\n", @@ -1887,15 +2065,15 @@ "weighted avg 0.86720000 0.86000000 0.86050582 50\n", "\n", "Rule population evaluation at iteration 50000\n", - "Run Time: 55.10330867767334\n", + "Run Time: 65.36887764930725\n", " precision recall f1-score support\n", "\n", - " 0 0.92000000 0.85185185 0.88461538 27\n", - " 1 0.84000000 0.91304348 0.87500000 23\n", + " 0 0.92000000 0.82142857 0.86792453 28\n", + " 1 0.80000000 0.90909091 0.85106383 22\n", "\n", - " accuracy 0.88000000 50\n", - " macro avg 0.88000000 0.88244767 0.87980769 50\n", - "weighted avg 0.88320000 0.88000000 0.88019231 50\n", + " accuracy 0.86000000 50\n", + " macro avg 0.86000000 0.86525974 0.85949418 50\n", + "weighted avg 0.86720000 0.86000000 0.86050582 50\n", "\n" ] } @@ -1932,18 +2110,18 @@ "output_type": "stream", "text": [ "Top default model evaluation at iteration 10\n", - "Run Time: 6.591730117797852\n", + "Run Time: 4.270115375518799\n", " precision recall f1-score support\n", "\n", - " 0 1.00000000 1.00000000 1.00000000 25\n", - " 1 1.00000000 1.00000000 1.00000000 25\n", + " 0 0.96000000 1.00000000 0.97959184 24\n", + " 1 1.00000000 0.96153846 0.98039216 26\n", "\n", - " accuracy 1.00000000 50\n", - " macro avg 1.00000000 1.00000000 1.00000000 50\n", - "weighted avg 1.00000000 1.00000000 1.00000000 50\n", + " accuracy 0.98000000 50\n", + " macro avg 0.98000000 0.98076923 0.97999200 50\n", + "weighted avg 0.98080000 0.98000000 0.98000800 50\n", "\n", "Top default model evaluation at iteration 50\n", - "Run Time: 28.266413688659668\n", + "Run Time: 18.243428707122803\n", " precision recall f1-score support\n", "\n", " 0 1.00000000 1.00000000 1.00000000 25\n", @@ -1954,7 +2132,7 @@ "weighted avg 1.00000000 1.00000000 1.00000000 50\n", "\n", "Top default model evaluation at iteration 100\n", - "Run Time: 57.59666323661804\n", + "Run Time: 38.08714175224304\n", " precision recall f1-score support\n", "\n", " 0 1.00000000 1.00000000 1.00000000 25\n", @@ -1997,15 +2175,15 @@ "text": [ "---------------------------------------------------------------------------------------------\n", "Top model evaluation at iteration 10\n", - "Run Time: 6.591730117797852\n", - "11 non-dominated models on Pareto-front.\n", + "Run Time: 4.270115375518799\n", + "7 non-dominated models on Pareto-front.\n", "----------------------------------------\n", - "Model testing accuracies: [0.98, 0.8600000000000001, 0.8400000000000001, 0.8, 0.72, 0.8200000000000001, 0.78, 0.52, 0.5800000000000001, 0.45999999999999996, 0.56]\n", - "Model testing coverages: [0.96, 0.76, 0.84, 0.74, 0.88, 0.56, 0.54, 0.78, 0.56, 0.48, 0.36]\n", - "Model rule counts: [8, 7, 7, 6, 5, 4, 3, 3, 2, 1, 1]\n", + "Model testing accuracies: [0.98, 0.8999999999999999, 0.8200000000000001, 0.8200000000000001, 0.6200000000000001, 0.78, 0.6200000000000001]\n", + "Model testing coverages: [np.float64(1.0), np.float64(0.92), np.float64(0.64), np.float64(0.76), np.float64(0.62), np.float64(0.68), np.float64(0.44)]\n", + "Model rule counts: [8, 7, 6, 5, 4, 2, 1]\n", "----------------------------------------\n", "Best model testing accuracy: 0.98\n", - "Best model testing coverage: 0.96\n", + "Best model testing coverage: 1.0\n", "Best rule count: 8\n", "Best model index: 0\n", "----------------------------------------\n", @@ -2020,12 +2198,12 @@ "\n", "---------------------------------------------------------------------------------------------\n", "Top model evaluation at iteration 50\n", - "Run Time: 28.266413688659668\n", - "11 non-dominated models on Pareto-front.\n", + "Run Time: 18.243428707122803\n", + "7 non-dominated models on Pareto-front.\n", "----------------------------------------\n", - "Model testing accuracies: [1.0, 0.94, 0.9199999999999999, 0.6200000000000001, 0.62, 0.64, 0.6799999999999999, 0.6000000000000001, 0.6, 0.6599999999999999, 0.52]\n", - "Model testing coverages: [1.0, 0.88, 0.8, 1.0, 0.92, 0.92, 1.0, 0.82, 0.78, 0.54, 0.54]\n", - "Model rule counts: [8, 7, 7, 6, 5, 4, 3, 3, 2, 1, 1]\n", + "Model testing accuracies: [1.0, 0.88, 0.88, 0.8, 0.76, 0.78, 0.64]\n", + "Model testing coverages: [np.float64(1.0), np.float64(0.76), np.float64(0.78), np.float64(0.74), np.float64(0.9), np.float64(1.0), np.float64(0.58)]\n", + "Model rule counts: [8, 7, 6, 5, 4, 2, 1]\n", "----------------------------------------\n", "Best model testing accuracy: 1.0\n", "Best model testing coverage: 1.0\n", @@ -2043,12 +2221,12 @@ "\n", "---------------------------------------------------------------------------------------------\n", "Top model evaluation at iteration 100\n", - "Run Time: 57.59666323661804\n", - "11 non-dominated models on Pareto-front.\n", + "Run Time: 38.08714175224304\n", + "7 non-dominated models on Pareto-front.\n", "----------------------------------------\n", - "Model testing accuracies: [1.0, 0.96, 0.96, 0.88, 0.76, 0.6200000000000001, 0.5800000000000001, 0.5800000000000001, 0.6799999999999999, 0.44000000000000006, 0.5800000000000001]\n", - "Model testing coverages: [1.0, 0.98, 0.94, 0.88, 1.0, 1.0, 1.0, 1.0, 1.0, 0.48, 0.48]\n", - "Model rule counts: [8, 7, 7, 6, 5, 4, 3, 3, 2, 1, 1]\n", + "Model testing accuracies: [1.0, 0.98, 0.92, 0.78, 0.76, 0.76, 0.44000000000000006]\n", + "Model testing coverages: [np.float64(1.0), np.float64(0.94), np.float64(0.86), np.float64(0.74), np.float64(1.0), np.float64(1.0), np.float64(0.52)]\n", + "Model rule counts: [8, 7, 6, 5, 4, 2, 1]\n", "----------------------------------------\n", "Best model testing accuracy: 1.0\n", "Best model testing coverage: 1.0\n", @@ -2093,204 +2271,15 @@ "execution_count": 36, "id": "b0a873b6", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDCondition IndexesCondition ValuesActionNumerosityFitnessUseful AccuracyUseful CoverageAccuracyMatch CoverCorrect CoverMean Absolute ErrorPredictionOutcome Range ProbabilityBirth IterationSpecified CountAverage Match Set SizeDeletion Probabiilty
018[2][1]1210.9078270.29357832.00.646789218141NaNNaNNaN11194.7995370.025725
119[2][1]130.9078270.29357832.00.646789218141NaNNaNNaN11194.7995370.002858
23[2][0]0120.9076650.27586232.00.637931232148NaNNaNNaN1198.7451930.011911
320[4][1]1210.8366790.26696829.50.633484221140NaNNaNNaN15195.3441640.012477
414[4][0]0120.8366000.25764229.50.628821229144NaNNaNNaN8197.2720160.022632
\n", - "
" - ], - "text/plain": [ - " ID Condition Indexes Condition Values Action Numerosity Fitness \\\n", - "0 18 [2] [1] 1 21 0.907827 \n", - "1 19 [2] [1] 1 3 0.907827 \n", - "2 3 [2] [0] 0 12 0.907665 \n", - "3 20 [4] [1] 1 21 0.836679 \n", - "4 14 [4] [0] 0 12 0.836600 \n", - "\n", - " Useful Accuracy Useful Coverage Accuracy Match Cover Correct Cover \\\n", - "0 0.293578 32.0 0.646789 218 141 \n", - "1 0.293578 32.0 0.646789 218 141 \n", - "2 0.275862 32.0 0.637931 232 148 \n", - "3 0.266968 29.5 0.633484 221 140 \n", - "4 0.257642 29.5 0.628821 229 144 \n", - "\n", - " Mean Absolute Error Prediction Outcome Range Probability \\\n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 NaN NaN NaN \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "\n", - " Birth Iteration Specified Count Average Match Set Size \\\n", - "0 11 1 94.799537 \n", - "1 11 1 94.799537 \n", - "2 1 1 98.745193 \n", - "3 15 1 95.344164 \n", - "4 8 1 97.272016 \n", - "\n", - " Deletion Probabiilty \n", - "0 0.025725 \n", - "1 0.002858 \n", - "2 0.011911 \n", - "3 0.012477 \n", - "4 0.022632 " - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# Load the previously trained rule population from the saved .cvs file as a dataframe\n", - "pop_df = pd.read_csv('output/A_multiplexer_6_bit_500_inst_CV_Train_1/rule_pop.csv')\n", - "pop_df.head()" + "# Load the previously trained rule population from the saved .csv file as a dataframe\n", + "pop_df = pd.read_csv('output/'+rule_pop_path)\n", + "pop_df.head()\n", + "\n", + "# For demonstration purposes, we will update the phase I and II iteration to smaller values for the reboot\n", + "iterations = 10000 # (Rule_I) Number of Phase I learning iterations (e.g. 50000)\n", + "model_iterations = 40 # (Model_I) Number of Phase II learning iterations (e.g. 100)" ] }, { @@ -2311,229 +2300,192 @@ "Feature Types: [1, 1, 1, 1, 1, 1]\n", "Missing Values: 0\n", "Quantiative Feature Range: [[inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf], [inf, -inf]]\n", - "Categorical Feature Values: [[1, 0], [0, 1], [1, 0], [0, 1], [1, 0], [1, 0]]\n", + "Categorical Feature Values: [[np.int64(1), np.int64(0)], [np.int64(0), np.int64(1)], [np.int64(1), np.int64(0)], [np.int64(0), np.int64(1)], [np.int64(1), np.int64(0)], [np.int64(1), np.int64(0)]]\n", "Average States: 2.0\n", "Rule Specificity Limit: 6\n", - "Classes: [1, 0]\n", - "Class Counts: {1: 225, 0: 225}\n", - "Class Weights: {1: 0.5, 0: 0.5}\n", + "Classes: [np.int64(1), np.int64(0)]\n", + "Class Counts: {np.int64(1): 225, np.int64(0): 225}\n", + "Class Weights: {np.int64(1): 0.5, np.int64(0): 0.5}\n", "Majority Class: 1\n", "Expert Knowledge Weights Used: True\n", "--------------------------------------------------------------------\n", "Initializing Rule Population via Loaded File!\n", - "Max Rule ID in Loaded Population: 19876\n", - "Loading Rule Population Complete: 90 unique rules and 500 total rules loaded.\n", + "Max Rule ID in Loaded Population: 22241\n", + "Loading Rule Population Complete: 91 unique rules and 500 total rules loaded.\n", "--------------------------------------------------------------------\n", - "Original Population Size: 138\n", - "Post-Cleaning Population Size: 138\n", - "13 rules subsumed with a specificity of 2\n", - "27 rules subsumed with a specificity of 3\n", - "6 rules subsumed with a specificity of 4\n", + "Original Population Size: 91\n", + "Post-Cleaning Population Size: 91\n", + "Post-Subsumption Compaction Population Size: 91\n", + "HEROS Evolution Beginning!\n", + "Archiving: 500\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 1000 0.9 208 500 0.665\n", + "Archiving: 1000\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 221\n", + "Post-Cleaning Population Size: 221\n", + "17 rules subsumed with a specificity of 2\n", + "60 rules subsumed with a specificity of 3\n", + "54 rules subsumed with a specificity of 4\n", + "2 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 88\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 2000 0.889 88 500 1.347\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:2000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 1 0.893 1.0 38 0.495\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 2 0.907 1.0 27 0.98\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 3 0.909 1.0 34 1.451\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 4 0.916 1.0 23 1.832\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 5 0.922 1.0 31 2.206\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 6 0.922 1.0 31 2.565\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 7 0.927 1.0 22 2.927\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 8 0.931 0.971 15 3.276\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.7877394216722057\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 3000 0.906 192 500 5.717\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 202\n", + "Post-Cleaning Population Size: 201\n", + "18 rules subsumed with a specificity of 2\n", + "53 rules subsumed with a specificity of 3\n", + "40 rules subsumed with a specificity of 4\n", + "1 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 89\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 4000 0.906 89 499 6.363\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:2000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 9 0.936 1.0 17 3.671\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 10 0.964 1.0 17 4.052\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 11 0.964 1.0 17 4.363\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 12 0.964 1.0 17 4.741\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 13 0.964 1.0 17 5.078\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 14 0.964 1.0 17 5.362\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 15 0.964 1.0 17 5.617\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 16 0.964 1.0 17 5.977\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.18578045670174903\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 5000 0.901 188 500 9.757\n", + "Archiving: 5000\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 213\n", + "Post-Cleaning Population Size: 213\n", + "17 rules subsumed with a specificity of 2\n", + "63 rules subsumed with a specificity of 3\n", + "43 rules subsumed with a specificity of 4\n", + "2 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 88\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 6000 0.911 88 500 10.542\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:2000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 17 0.964 1.0 17 6.321\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 18 0.964 1.0 17 6.709\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 19 0.964 1.0 17 7.077\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 20 0.964 1.0 17 7.405\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 21 0.964 1.0 17 7.813\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 22 0.964 1.0 17 8.279\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 23 0.964 1.0 17 8.553\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 24 0.964 1.0 17 8.84\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.08748387057121221\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 7000 0.894 209 500 14.109\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 223\n", + "Post-Cleaning Population Size: 223\n", + "17 rules subsumed with a specificity of 2\n", + "63 rules subsumed with a specificity of 3\n", + "52 rules subsumed with a specificity of 4\n", + "1 rules subsumed with a specificity of 5\n", + "Post-Subsumption Compaction Population Size: 90\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 8000 0.897 90 500 14.831\n", + "HEROS (Phase 1) run complete!\n", + "Number of Unique Rules Identified: 0\n", + "Number of Iterations Used:2000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 25 0.964 1.0 17 9.124\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 26 0.964 1.0 17 9.499\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 27 0.964 1.0 17 9.842\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 28 0.973 1.0 18 10.195\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 29 0.973 1.0 18 10.507\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 30 0.973 1.0 18 10.857\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 31 0.973 1.0 17 11.263\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 32 0.973 1.0 17 11.614\n", + "HEROS (Phase 2) run complete!\n", + "Random Seed Check - End: 0.8276400675077251\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 9000 0.893 207 500 18.279\n", + "--------------------------------------------------------------------\n", + "Original Population Size: 223\n", + "Post-Cleaning Population Size: 223\n", + "19 rules subsumed with a specificity of 2\n", + "60 rules subsumed with a specificity of 3\n", + "51 rules subsumed with a specificity of 4\n", + "1 rules subsumed with a specificity of 5\n", "Post-Subsumption Compaction Population Size: 92\n", + " Iteration Pred.Acc.Est. Unique Rule Count Rule Pop Size Total Time\n", + " 10000 0.899 92 500 18.985\n", + "Archiving: 10000\n", "HEROS (Phase 1) run complete!\n", "Number of Unique Rules Identified: 0\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 1 0.882 0.882 10 1.562\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 2 0.887 1.0 47 2.293\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 3 0.887 1.0 47 3.072\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 4 0.898 1.0 39 3.749\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 5 0.922 1.0 17 4.469\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 6 0.922 1.0 17 5.142\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 7 0.962 1.0 33 5.717\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 8 0.962 1.0 33 6.286\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 9 0.962 1.0 33 6.887\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 10 0.962 1.0 33 7.425\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 11 0.962 1.0 33 8.019\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 12 0.984 1.0 15 8.609\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 13 0.991 1.0 18 9.178\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 14 1.0 1.0 13 9.71\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 15 1.0 1.0 13 10.31\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 16 1.0 1.0 13 10.897\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 17 1.0 1.0 13 11.434\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 18 1.0 1.0 13 11.946\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 19 1.0 1.0 13 12.563\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 20 1.0 1.0 13 13.225\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 21 1.0 1.0 13 13.765\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 22 1.0 1.0 12 14.266\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 23 1.0 1.0 11 14.854\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 24 1.0 1.0 10 15.451\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 25 1.0 1.0 10 15.907\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 26 1.0 1.0 10 16.471\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 27 1.0 1.0 10 17.081\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 28 1.0 1.0 9 17.636\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 29 1.0 1.0 9 18.325\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 30 1.0 1.0 9 18.842\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 31 1.0 1.0 9 19.495\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 32 1.0 1.0 9 20.017\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 33 1.0 1.0 9 20.711\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 34 1.0 1.0 9 21.24\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 35 1.0 1.0 9 21.776\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 36 1.0 1.0 9 22.337\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 37 1.0 1.0 8 22.937\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 38 1.0 1.0 8 23.583\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 39 1.0 1.0 8 24.12\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 40 1.0 1.0 8 24.693\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 41 1.0 1.0 8 25.368\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 42 1.0 1.0 8 26.08\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 43 1.0 1.0 8 26.696\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 44 1.0 1.0 8 27.33\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 45 1.0 1.0 8 27.92\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 46 1.0 1.0 8 28.4\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 47 1.0 1.0 8 28.896\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 48 1.0 1.0 8 29.44\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 49 1.0 1.0 8 30.04\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 50 1.0 1.0 8 30.6\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 51 1.0 1.0 8 31.141\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 52 1.0 1.0 8 31.712\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 53 1.0 1.0 8 32.323\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 54 1.0 1.0 8 32.917\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 55 1.0 1.0 8 33.348\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 56 1.0 1.0 8 33.911\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 57 1.0 1.0 8 34.489\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 58 1.0 1.0 8 34.978\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 59 1.0 1.0 8 35.528\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 60 1.0 1.0 8 36.119\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 61 1.0 1.0 8 36.703\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 62 1.0 1.0 8 37.351\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 63 1.0 1.0 8 37.932\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 64 1.0 1.0 8 38.479\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 65 1.0 1.0 8 39.046\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 66 1.0 1.0 8 39.571\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 67 1.0 1.0 8 40.155\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 68 1.0 1.0 8 40.794\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 69 1.0 1.0 8 41.232\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 70 1.0 1.0 8 41.736\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 71 1.0 1.0 8 42.389\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 72 1.0 1.0 8 42.847\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 73 1.0 1.0 8 43.464\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 74 1.0 1.0 8 43.925\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 75 1.0 1.0 8 44.508\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 76 1.0 1.0 8 45.108\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 77 1.0 1.0 8 45.62\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 78 1.0 1.0 8 46.165\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 79 1.0 1.0 8 46.619\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 80 1.0 1.0 8 47.09\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 81 1.0 1.0 8 47.564\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 82 1.0 1.0 8 48.278\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 83 1.0 1.0 8 48.991\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 84 1.0 1.0 8 49.582\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 85 1.0 1.0 8 50.066\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 86 1.0 1.0 8 50.688\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 87 1.0 1.0 8 51.264\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 88 1.0 1.0 8 51.843\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 89 1.0 1.0 8 52.402\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 90 1.0 1.0 8 52.92\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 91 1.0 1.0 8 53.489\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 92 1.0 1.0 8 53.981\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 93 1.0 1.0 8 54.464\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 94 1.0 1.0 8 55.017\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 95 1.0 1.0 8 55.714\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 96 1.0 1.0 8 56.384\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 97 1.0 1.0 8 56.898\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 98 1.0 1.0 8 57.428\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 99 1.0 1.0 8 58.027\n", - " Iteration Training Accuracy Coverage Rules in Model Total Time\n", - "0 100 1.0 1.0 8 58.604\n", + "Number of Iterations Used:2000\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 33 0.973 1.0 17 11.99\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 34 0.973 1.0 17 12.356\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 35 0.973 1.0 17 12.682\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 36 0.978 1.0 12 13.081\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 37 0.978 1.0 12 13.461\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 38 0.978 1.0 12 13.806\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 39 1.0 1.0 11 14.252\n", + " Iteration Training Accuracy Coverage Rules in Model Total Time\n", + " 40 1.0 1.0 11 14.588\n", "HEROS (Phase 2) run complete!\n", - "Random Seed Check - End: 0.5884725585444689\n" + "Random Seed Check - End: 0.43306151147896965\n" ] } ], @@ -2541,12 +2493,13 @@ "rule_pop_init = 'load' # Change the rule population initialization run parameter to load (all other parameters kept the same)\n", "\n", "# Initialize HEROS algorithm with run parameters\n", - "heros = HEROS(outcome_type=outcome_type,iterations=iterations,pop_size=pop_size,cross_prob=cross_prob,mut_prob=mut_prob,nu=nu,beta=beta,theta_sel=theta_sel,\n", + "heros_reboot = HEROS(outcome_type=outcome_type,iterations=iterations,pop_size=pop_size,cross_prob=cross_prob,mut_prob=mut_prob,nu=nu,beta=beta,theta_sel=theta_sel,\n", " fitness_function=fitness_function,subsumption=subsumption,rsl=rsl,feat_track=feat_track, model_iterations=model_iterations,\n", " model_pop_size=model_pop_size,model_pop_init=model_pop_init,new_gen=new_gen,merge_prob=merge_prob,rule_pop_init=rule_pop_init,compaction=compaction,\n", - " track_performance=track_performance,model_tracking=model_tracking,stored_rule_iterations=stored_rule_iterations,stored_model_iterations=stored_model_iterations,random_state=random_state, verbose=verbose)\n", + " track_performance=track_performance,model_tracking=model_tracking,stored_rule_iterations=stored_rule_iterations,stored_model_iterations=stored_model_iterations,\n", + " random_state=random_state,verbose=verbose,alternate=alternate,alternate_mode=alternate_mode,feedback=feedback)\n", "\n", - "heros = heros.fit(X, y, row_id, cat_feat_indexes=cat_feat_indexes, pop_df=pop_df, ek=ek)" + "heros_reboot = heros_reboot.fit(X, y, row_id, cat_feat_indexes=cat_feat_indexes, pop_df=pop_df, ek=ek)" ] }, { @@ -2559,63 +2512,75 @@ "name": "stdout", "output_type": "stream", "text": [ - "8 non-dominated models on Pareto-front.\n", + "14 non-dominated models on Pareto-front.\n", "----------------------------------------\n", - "Model testing accuracies: [1.0, 0.96, 0.88, 0.76, 0.5800000000000001, 0.54, 0.54, 0.6]\n", - "Model testing coverages: [1.0, 0.94, 0.92, 1.0, 1.0, 1.0, 1.0, 0.52]\n", - "Model rule counts: [8, 7, 6, 5, 4, 2, 2, 1]\n", + "Model testing accuracies: [1.0, 1.0, 0.96, 0.9199999999999999, 0.88, 0.88, 0.78, 0.76, 0.76, 0.76, 0.76, 0.76, 0.74, 0.64]\n", + "Model testing coverages: [np.float64(1.0), np.float64(1.0), np.float64(0.96), np.float64(0.9), np.float64(0.98), np.float64(0.9), np.float64(0.92), np.float64(0.8), np.float64(0.74), np.float64(1.0), np.float64(1.0), np.float64(1.0), np.float64(0.72), np.float64(0.42)]\n", + "Model rule counts: [11, 11, 10, 9, 8, 6, 5, 5, 4, 3, 3, 3, 2, 1]\n", "----------------------------------------\n", "Best model testing accuracy: 1.0\n", "Best model testing coverage: 1.0\n", - "Best rule count: 8\n", + "Best rule count: 11\n", "Best model index: 0\n", "----------------------------------------\n", - " Condition Indexes Condition Values Action Numerosity Fitness \\\n", - "0 [0, 1, 2] [0, 0, 0] 0 9 1.000000 \n", - "1 [0, 1, 3] [0, 1, 1] 1 7 0.998143 \n", - "2 [0, 1, 2] [0, 0, 1] 1 5 0.998714 \n", - "3 [0, 1, 4] [1, 0, 1] 1 7 0.997857 \n", - "4 [0, 1, 4] [1, 0, 0] 0 4 0.997857 \n", - "5 [0, 1, 5] [1, 1, 0] 0 6 0.996857 \n", - "6 [0, 1, 5] [1, 1, 1] 1 5 0.997429 \n", - "7 [0, 1, 3] [0, 1, 0] 0 5 0.997714 \n", + " Condition Indexes Condition Values Action Numerosity Fitness \\\n", + "0 [1, 2, 4] [0, 1, 1] 1 13 0.998714 \n", + "1 [0, 1, 3] [0, 1, 0] 0 7 0.997714 \n", + "2 [0, 4, 5] [1, 0, 0] 0 9 0.998000 \n", + "3 [0, 1, 5] [1, 1, 1] 1 5 0.997429 \n", + "4 [0, 1, 3] [0, 1, 1] 1 1 0.998143 \n", + "5 [0, 1, 2] [0, 0, 0] 0 6 1.000000 \n", + "6 [0, 1, 5] [1, 1, 0] 0 3 0.996857 \n", + "7 [0, 1, 4] [1, 0, 0] 0 6 0.997857 \n", + "8 [0, 1, 2] [0, 0, 1] 1 4 0.998714 \n", + "9 [0, 2, 3] [0, 1, 1] 1 7 0.997143 \n", + "10 [0, 1, 4] [1, 0, 1] 1 10 0.997857 \n", "\n", - " Useful Accuracy Useful Coverage Accuracy Match Cover Correct Cover \\\n", - "0 1.0 34.0 1.0 68 68 \n", - "1 1.0 28.5 1.0 57 57 \n", - "2 1.0 30.5 1.0 61 61 \n", - "3 1.0 27.5 1.0 55 55 \n", - "4 1.0 27.5 1.0 55 55 \n", - "5 1.0 24.0 1.0 48 48 \n", - "6 1.0 26.0 1.0 52 52 \n", - "7 1.0 27.0 1.0 54 54 \n", + " Useful Accuracy Useful Coverage Accuracy Match Cover Correct Cover \\\n", + "0 1.0 30.5 1.0 61 61 \n", + "1 1.0 27.0 1.0 54 54 \n", + "2 1.0 28.0 1.0 56 56 \n", + "3 1.0 26.0 1.0 52 52 \n", + "4 1.0 28.5 1.0 57 57 \n", + "5 1.0 34.0 1.0 68 68 \n", + "6 1.0 24.0 1.0 48 48 \n", + "7 1.0 27.5 1.0 55 55 \n", + "8 1.0 30.5 1.0 61 61 \n", + "9 1.0 25.0 1.0 50 50 \n", + "10 1.0 27.5 1.0 55 55 \n", "\n", - " Mean Absolute Error Prediction Outcome Range Probability Birth Iteration \\\n", - "0 None None None 0 \n", - "1 None None None 0 \n", - "2 None None None 0 \n", - "3 None None None 0 \n", - "4 None None None 0 \n", - "5 None None None 0 \n", - "6 None None None 0 \n", - "7 None None None 0 \n", + " Mean Absolute Error Prediction Outcome Range Probability Birth Iteration \\\n", + "0 None None None 0 \n", + "1 None None None 0 \n", + "2 None None None 0 \n", + "3 None None None 0 \n", + "4 None None None 0 \n", + "5 None None None 0 \n", + "6 None None None 0 \n", + "7 None None None 0 \n", + "8 None None None 0 \n", + "9 None None None 0 \n", + "10 None None None 0 \n", "\n", - " Specified Count Average Match Set Size Deletion Probabiilty \n", - "0 3 121.211646 0.015134 \n", - "1 3 114.369612 0.008655 \n", - "2 3 116.904356 0.004511 \n", - "3 3 137.258037 0.010390 \n", - "4 3 132.024367 0.003263 \n", - "5 3 116.133317 0.006465 \n", - "6 3 117.204513 0.004528 \n", - "7 3 113.834673 0.004397 \n" + " Specified Count Average Match Set Size Deletion Probabiilty \n", + "0 3 109.048706 0.007553 \n", + "1 3 96.425541 0.013104 \n", + "2 3 98.333002 0.004362 \n", + "3 3 89.790339 0.006227 \n", + "4 3 87.333473 0.000272 \n", + "5 3 99.903499 0.009952 \n", + "6 3 88.093832 0.002201 \n", + "7 3 98.315752 0.009815 \n", + "8 3 93.700073 0.004154 \n", + "9 3 89.696024 0.003983 \n", + "10 3 101.273674 0.028083 \n" ] } ], "source": [ "# Get the best model (as before)\n", - "best_model_index = heros.auto_select_top_model(X_test,y_test,verbose=True)\n", - "set_df = heros.get_model_rules(best_model_index)\n", + "best_model_index = heros_reboot.auto_select_top_model(X_test,y_test,verbose=True)\n", + "set_df = heros_reboot.get_model_rules(best_model_index)\n", "print(set_df) #Print all rules of the top model" ] }, @@ -2644,7 +2609,7 @@ ], "source": [ "# Report performance results for the top model\n", - "predictions = heros.predict(X_test,whole_rule_pop=False, target_model=best_model_index)\n", + "predictions = heros_reboot.predict(X_test,whole_rule_pop=False, target_model=best_model_index)\n", "print(\"HEROS Top Model Testing Data Performance Report:\")\n", "print(classification_report(predictions, y_test, digits=8))" ] @@ -2657,17 +2622,17 @@ "outputs": [], "source": [ "# Save Rule Population as .csv\n", - "rule_pop_df = heros.get_pop()\n", + "rule_pop_df = heros_reboot.get_pop()\n", "rule_pop_df.to_csv(output_path+'/rule_pop_rebooted.csv', index=False)\n", "# Save Model Population as .csv\n", - "model_pop_df = heros.get_model_pop()\n", - "model_pop_df.to_csv(output_path+'/model_pop_rebooted.csv', index=False)" + "model_pop_df = heros_reboot.get_model_pop()\n", + "model_pop_df.to_csv(output_path+'/model_pop_rebooted.csv', index=False)\n" ] } ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": "heros_env", "language": "python", "name": "python3" }, @@ -2681,7 +2646,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.12.13" } }, "nbformat": 4, diff --git a/README.md b/README.md index e5c0095..57a3893 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,7 @@ To date, HEROS functionality has been validated on binary classification problem A schematic detailing how the HEROS algorithm works is given below: -![alttext](https://github.com/UrbsLab/heros/blob/main/images/HEROS_1.0_Paper_Schematic_white_back.png?raw=true) +![alttext](https://github.com/UrbsLab/heros/blob/main/images/HEROS_1.1_Paper_Schematic_New4.png?raw=true) *** @@ -188,6 +188,9 @@ The table below gives other HEROS hyperparameters that should generally be left | Hyperparameter | Description | Type/Options | Default Value | | -------------- | ----------- | ------------- | ------------- | +| *rule_pop_init* | Specifies rule population pre-initialization method | None, 'load','dt'| None | +| *alternate* | Number of phase alternations (i.e. Phase I to Phase II transitions) | int | 5 | +| *alternate_mode* | Phase alternation strategy | 'equal', None | 'equal' | | *beta* | Learning parameter - used in calculating average match set size (Phase I) | float | 0.2 | | *theta_sel* | The fraction of the correct set to be included in tournament selection (Phases I & II) | float | 0.5 | | *cross_prob* | The probability of applying crossover in rule discovery with the genetic algorithm (Phases I & II) | float | 0.8 | @@ -219,7 +222,7 @@ This last table gives hyperparameters that are 'in-development' and should be le | *outcome_type* | Defines the type of outcome in the dataset | 'class','quant' | 'class' | | *fitness_function* | Defines the Phase I fitness function used by HEROS. The 'accuracy' option should only be used for clean-signal problems. | 'accuracy','pareto' | 'pareto' | | *feat_track* | Feature tracking strategy applied | None, 'add','wh','end' | None | -| *rule_pop_init* | Specifies rule population pre-initialization method | None, 'load','dt'| None | +| *feedback* | Feedback strategy used between phases when alternation is applied | Bool | False | ### fit() Parameters In addition to the typical *X* and *y* parameters for HEROS's fit function users can utilize the following fit() parameters: @@ -262,13 +265,26 @@ Most recently, in 2024, we released [Survival-LCS](https://github.com/UrbsLab/su *** ## Citing HEROS -If you use HEROS in a scientific publication, cite the following paper: +If you use HEROS in a scientific publication, cite the following paper(s): Gabe Lipschutz-Villa, Harsh Bandhey, Ruonan Yin, Malek Kamoun, Ryan Urbanowicz. 2025. [Rule-based Machine Learning: Separating Rule and Rule-Set Pareto-Optimization for Interpretable Noise-Agnostic Modeling](https://dl.acm.org/doi/10.1145/3712256.3726461) GECCO '25: Proceedings of the Genetic and Evolutionary Computation Conference. 407-415. BibTeX entry: ```bibtex -Not yet available +@inproceedings{lipschutz2025rule, + title={Rule-based Machine Learning: Separating Rule and Rule-Set Pareto-Optimization for Interpretable Noise-Agnostic Modeling}, + author={Lipschutz-Villa, Gabriel and Bandhey, Harsh and Yin, Ruonan and Kamoun, Malek and Urbanowicz, Ryan}, + booktitle={Proceedings of the Genetic and Evolutionary Computation Conference}, + pages={407--415}, + year={2025} +} +``` + +Gabe Lipschutz-Villa, Harsh Bandhey, Khoi Dinh, Michael Heider, Malek Kamoun, Ryan Urbanowicz. 2026. [Phase-Alternation and Tree-Initialization to Facilitate Interpretable Rule-based Machine Learning](https://dl.acm.org/doi/10.1145/3712256.3726461) GECCO '26: Proceedings of the Genetic and Evolutionary Computation Conference.(In Press) + +BibTeX entry: +```bibtex +Not Yet Available ``` *** @@ -295,9 +311,11 @@ The study was supported by Cedars Sinai Medical Center and NIH grants R01 AI1730 ### Code Contributors * Ryan Urbanowicz - Developed algorithm concepts, implemented algorithm, led debugging and evaluation -* Gabriel Lipschutz-Villa - Prototyped implementation of Phase II, model initialization strategies, and phase alternation (in development) -* Harsh Bandhey - Prototyped implementation of random forest rule initialization (in development) -* Khoi Dinh - Prototyped implementation of model interpretation visualization +* Gabriel Lipschutz-Villa - Prototyped implementation of Phase II, model initialization strategies, and phase alternation +* Harsh Bandhey - Prototyped implementation of random forest rule initialization +* Akshita Islam - Further prototyped random forest rule initialization +* Khoi Dinh - Prototyped implementation of model interpretation visualization, and contributions to tree-initialization and LLM explanation translator * Ruonan Yin - Developed strategy for calculating distance from the rule-pareto front for Phase I rule fitness * Robert Zhang - Prototyped strategy for rule batch-learning (adapted for HEROS) + diff --git a/evaluation/.DS_Store b/evaluation/.DS_Store new file mode 100644 index 0000000..5b92f68 Binary files /dev/null and b/evaluation/.DS_Store differ diff --git a/evaluation/experiments/comparison_algs_scripts/README.md b/evaluation/experiments/comparison_algs_scripts/README.md new file mode 100644 index 0000000..f1fdb11 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/README.md @@ -0,0 +1,532 @@ +# Comparison Algorithms Setup & Execution Guide + +This directory contains scripts and configurations for running **BioHEL**, **BioHEL RPE**, and **RIPPER** algorithms on benchmark datasets for comparative evaluation against HEROS. + +## Overview + +This experimental pipeline enables: +- Cross-validation partitioned execution across multiple random seeds +- BioHEL training with optional RPE (Rule Post-processing Engine) extension +- RIPPER rule learning via the Wittgenstein Python package +- Automated result aggregation and statistical analysis +- HPC (High-Performance Computing) batch job submission and management +- Reproducible paper results with all commands documented in `run_commands.txt` + +## Algorithm Implementations + +### BioHEL (Bioinformatic Hierarchical Evolutionary Learning) + +**BioHEL** is an evolutionary algorithm-based learning classifier system optimized for bioinformatics applications but applicable to general classification tasks. + +#### Installation & Setup + +##### 1. Download BioHEL Source + +Visit: **https://ico2s.org/software/biohel.html** + +- Download the BioHEL source code package +- Extract the archive: + ```bash + tar -xzf biohel_source.tar.gz + cd biohel_source + ``` + +##### 2. Build C Binaries + +Follow the build instructions provided with BioHEL source (typically): + +```bash +# Check for build requirements (see INSTALL or README in source) +./configure +make +make install +``` + +**Common build dependencies** (adjust for your system): +```bash +# macOS +brew install gcc + +# Ubuntu/Debian +sudo apt-get install build-essential +``` + +After successful build, the `biohel` executable will be generated. + +##### 3. Install in Comparison Scripts Directory + +Once built, make the binary accessible to the comparison scripts: + +```bash +# Option A: Copy the binary to the comparison scripts directory +cp /path/to/built/biohel ./biohel + +# Option B: Create a symlink +ln -s /path/to/built/biohel ./biohel + +# Option C: Add binary location to your PATH +export PATH="/path/to/built:$PATH" +``` + +Verify installation: +```bash +./biohel --help +# or +which biohel +``` + +#### BioHEL Configuration + +Configuration is managed through `.conf` files. See `biohel_sample.conf` for an example with key parameters: + +- **Population parameters**: `pop size`, `prob crossover`, `prob individual mutation` +- **Fitness function**: MDL (Minimum Description Length) based +- **Hyperrectangle representation**: Used for rule generalization +- **GPU support**: CUDA configuration options available +- **Iterations & coverage**: Controlled via `iterations`, `coverage ratio` + +Modify configuration parameters in `.conf` files as needed for your experiments. + +### BioHEL RPE (Rule Post-processing Engine) + +BioHEL RPE provides post-training rule refinement and optimization. + +#### Installation & Setup + +##### 1. Download BioHEL RPE Source + +Visit: **http://ico2s.org/software/biohel-rpe.html** + +- Download the BioHEL RPE source code package +- Extract the archive: + ```bash + tar -xzf biohel_rpe_source.tar.gz + cd biohel_rpe_source + ``` + +##### 2. Build RPE Binary + +Follow the build instructions provided with BioHEL RPE source: + +```bash +./configure +make +make install +``` + +##### 3. Install in Comparison Scripts Directory + +Make the `postprocess` executable accessible: + +```bash +# Option A: Copy the binary +cp /path/to/built/postprocess ./postprocess + +# Option B: Create a symlink +ln -s /path/to/built/postprocess ./postprocess + +# Option C: Add to PATH +export PATH="/path/to/built:$PATH" +``` + +Verify installation: +```bash +./postprocess --help +# or +which postprocess +``` + +#### Using BioHEL RPE + +Enable RPE post-processing in job scripts with the `--enable_rpe` flag: + +```bash +python job_biohel_hpc.py \ + --d \ + --o \ + --enable_rpe +``` + +RPE refines discovered rules for improved interpretability and performance. Configuration is managed through `postprocess.conf`. + +### RIPPER (Repeated Incremental Pruning to Produce Error Reduction) + +**RIPPER** is a classic rule-learning algorithm implemented via the **Wittgenstein** Python package. + +#### Installation + +Install the Wittgenstein package using pip: + +```bash +pip install wittgenstein +``` + +Verify installation: +```bash +python -c "import wittgenstein; print(wittgenstein.__version__)" +``` + +This provides a Python interface to RIPPER, enabling rule-based classification with minimal overhead and cross-platform compatibility. + +#### RIPPER Configuration + +RIPPER is configured through command-line arguments in job scripts: +- `--verbosity`: Control output verbosity (0 = minimal, higher = verbose) +- Dataset labels: outcome label, instance ID, excluded columns +- Random seed management for reproducibility + +No additional binary installation required—Wittgenstein handles all RIPPER functionality in Python. + +## Directory Structure + +``` +comparison_algs_scripts/ +├── README.md # This file +├── run_commands.txt # All commands needed to reproduce paper results +├── biohel_sample.conf # Example BioHEL configuration file +├── postprocess.conf # BioHEL RPE configuration +│ +├── Executables (must be built and placed here): +├── biohel # BioHEL binary (built from source) +├── postprocess # BioHEL RPE binary (built from source) +│ +├── Job submission scripts (HPC LSF): +├── job_biohel_hpc.py # Single BioHEL job (single dataset fold) +├── job_ripper_hpc.py # Single RIPPER job (single dataset fold) +├── job_biohel_sum_hpc.py # BioHEL aggregation job +├── job_ripper_sum_hpc.py # RIPPER aggregation job +├── job_sum_table_hpc.py # Final results table generation +│ +├── Runner scripts (generate & submit batch jobs): +├── run_biohel_hpc.py # Submit BioHEL jobs across CV folds & seeds +├── run_ripper_hpc.py # Submit RIPPER jobs across CV folds & seeds +├── run_biohel_sum_hpc.py # Submit BioHEL summary job +├── run_ripper_sum_hpc.py # Submit RIPPER summary job +│ +├── Utilities: +├── cleanup_hpc_artifacts.py # Remove scratch files and logs +├── check_failed_jobs.py # Monitor job completion status +│ +└── stats_scripts/ # Statistical comparison scripts + ├── combine_heros_for_stats.py # Aggregate HEROS results + └── job_statistical_test.py # Wilcoxon signed-rank tests +``` + +## Prerequisites + +Before running experiments, ensure all of the following are installed and configured: + +### 1. Python Environment +- **Python 3.7+** installed +- Required Python package: + ```bash + pip install wittgenstein + ``` + +### 2. BioHEL Binary +- Build from source: https://ico2s.org/software/biohel.html +- Place executable as `./biohel` or add to PATH +- Verify with: `./biohel --help` + +### 3. BioHEL RPE Binary (Optional, for RPE post-processing) +- Build from source: http://ico2s.org/software/biohel-rpe.html +- Place executable as `./postprocess` or add to PATH +- Verify with: `./postprocess --help` + +### 4. Data Preparation +- Input data should be in tab-separated format (`.txt`) +- Cross-validation partitions should be created first using the CV partitioning script +- Dataset must have: outcome/class column, instance ID column, optionally excluded columns + +### 5. HPC System Access (if running on cluster) +- LSF (Load Sharing Facility) or compatible job scheduler +- Access to shared storage for data and output + +## Workflow: From Data to Results + +### Step 1: Run BioHEL Training + +#### Option A: Single Debug Run (Local, No HPC) + +For testing on a single fold without HPC submission: + +```bash +python job_biohel_hpc.py \ + --d \ + --o \ + --ol \ + --il \ + --el \ + --rs \ + --enable_rpe \ + --v +``` + +#### Option B: Full Batch Submission (HPC/LSF) + +Submit BioHEL jobs across all CV folds and random seeds: + +```bash +python run_biohel_hpc.py \ + --d \ + --w \ + --o \ + --ol \ + --il \ + --el \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --enable_rpe +``` + +**Parameters**: +- `--d`: CV data directory or single training file +- `--w`: Output workspace root +- `--o`: Output subdirectory name +- `--ol`: Column name of outcome/class label +- `--il`: Column name of instance IDs +- `--el`: Excluded column name (e.g., experimental group identifier) +- `--rc`: Resource controller (LSF for HPC) +- `--rm`: Memory request (GB) +- `--q`: HPC queue name +- `--cv`: Number of CV folds +- `--r`: Number of random seeds/replicates +- `--enable_rpe`: Enable BioHEL RPE post-processing + +### Step 3: Run RIPPER Training + +#### Option A: Single Debug Run (Local, No HPC) + +For testing on a single fold without HPC submission: + +```bash +python job_ripper_hpc.py \ + --d \ + --o \ + --ol \ + --il \ + --el \ + --rs \ + --verbosity 0 \ + --v +``` + +#### Option B: Full Batch Submission (HPC/LSF) + +Submit RIPPER jobs across all CV folds and random seeds: + +```bash +python run_ripper_hpc.py \ + --d \ + --w \ + --o \ + --ol \ + --il \ + --el \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --verbosity 0 +``` + +**Parameters**: Same as BioHEL except: +- `--verbosity`: Output verbosity level (0 = minimal, 1+ = verbose) +- No `--enable_rpe` option (RIPPER doesn't use post-processing) + +### Step 4: Aggregate Results + +Once individual training jobs complete, aggregate results across all folds and seeds. + +#### Aggregate BioHEL Results + +```bash +python run_biohel_sum_hpc.py \ + --w \ + --o \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 +``` + +#### Aggregate RIPPER Results + +```bash +python run_ripper_sum_hpc.py \ + --w \ + --o \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --plots +``` + +### Step 5: Generate Paper Results Tables + +Generate comparative performance tables comparing all algorithms: + +```bash +python job_sum_table_hpc.py \ + --biohel_root \ + --ripper_root \ + --out +``` + +### Step 6: Statistical Analysis (Optional) + +Compare HEROS baseline against BioHEL and RIPPER using Wilcoxon signed-rank tests: + +```bash +# Combine HEROS results +python stats_scripts/combine_heros_for_stats.py \ + --root \ + --outdir \ + --outname combined_heros_cv_default_runs_long.csv + +# Run statistical tests +python stats_scripts/job_statistical_test.py \ + --heros_csv \ + --other_csv \ + --outdir \ + --prefix heros_baseline_wilcoxon \ + --alpha 0.05 +``` + +## Reproducing Paper Results + +### Quick Reference: Complete Experiment Workflow + +```bash +# 1. Create CV folds (prerequisite, shared across all algorithms) +python ../cv_partitioning/run_CV_Partitioner.py ... + +# 2. Submit BioHEL training jobs +python run_biohel_hpc.py ... + +# 3. Submit RIPPER training jobs +python run_ripper_hpc.py ... + +# 4. Wait for all jobs to complete +python check_failed_jobs.py + +# 5. Aggregate results +python run_biohel_sum_hpc.py ... +python run_ripper_sum_hpc.py ... + +# 6. Generate paper tables +python job_sum_table_hpc.py ... + +# 7. Optional: Statistical significance testing +python stats_scripts/job_statistical_test.py ... + +# 8. Optional: Cleanup scratch files +python cleanup_hpc_artifacts.py --w --yes +``` + +### All Experiment Commands + +**All commands needed to reproduce the exact paper results are documented in `run_commands.txt`.** + +This file contains the complete, tested pipeline including: +- CV fold creation commands with exact dataset paths +- BioHEL debug runs and full training pipelines (multiplexer and GAMETES datasets) +- RIPPER debug runs and full training pipelines +- Result aggregation steps +- Paper table generation +- Statistical significance testing +- Optional cleanup commands + +**Always reference `run_commands.txt` for the authoritative commands used in the paper.** + +## Monitoring and Troubleshooting + +### Check Job Status + +```bash +# List all current jobs +bjobs + +# Check specific queue +bqueues + +# List failed jobs +python check_failed_jobs.py +``` + +### BioHEL Binary Not Found + +```bash +# Verify BioHEL was built successfully +./biohel --help + +# Check if binary is in PATH +which biohel + +# If not found, build from source and create symlink or copy to this directory +ln -s /path/to/built/biohel ./biohel +``` + +### RIPPER/Wittgenstein Import Errors + +```bash +# Reinstall or upgrade Wittgenstein +pip install --upgrade wittgenstein + +# Verify installation +python -c "import wittgenstein; print('OK')" +``` + +### BioHEL RPE Errors (Optional) + +If using `--enable_rpe`: + +```bash +# Verify postprocess binary exists and is executable +./postprocess --help + +# Check postprocess.conf for correct configuration +cat postprocess.conf +``` + +### HPC Job Failures + +- Check job logs in the output directory +- Verify memory and time requirements match queue limits +- Ensure dataset labels (`--ol`, `--il`, `--el`) are consistent across runs +- Use `check_failed_jobs.py` to identify which folds/seeds failed +- Check shared storage accessibility and permissions + +### CV Fold Mismatch + +- Ensure CV folds are created with matching parameters across algorithms +- Verify dataset labels are consistent between CV partitioning and training +- Check file paths in `run_commands.txt` match your environment + +Statistical analysis uses Wilcoxon signed-rank tests for paired comparisons. + +## References + +- **BioHEL**: https://ico2s.org/software/biohel.html +- **BioHEL RPE**: http://ico2s.org/software/biohel-rpe.html +- **Wittgenstein (RIPPER Python package)**: https://github.com/imoscovitz/wittgenstein +- **RIPPER Original Paper**: Cohen, W.W. (1995). Fast Effective Rule Induction. In *Proceedings of the 12th International Conference on Machine Learning (ICML)* + +For HEROS training, see parent `../` directory for HEROS-specific runners. + +## Contact & Support + +For issues with: +- **BioHEL**: See https://ico2s.org/software/biohel.html +- **BioHEL RPE**: See http://ico2s.org/software/biohel-rpe.html +- **RIPPER/Wittgenstein**: See https://github.com/imoscovitz/wittgenstein +- **This pipeline**: Check `run_commands.txt` for exact commands and refer to script documentation + +--- diff --git a/evaluation/experiments/comparison_algs_scripts/biohel b/evaluation/experiments/comparison_algs_scripts/biohel new file mode 100755 index 0000000..0a8f9fd Binary files /dev/null and b/evaluation/experiments/comparison_algs_scripts/biohel differ diff --git a/evaluation/experiments/comparison_algs_scripts/biohel_sample.conf b/evaluation/experiments/comparison_algs_scripts/biohel_sample.conf new file mode 100644 index 0000000..a0a99c9 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/biohel_sample.conf @@ -0,0 +1,36 @@ +crossover operator 1px +default class major +fitness function mdl +initialization min classifiers 20 +initialization max classifiers 20 +iterations 50 +mdl initial tl ratio 0.25 +mdl iteration 10 +mdl weight relax factor 0.90 +pop size 500 +prob crossover 0.6 +prob individual mutation 0.6 +prob one 0.75 +selection algorithm tournamentwor +tournament size 4 +windowing ilas 1 +dump evolution stats +smart init +class wise init +coverage breakpoint 0.01 +repetitions of rule learning 2 +coverage ratio 0.90 + +kr hyperrect +num expressed attributes init 15 +hyperrectangle uses list of attributes +prob generalize list 0.10 +prob specialize list 0.10 + +expected number of attributes 10 + +device selected 0 +device memory used 1.0 +cuda enabled + +random seed 0 \ No newline at end of file diff --git a/evaluation/experiments/comparison_algs_scripts/check_failed_jobs.py b/evaluation/experiments/comparison_algs_scripts/check_failed_jobs.py new file mode 100644 index 0000000..6a6dd11 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/check_failed_jobs.py @@ -0,0 +1,308 @@ +#!/usr/bin/env python3 +""" +check_failed_jobs.py + +Scan an HPC log folder for failed jobs by inspecting stdout/stderr log files. + +Typical layout: + logs/ + jobA.o + jobA.e + jobB.out + jobB.err + slurm-12345.out + +Heuristics: + - If stderr is non-empty and contains error keywords => failed + - If stdout/stderr contain fatal keywords => failed + - If stdout lacks any "success marker" (optional) but contains crash keywords => failed + - Detect common scheduler failure messages + +Outputs: + - Human-readable summary to stdout + - Optional JSON report for downstream tooling + +Usage: + python check_failed_jobs.py --log-dir /path/to/logs --json report.json + python check_failed_jobs.py --log-dir logs --pair-suffixes .o .e +""" + +from __future__ import annotations + +import argparse +import json +import os +import re +from dataclasses import dataclass, asdict +from pathlib import Path +from typing import Dict, List, Optional, Tuple + + +# --- Tune these to your environment --- +DEFAULT_ERROR_KEYWORDS = [ + # Python / general + r"Traceback \(most recent call last\):", + r"\bException\b", + r"\bERROR\b", + r"\bFATAL\b", + r"\bFatal\b", + r"\bSegmentation fault\b", + r"\bcore dumped\b", + r"\bout of memory\b", + r"\bOOM\b", + r"\bKilled\b", + r"\bkilled by signal\b", + r"\bCUDA error\b", + r"\bCUBLAS\b", + r"\bCUDNN\b", + r"\bnvcc\b.*error", + # LSF + r"\bExited with exit code\b", + r"\bTERM_(MEMLIMIT|RUNLIMIT|CPULIMIT)\b", + r"\bMEMLIMIT\b", + r"\bRun time exceeded\b", + r"\bJob killed\b", + # Slurm + r"\bslurmstepd:\b.*error", + r"\bCANCELLED\b", + r"\bOUT_OF_MEMORY\b", + r"\bTIMEOUT\b", + r"\bNODE_FAIL\b", + r"\bFAILED\b", + # PBS/Torque + r"\bPBS:\b.*Killed", + r"\bjob killed\b", +] + +DEFAULT_SUCCESS_MARKERS = [ + # Put something your jobs print on success (recommended) + r"\bTRAINING COMPLETE\b", + r"\bDONE\b", + r"\bCompleted successfully\b", +] + + +@dataclass +class LogFinding: + job_key: str + stdout_path: Optional[str] + stderr_path: Optional[str] + status: str # "failed" | "suspect" | "ok" + reasons: List[str] + + +def read_tail(path: Path, max_bytes: int = 200000) -> str: + """ + Read up to max_bytes from the end of a file (fast for big logs). + """ + try: + size = path.stat().st_size + with path.open("rb") as f: + if size > max_bytes: + f.seek(-max_bytes, os.SEEK_END) + data = f.read() + # decode with replacement to avoid crashes on binary junk + return data.decode("utf-8", errors="replace") + except FileNotFoundError: + return "" + except Exception as e: + return f"<>" + + +def compile_patterns(patterns: List[str]) -> List[re.Pattern]: + return [re.compile(p, flags=re.IGNORECASE | re.MULTILINE) for p in patterns] + + +def matches_any(text: str, pats: List[re.Pattern]) -> List[str]: + hits = [] + for p in pats: + if p.search(text): + hits.append(p.pattern) + return hits + + +def group_logs( + log_dir: Path, + pair_suffixes: Tuple[str, str], + extra_stdout_suffixes: Tuple[str, ...] = (".out", ".o", ".stdout"), + extra_stderr_suffixes: Tuple[str, ...] = (".err", ".e", ".stderr"), +) -> Dict[str, Dict[str, Path]]: + """ + Group logs by a "job_key" derived from filename minus suffix. + + Examples: + foo.o + foo.e => job_key="foo" + slurm-12345.out (no matching err) => job_key="slurm-12345" + """ + groups: Dict[str, Dict[str, Path]] = {} + + # Suffix sets for detection + stdout_sufs = set(extra_stdout_suffixes) + stderr_sufs = set(extra_stderr_suffixes) + + for p in log_dir.iterdir(): + if not p.is_file(): + continue + + suf = p.suffix + name = p.name + + # Handle double suffix like .o123? (rare) - skip complexity unless needed + if suf in stdout_sufs: + key = name[: -len(suf)] + groups.setdefault(key, {})["stdout"] = p + elif suf in stderr_sufs: + key = name[: -len(suf)] + groups.setdefault(key, {})["stderr"] = p + else: + # Also accept common scheduler default names like "slurm-12345.out" + # which already matches ".out" above; anything else ignored. + continue + + # If user gave explicit pair suffixes, ensure those are preferred when present + out_suf, err_suf = pair_suffixes + for p in log_dir.iterdir(): + if not p.is_file(): + continue + if p.name.endswith(out_suf): + key = p.name[: -len(out_suf)] + groups.setdefault(key, {})["stdout"] = p + if p.name.endswith(err_suf): + key = p.name[: -len(err_suf)] + groups.setdefault(key, {})["stderr"] = p + + return groups + + +def classify_job( + job_key: str, + stdout_path: Optional[Path], + stderr_path: Optional[Path], + error_pats: List[re.Pattern], + success_pats: List[re.Pattern], + max_bytes: int, + treat_nonempty_stderr_as_suspect: bool = True, +) -> LogFinding: + reasons: List[str] = [] + + stdout_txt = read_tail(stdout_path, max_bytes=max_bytes) if stdout_path else "" + stderr_txt = read_tail(stderr_path, max_bytes=max_bytes) if stderr_path else "" + + # Keyword hits + err_hits = matches_any(stdout_txt + "\n" + stderr_txt, error_pats) + if err_hits: + reasons.append(f"Matched error patterns: {', '.join(err_hits[:8])}" + (" ..." if len(err_hits) > 8 else "")) + + # Success markers (optional) + success_hits = matches_any(stdout_txt, success_pats) if success_pats else [] + has_success = bool(success_hits) + + # stderr non-empty heuristic + stderr_nonempty = bool(stderr_txt.strip()) if stderr_path else False + if stderr_nonempty and treat_nonempty_stderr_as_suspect: + # Avoid false positives from harmless warnings; keep it as "suspect" unless error keywords hit. + reasons.append("stderr is non-empty") + + # Determine status + if err_hits: + status = "failed" + elif stderr_nonempty and treat_nonempty_stderr_as_suspect and not has_success: + status = "suspect" + reasons.append("no success marker found in stdout") + else: + status = "ok" + if has_success: + reasons.append(f"Found success marker(s): {', '.join(success_hits[:5])}") + + return LogFinding( + job_key=job_key, + stdout_path=str(stdout_path) if stdout_path else None, + stderr_path=str(stderr_path) if stderr_path else None, + status=status, + reasons=reasons, + ) + + +def main() -> int: + ap = argparse.ArgumentParser(description="Scan HPC log directory for failed jobs.") + ap.add_argument("--log-dir", required=True, help="Folder containing job logs") + ap.add_argument("--pair-suffixes", nargs=2, default=[".o", ".e"], help="Preferred stdout/stderr suffixes (e.g. .out .err or .o .e)") + ap.add_argument("--max-bytes", type=int, default=200000, help="Read up to this many bytes from end of each log file") + ap.add_argument("--json", dest="json_path", default=None, help="Write JSON report to this path") + ap.add_argument("--success-marker", action="append", default=None, help="Regex for success marker in stdout (repeatable)") + ap.add_argument("--error-keyword", action="append", default=None, help="Regex for error keyword (repeatable)") + ap.add_argument("--strict-stderr", action="store_true", help="Treat any non-empty stderr as failed (instead of suspect)") + args = ap.parse_args() + + log_dir = Path(args.log_dir).expanduser().resolve() + if not log_dir.exists() or not log_dir.is_dir(): + raise SystemExit(f"Log dir does not exist or is not a directory: {log_dir}") + + error_patterns = args.error_keyword if args.error_keyword else DEFAULT_ERROR_KEYWORDS + success_patterns = args.success_marker if args.success_marker is not None else DEFAULT_SUCCESS_MARKERS + + error_pats = compile_patterns(error_patterns) + success_pats = compile_patterns(success_patterns) if success_patterns else [] + + groups = group_logs(log_dir, pair_suffixes=(args.pair_suffixes[0], args.pair_suffixes[1])) + + findings: List[LogFinding] = [] + for job_key, paths in sorted(groups.items()): + stdout_p = paths.get("stdout") + stderr_p = paths.get("stderr") + finding = classify_job( + job_key=job_key, + stdout_path=stdout_p, + stderr_path=stderr_p, + error_pats=error_pats, + success_pats=success_pats, + max_bytes=args.max_bytes, + treat_nonempty_stderr_as_suspect=not args.strict_stderr, + ) + findings.append(finding) + + failed = [f for f in findings if f.status == "failed"] + suspect = [f for f in findings if f.status == "suspect"] + ok = [f for f in findings if f.status == "ok"] + + print(f"Scanned: {log_dir}") + print(f"Jobs found: {len(findings)} | failed: {len(failed)} | suspect: {len(suspect)} | ok: {len(ok)}") + print() + + def print_block(title: str, items: List[LogFinding]) -> None: + if not items: + return + print(title) + print("-" * len(title)) + for f in items: + print(f"* {f.job_key}") + if f.stdout_path: + print(f" stdout: {f.stdout_path}") + if f.stderr_path: + print(f" stderr: {f.stderr_path}") + for r in f.reasons[:6]: + print(f" - {r}") + if len(f.reasons) > 6: + print(" - ...") + print() + + print_block("FAILED", failed) + print_block("SUSPECT (review)", suspect) + + if args.json_path: + out = { + "log_dir": str(log_dir), + "counts": {"total": len(findings), "failed": len(failed), "suspect": len(suspect), "ok": len(ok)}, + "findings": [asdict(f) for f in findings], + } + json_path = Path(args.json_path).expanduser().resolve() + json_path.parent.mkdir(parents=True, exist_ok=True) + json_path.write_text(json.dumps(out, indent=2)) + print(f"Wrote JSON report: {json_path}") + + # exit code for CI-style usage + return 2 if failed else (1 if suspect else 0) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/evaluation/experiments/comparison_algs_scripts/cleanup_hpc_artifacts.py b/evaluation/experiments/comparison_algs_scripts/cleanup_hpc_artifacts.py new file mode 100644 index 0000000..415cb96 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/cleanup_hpc_artifacts.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import os +from pathlib import Path +from typing import Iterable, List, Tuple + + +DEFAULT_LOG_GLOBS = [ + "*.o", "*.e", "*.out", "*.err", "*.log", + "slurm-*.out", "slurm-*.err", +] +DEFAULT_SCRATCH_GLOBS = [ + "*_run.sh", "*.sh", +] + + +def _collect_files(base: Path, subdir: str, globs: List[str]) -> List[Path]: + p = base / subdir + if not p.exists() or not p.is_dir(): + return [] + files: List[Path] = [] + for g in globs: + files.extend(sorted(p.glob(g))) + # de-dupe while preserving order + seen = set() + uniq = [] + for f in files: + if f not in seen and f.is_file(): + seen.add(f) + uniq.append(f) + return uniq + + +def _delete(files: Iterable[Path], dry_run: bool) -> Tuple[int, int]: + deleted = 0 + failed = 0 + for f in files: + try: + if dry_run: + print(f"[dry-run] rm {f}") + else: + f.unlink() + print(f"rm {f}") + deleted += 1 + except Exception as e: + failed += 1 + print(f"[WARN] failed to delete {f}: {e}") + return deleted, failed + + +def main(): + ap = argparse.ArgumentParser(description="Remove HPC scratch .sh scripts and log files under a writepath.") + ap.add_argument("--w", dest="writepath", type=str, required=True, + help="Writepath containing scratch/ and logs/ (e.g., /project/.../output_shared/ripper_gecco)") + ap.add_argument("--dry_run", action="store_true", help="Print what would be deleted without deleting.") + ap.add_argument("--yes", action="store_true", help="Do not prompt (non-interactive).") + + ap.add_argument("--no_logs", action="store_true", help="Skip deleting logs/") + ap.add_argument("--no_scratch", action="store_true", help="Skip deleting scratch/") + + args = ap.parse_args() + + writepath = Path(args.writepath).expanduser().resolve() + if not writepath.exists(): + raise FileNotFoundError(f"writepath not found: {writepath}") + + log_files = [] if args.no_logs else _collect_files(writepath, "logs", DEFAULT_LOG_GLOBS) + scratch_files = [] if args.no_scratch else _collect_files(writepath, "scratch", DEFAULT_SCRATCH_GLOBS) + + total = len(log_files) + len(scratch_files) + print(f"Target writepath: {writepath}") + print(f"Found {len(scratch_files)} scratch file(s) to delete in {writepath/'scratch'}") + print(f"Found {len(log_files)} log file(s) to delete in {writepath/'logs'}") + print(f"Total: {total}") + + if total == 0: + print("Nothing to delete.") + return 0 + + if not args.yes and not args.dry_run: + resp = input("Proceed with deletion? (y/N): ").strip().lower() + if resp not in ("y", "yes"): + print("Cancelled.") + return 0 + + d1, f1 = _delete(scratch_files, args.dry_run) + d2, f2 = _delete(log_files, args.dry_run) + + print(f"Deleted: {d1 + d2}, Failed: {f1 + f2}") + return 0 if (f1 + f2) == 0 else 2 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/evaluation/experiments/comparison_algs_scripts/job_biohel_hpc.py b/evaluation/experiments/comparison_algs_scripts/job_biohel_hpc.py new file mode 100644 index 0000000..06f0149 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/job_biohel_hpc.py @@ -0,0 +1,576 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import os +import sys +import re +import json +import time +import argparse +import subprocess +from dataclasses import dataclass +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +import numpy as np +import pandas as pd + + +# ----------------------------- +# ARFF + config +# ----------------------------- +def load_df(path: str) -> pd.DataFrame: + return pd.read_csv(path, sep="\t") + + +def build_feature_names(df: pd.DataFrame, outcome_label: str, instanceID_label: str, excluded_column: str) -> List[str]: + cols = list(df.columns) + for c in [excluded_column, instanceID_label]: + if c in cols: + cols.remove(c) + if outcome_label in cols: + cols.remove(outcome_label) + return cols + + +def infer_arff_schema(train_df: pd.DataFrame, feature_names: List[str], outcome_label: str) -> Tuple[Dict[str, List[int]], List[int]]: + """ + Infer ARFF nominal domains from TRAIN ONLY (prevents test peeking and guarantees consistent schema). + Returns: + feat_domains: dict feat -> sorted list of allowed int values + class_domain: sorted list of allowed int class values + """ + feat_domains: Dict[str, List[int]] = {} + for feat in feature_names: + vals = sorted(pd.Series(train_df[feat]).dropna().astype(int).unique().tolist()) + feat_domains[feat] = vals + + class_domain = sorted(pd.Series(train_df[outcome_label]).dropna().astype(int).unique().tolist()) + return feat_domains, class_domain + + +def write_arff_with_schema( + df: pd.DataFrame, + feature_names: List[str], + outcome_label: str, + filename: Path, + relation_name: str, + feat_domains: Dict[str, List[int]], + class_domain: List[int], + unknown_as_missing: bool = True, +) -> None: + """ + Write ARFF using a fixed schema (domains), typically inferred from TRAIN. + If unknown_as_missing=True, any value not in the domain is written as '?'. + """ + with open(filename, "w") as f: + f.write(f"@RELATION {relation_name}\n\n") + + for feat in feature_names: + dom = feat_domains[feat] + value_str = ",".join(map(str, dom)) + f.write(f"@ATTRIBUTE {feat} {{{value_str}}}\n") + + class_str = ",".join(map(str, class_domain)) + f.write(f"@ATTRIBUTE {outcome_label} {{{class_str}}}\n\n") + + f.write("@DATA\n") + for _, row in df.iterrows(): + vals_out: List[str] = [] + for feat in feature_names: + v = int(row[feat]) + if v in feat_domains[feat]: + vals_out.append(str(v)) + else: + if unknown_as_missing: + vals_out.append("?") + else: + raise ValueError(f"Value {v} for feature '{feat}' not in TRAIN domain {feat_domains[feat]}") + + y = int(row[outcome_label]) + if y in class_domain: + vals_out.append(str(y)) + else: + if unknown_as_missing: + vals_out.append("?") + else: + raise ValueError(f"Class value {y} not in TRAIN class domain {class_domain}") + + f.write(",".join(vals_out) + "\n") + + +# Wrong: this peeks at test data to infer schema, which is not allowed. +def convert_to_arff(df: pd.DataFrame, feature_names: List[str], outcome_label: str, filename: Path, relation_name: str) -> None: + with open(filename, "w") as f: + f.write(f"@RELATION {relation_name}\n\n") + + for feat in feature_names: + unique_values = sorted(df[feat].unique()) + value_str = ",".join(map(str, [int(v) for v in unique_values])) + f.write(f"@ATTRIBUTE {feat} {{{value_str}}}\n") + + class_values = sorted(df[outcome_label].unique()) + class_str = ",".join(map(str, [int(v) for v in class_values])) + f.write(f"@ATTRIBUTE {outcome_label} {{{class_str}}}\n\n") + + f.write("@DATA\n") + for _, row in df.iterrows(): + vals = [str(int(row[feat])) for feat in feature_names] + vals.append(str(int(row[outcome_label]))) + f.write(",".join(vals) + "\n") + + +def create_biohel_config(output_path: Path, seed: int) -> None: + config_content = f"""crossover operator 1px +default class major +fitness function mdl +initialization min classifiers 20 +initialization max classifiers 20 +iterations 1000 +mdl initial tl ratio 0.25 +mdl iteration 10 +mdl weight relax factor 0.90 +pop size 1000 +prob crossover 0.6 +prob individual mutation 0.6 +prob one 0.75 +selection algorithm tournamentwor +tournament size 5 +windowing ilas 1 +dump evolution stats +smart init +class wise init +coverage breakpoint 0.01 +repetitions of rule learning 2 +coverage ratio 0.90 +kr hyperrect +num expressed attributes init 15 +hyperrectangle uses list of attributes +prob generalize list 0.10 +prob specialize list 0.10 +expected number of attributes 10 +random seed {seed} +""" + output_path.write_text(config_content) + + +# ----------------------------- +# Rule parsing + application +# Supports: +# - BioHEL phenotype lines: "0:Att A_0 is 1|...|1" +# - RPE ruleset lines: "Att A_0 is 1|...|1" +# - Default rule: "Default rule -> 0" +# ----------------------------- +@dataclass(frozen=True) +class ParsedRule: + order: int + conditions: Dict[str, int] + prediction: int + is_default: bool = False + + +_COND_RE = re.compile(r"Att\s+([A-Za-z0-9_]+)\s+is\s+([-+]?\d+)") +_DEFAULT_RE = re.compile(r"^\s*(?:\d+:)?\s*Default rule\s*->\s*([-+]?\d+)\s*$", re.IGNORECASE) +_PREFIX_RE = re.compile(r"^\s*\d+\s*:\s*") + + +def parse_ruleset_lines(lines: List[str]) -> Tuple[List[ParsedRule], Optional[ParsedRule]]: + rules: List[ParsedRule] = [] + default_rule: Optional[ParsedRule] = None + + order = 0 + for raw in lines: + line = raw.strip() + if not line: + continue + + mdef = _DEFAULT_RE.match(line) + if mdef: + default_rule = ParsedRule(order=10**9, conditions={}, prediction=int(mdef.group(1)), is_default=True) + continue + + # strip "0:" prefix if present + line = _PREFIX_RE.sub("", line) + + parts = [p.strip() for p in line.split("|") if p.strip()] + if not parts: + continue + + try: + pred = int(parts[-1]) + except ValueError: + continue + + cond_text = "|".join(parts[:-1]) + conds: Dict[str, int] = {} + for feat, val in _COND_RE.findall(cond_text): + conds[feat] = int(val) + + rules.append(ParsedRule(order=order, conditions=conds, prediction=pred, is_default=False)) + order += 1 + + return rules, default_rule + + +def apply_ruleset_predict(df: pd.DataFrame, rules: List[ParsedRule], default_rule: Optional[ParsedRule], + excluded_columns: List[str]) -> Tuple[np.ndarray, np.ndarray]: + """ + Returns: + y_pred: predicted labels for ALL instances (default fills uncovered) + covered: boolean array True if covered by ANY non-default rule + """ + X = df.drop(columns=[c for c in excluded_columns if c in df.columns], errors="ignore") + n = len(X) + covered = np.zeros(n, dtype=bool) + + # initialize with default prediction + if default_rule is None: + # If absent, choose the most frequent class in the data if Class exists; else 0 + default_pred = int(df["Class"].mode().iloc[0]) if "Class" in df.columns and not df["Class"].mode().empty else 0 + else: + default_pred = default_rule.prediction + + y_pred = np.full(n, default_pred, dtype=int) + + # apply in order: first match wins (typical ruleset semantics) + undecided = np.ones(n, dtype=bool) + + for r in sorted(rules, key=lambda rr: rr.order): + if not r.conditions: + # condition-less rule matches everything still undecided + hit = undecided.copy() + else: + hit = undecided.copy() + for feat, val in r.conditions.items(): + if feat not in X.columns: + hit &= False + break + hit &= (X[feat].astype(int).values == int(val)) + + if hit.any(): + y_pred[hit] = int(r.prediction) + covered[hit] = True + undecided[hit] = False + + if not undecided.any(): + break + + return y_pred, covered + + +def coverage_from_covered(covered: np.ndarray) -> float: + return float(np.mean(covered)) if covered.size else float("nan") + + +# ----------------------------- +# BioHEL output extraction +# ----------------------------- +def extract_phenotype_rules(stdout: str) -> List[str]: + lines = stdout.splitlines() + out: List[str] = [] + in_pheno = False + for ln in lines: + if ln.startswith("Phenotype:"): + in_pheno = True + continue + if in_pheno: + if not ln.strip(): + break + if ln.startswith("Train"): + break + out.append(ln.rstrip()) + return out + + +def parse_biohel_train_test_accuracy(stdout: str) -> Tuple[Optional[float], Optional[float], Optional[float]]: + train_acc = None + test_acc = None + runtime = None + for line in stdout.splitlines(): + if "Train accuracy :" in line: + m = re.search(r"Train accuracy\s*:\s*([\d.]+)", line) + if m: + train_acc = float(m.group(1)) + if "Test accuracy :" in line: + m = re.search(r"Test accuracy\s*:\s*([\d.]+)", line) + if m: + test_acc = float(m.group(1)) + if "Total time:" in line: + m = re.search(r"Total time:\s*([\d.]+)", line) + if m: + runtime = float(m.group(1)) + return train_acc, test_acc, runtime + + +# ----------------------------- +# RPE integration +# ----------------------------- +_RULE_ID_PREFIX = re.compile(r"^\s*\d+\s*:\s*") + + +def write_ruleset_for_rpe(phenotype_lines: List[str], out_path: Path) -> int: + """ + Convert BioHEL phenotype to RPE ruleset: + - strip leading "id:" from each rule + - include Default rule line + """ + rules_out = [] + default_line = None + + for ln in phenotype_lines: + s = ln.strip() + if not s: + continue + if "Default rule" in s: + default_line = _RULE_ID_PREFIX.sub("", s) + continue + # normal rule + rules_out.append(_RULE_ID_PREFIX.sub("", s)) + + if default_line is None: + # BioHEL sometimes prints default outside phenotype; try to locate in original lines + for ln in phenotype_lines: + if "Default rule" in ln: + default_line = _RULE_ID_PREFIX.sub("", ln.strip()) + break + + if default_line is None: + raise ValueError("Default rule not found in phenotype rules.") + + out_path.write_text("\n".join(rules_out + [default_line]) + "\n") + return len(rules_out) + + +def run_postprocess(postprocess_bin: str, conf_path: str, ruleset_path: Path, + train_arff: Path, test_arff: Path, cwd: Path) -> str: + cmd = [postprocess_bin, conf_path, str(ruleset_path), str(train_arff), str(test_arff)] + # print(f"Running RPE postprocess: {' '.join(cmd)}") + proc = subprocess.run(cmd, capture_output=True, text=True) + if proc.returncode != 0: + raise RuntimeError(f"postprocess failed (rc={proc.returncode}):\n{proc.stderr}") + return proc.stdout + + +def extract_rpe_rules_from_stdout(pp_stdout: str) -> List[str]: + """ + Conservative heuristic: keep lines that look like BioHEL rules + default. + """ + lines = pp_stdout.splitlines() + out: List[str] = [] + in_pheno = False + for ln in lines: + if ln.startswith("Phenotype:"): + in_pheno = True + continue + if in_pheno: + if not ln.strip(): + break + if ln.startswith("Total"): + break + out.append(ln.rstrip()) + return out + + +# ----------------------------- +# Main +# ----------------------------- +def main(argv): + parser = argparse.ArgumentParser(description="BioHEL job: one CV fold + one seed (+ optional RPE)") + + parser.add_argument("--d", dest="full_data_path", type=str, required=True, + help="Path to training fold: _CV_Train_k.txt") + parser.add_argument("--o", dest="outputPath", type=str, required=True, + help="Output directory for this seed+cv fold") + + parser.add_argument("--biohel", dest="biohel_bin", type=str, default="./biohel") + + parser.add_argument("--enable_rpe", dest="enable_rpe", action="store_true") + parser.add_argument("--postprocess_bin", dest="postprocess_bin", type=str, default="./postprocess") + parser.add_argument("--postprocess_conf", dest="postprocess_conf", type=str, default="./postprocess.conf") + + parser.add_argument("--ol", dest="outcome_label", type=str, default="Class") + parser.add_argument("--il", dest="instanceID_label", type=str, default="InstanceID") + parser.add_argument("--el", dest="excluded_column", type=str, default="Group") + + parser.add_argument("--rs", dest="random_state", type=int, default=42) + parser.add_argument("--v", dest="verbose", action="store_true") + + opts = parser.parse_args(argv[1:]) + + train_path = opts.full_data_path + test_path = train_path.replace("Train", "Test") + if not os.path.exists(test_path): + raise FileNotFoundError(f"Expected test fold at: {test_path}") + + outdir = Path(opts.outputPath) + outdir.mkdir(parents=True, exist_ok=True) + + outcome_label = opts.outcome_label + instanceID_label = opts.instanceID_label + excluded_column = opts.excluded_column + seed = int(opts.random_state) + + # Load raw dataframes (used for deterministic evaluation + coverage) + train_df = load_df(train_path) + test_df = load_df(test_path) + + # Build ARFF + config + feature_names = build_feature_names(train_df, outcome_label, instanceID_label, excluded_column) + + train_arff = outdir / "train.arff" + test_arff = outdir / "test.arff" + conf_path = outdir / "config.conf" + + # Infer a single ARFF schema from TRAIN ONLY (consistent header; avoids test peeking) + feat_domains, class_domain = infer_arff_schema(train_df, feature_names, outcome_label) + + write_arff_with_schema( + train_df, feature_names, outcome_label, + filename=train_arff, relation_name="Train", + feat_domains=feat_domains, class_domain=class_domain, + ) + + write_arff_with_schema( + test_df, feature_names, outcome_label, + filename=test_arff, relation_name="Test", + feat_domains=feat_domains, class_domain=class_domain, + ) + + create_biohel_config(conf_path, seed=seed) + + # Run BioHEL + cmd = [opts.biohel_bin, str(conf_path), str(train_arff), str(test_arff)] + t0 = time.time() + # print(f"Running BioHEL: {' '.join(cmd)}") + proc = subprocess.run(cmd, capture_output=True, text=True) + wall_time = time.time() - t0 + + (outdir / "biohel_stdout.txt").write_text(proc.stdout) + (outdir / "biohel_stderr.txt").write_text(proc.stderr) + + if proc.returncode != 0: + raise RuntimeError(f"BioHEL failed (rc={proc.returncode}). See biohel_stderr.txt") + + # Extract phenotype rules (raw) + phenotype_lines = extract_phenotype_rules(proc.stdout) + (outdir / "rules_raw.txt").write_text("\n".join(phenotype_lines) + ("\n" if phenotype_lines else "")) + + # Compute raw evaluation from raw rules (deterministic) + rules_lines_for_eval = [] + for ln in phenotype_lines: + s = ln.strip() + if not s: + continue + rules_lines_for_eval.append(s) + + rules_raw, default_raw = parse_ruleset_lines(rules_lines_for_eval) + + excluded_cols = [excluded_column, instanceID_label, outcome_label] + + yhat_train_raw, covered_train_raw = apply_ruleset_predict(train_df, rules_raw, default_raw, excluded_cols) + yhat_test_raw, covered_test_raw = apply_ruleset_predict(test_df, rules_raw, default_raw, excluded_cols) + + y_train = train_df[outcome_label].astype(int).values + y_test = test_df[outcome_label].astype(int).values + + train_acc_raw = float(np.mean(yhat_train_raw == y_train)) + test_acc_raw = float(np.mean(yhat_test_raw == y_test)) + train_cov_raw = coverage_from_covered(covered_train_raw) + test_cov_raw = coverage_from_covered(covered_test_raw) + + num_rules_raw = len(rules_raw) + + # Parse BioHEL-reported runtime (optional; not used for correctness) + train_acc_reported, test_acc_reported, runtime_reported = parse_biohel_train_test_accuracy(proc.stdout) + + raw_row = { + "train_file": train_path, + "test_file": test_path, + "seed": seed, + + "train_accuracy": train_acc_raw, + "test_accuracy": test_acc_raw, + "train_coverage": train_cov_raw, + "test_coverage": test_cov_raw, + "train_default_rate": float(1.0 - train_cov_raw), + "test_default_rate": float(1.0 - test_cov_raw), + + "num_rules": int(num_rules_raw), + + "runtime": runtime_reported, + "wall_time": float(wall_time), + + # trace: what BioHEL printed (if present) + # "train_accuracy_reported": train_acc_reported, + # "test_accuracy_reported": test_acc_reported, + } + + pd.DataFrame([raw_row]).to_csv(outdir / "result_row_raw.csv", index=False) + + # Optional: run RPE and use postprocessed rules as "final" + final_row = dict(raw_row) + final_row["postprocess_wall_time"] = None + final_row["postprocess_num_rules"] = None + + if opts.enable_rpe: + ruleset_path = outdir / "ruleset_for_rpe.txt" + write_ruleset_for_rpe(phenotype_lines, ruleset_path) + + t1 = time.time() + pp_stdout = run_postprocess( + postprocess_bin=opts.postprocess_bin, + conf_path=opts.postprocess_conf, + ruleset_path=ruleset_path, + train_arff=train_arff, + test_arff=test_arff, + cwd=outdir, + ) + pp_wall = time.time() - t1 + + (outdir / "postprocess_stdout.txt").write_text(pp_stdout) + + pp_rules_lines = extract_rpe_rules_from_stdout(pp_stdout) + (outdir / "rules_postprocessed.txt").write_text("\n".join(pp_rules_lines) + ("\n" if pp_rules_lines else "")) + + # Deterministic evaluation from postprocessed rules + rules_pp, default_pp = parse_ruleset_lines(pp_rules_lines) + + yhat_train_pp, covered_train_pp = apply_ruleset_predict(train_df, rules_pp, default_pp, excluded_cols) + yhat_test_pp, covered_test_pp = apply_ruleset_predict(test_df, rules_pp, default_pp, excluded_cols) + + train_acc_pp = float(np.mean(yhat_train_pp == y_train)) + test_acc_pp = float(np.mean(yhat_test_pp == y_test)) + train_cov_pp = coverage_from_covered(covered_train_pp) + test_cov_pp = coverage_from_covered(covered_test_pp) + + final_row.update({ + "train_accuracy": train_acc_pp, + "test_accuracy": test_acc_pp, + "train_coverage": train_cov_pp, + "test_coverage": test_cov_pp, + "train_default_rate": float(1.0 - train_cov_pp), + "test_default_rate": float(1.0 - test_cov_pp), + "num_rules": int(len(rules_pp)), + "postprocess_wall_time": float(pp_wall), + "postprocess_num_rules": int(len(rules_pp)), + }) + + # Write final sentinel row used by summary + check/resub logic + pd.DataFrame([final_row]).to_csv(outdir / "result_row.csv", index=False) + + # Write a metrics.json for convenience + (outdir / "metrics.json").write_text(json.dumps({"raw": raw_row, "final": final_row}, indent=2) + "\n") + + if opts.verbose: + print( + f"Done seed={seed} " + f"test_acc={final_row['test_accuracy']:.4f} " + f"test_cov={final_row['test_coverage']:.4f} " + f"rules={final_row['num_rules']}" + ) + + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/job_biohel_sum_hpc.py b/evaluation/experiments/comparison_algs_scripts/job_biohel_sum_hpc.py new file mode 100644 index 0000000..8dfdf23 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/job_biohel_sum_hpc.py @@ -0,0 +1,401 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import os +import sys +import argparse +from pathlib import Path +from typing import List + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns + + +def _safe_read_csv(path: Path) -> pd.DataFrame: + if not path.exists(): + raise FileNotFoundError(f"Missing expected file: {path}") + return pd.read_csv(path) + + +def _ensure_numeric(df: pd.DataFrame, cols: List[str]) -> pd.DataFrame: + out = df.copy() + for c in cols: + if c in out.columns: + out[c] = pd.to_numeric(out[c], errors="coerce") + return out + + +def _get_first_row_value(rr: pd.DataFrame, col: str) -> float: + if rr is None or rr.empty or col not in rr.columns: + return np.nan + return rr[col].iloc[0] + + +def _make_eval_df_from_result_rows(rr_raw_path: Path | None, rr_final_path: Path | None) -> pd.DataFrame: + """ + Build HEROS-compatible evaluation_summary.csv. + + Output policy (per your requirement): + - raw row (non-RPE): use result_row_raw.csv; keep num_rules, runtime, wall_time as-is + - final row (RPE): use result_row.csv but normalize: + runtime = wall_time + postprocess_wall_time + wall_time = wall_time + postprocess_wall_time + num_rules = postprocess_num_rules + and DROP postprocess_* columns from the eval tables (they won't be written). + + Backward-compat: + - If only result_row.csv exists (legacy non-RPE), treat it as raw. + """ + + # Columns that will exist in evaluation_summary.csv (NO postprocess_* columns) + eval_cols = [ + "train_accuracy", + "test_accuracy", + "train_coverage", + "test_coverage", + "train_default_rate", + "test_default_rate", + "num_rules", + "runtime", + "wall_time", + ] + + rows = [] + + # ---------- RAW (non-RPE) ---------- + if rr_raw_path is not None and rr_raw_path.exists(): + rr_raw = _safe_read_csv(rr_raw_path) + row = {c: _get_first_row_value(rr_raw, c) for c in eval_cols} + row["Row Indexes"] = "raw" + rows.append(row) + + # ---------- FINAL (RPE) ---------- + if rr_final_path is not None and rr_final_path.exists(): + rr_final = _safe_read_csv(rr_final_path) + + # Base values + train_acc = _get_first_row_value(rr_final, "train_accuracy") + test_acc = _get_first_row_value(rr_final, "test_accuracy") + train_cov = _get_first_row_value(rr_final, "train_coverage") + test_cov = _get_first_row_value(rr_final, "test_coverage") + train_def = _get_first_row_value(rr_final, "train_default_rate") + test_def = _get_first_row_value(rr_final, "test_default_rate") + + wall = _get_first_row_value(rr_final, "wall_time") + post = _get_first_row_value(rr_final, "postprocess_wall_time") + # normalize missing postprocess to 0 + if np.isnan(post): + post = 0.0 + + # RPE normalization rules: + wall_total = (wall + post) if not np.isnan(wall) else np.nan + runtime_total = wall_total # per your requirement + # num_rules from postprocess_num_rules (fallback to num_rules if missing) + prules = _get_first_row_value(rr_final, "postprocess_num_rules") + if np.isnan(prules): + prules = _get_first_row_value(rr_final, "num_rules") + + row = { + "train_accuracy": train_acc, + "test_accuracy": test_acc, + "train_coverage": train_cov, + "test_coverage": test_cov, + "train_default_rate": train_def, + "test_default_rate": test_def, + "num_rules": prules, + "runtime": runtime_total, + "wall_time": wall_total, + "Row Indexes": "final", + } + rows.append(row) + + # ---------- LEGACY: only result_row.csv present; treat as raw ---------- + if not rows and rr_final_path is not None and rr_final_path.exists(): + rr = _safe_read_csv(rr_final_path) + row = {c: _get_first_row_value(rr, c) for c in eval_cols} + row["Row Indexes"] = "raw" + rows.append(row) + + if not rows: + return pd.DataFrame(columns=["Row Indexes"] + eval_cols) + + out = pd.DataFrame(rows) + out = out[["Row Indexes"] + eval_cols] + return out + + +def main(argv): + parser = argparse.ArgumentParser(description="BioHEL summary job (HEROS-compatible outputs)") + + parser.add_argument("--o", dest="outputPath", type=str, required=True, + help="Path to BioHEL_ output folder (contains dataset subfolders)") + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + parser.add_argument("--plots", dest="plots", action="store_true") + + options = parser.parse_args(argv[1:]) + + outputPath = Path(options.outputPath) + cv_partitions = int(options.cv_partitions) + random_seeds = int(options.random_seeds) + make_plots = bool(options.plots) + + if not outputPath.exists(): + raise FileNotFoundError(f"Output path does not exist: {outputPath}") + + # Metrics that exist in evaluation_summary.csv (postprocess_* dropped) + metric_cols = [ + "train_accuracy", + "test_accuracy", + "train_coverage", + "test_coverage", + "train_default_rate", + "test_default_rate", + "num_rules", + "runtime", + "wall_time", + ] + + # 1) Ensure evaluation_summary.csv exists per cv folder (HEROS-style interface) + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + if not seed_level_path.exists(): + continue + + for j in range(1, cv_partitions + 1): + cv_level_path = seed_level_path / f"cv_{j}" + if not cv_level_path.exists(): + continue + + eval_path = cv_level_path / "evaluation_summary.csv" + if eval_path.exists(): + continue + + rr_raw_path = cv_level_path / "result_row_raw.csv" + rr_final_path = cv_level_path / "result_row.csv" + + if rr_raw_path.exists() or rr_final_path.exists(): + eval_df = _make_eval_df_from_result_rows( + rr_raw_path if rr_raw_path.exists() else None, + rr_final_path if rr_final_path.exists() else None, + ) + eval_df.to_csv(eval_path, index=False) + + # 2) Seed-level CV summaries: mean/sd across CV folds + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + if not seed_level_path.is_dir(): + continue + + dfs = [] + + for j in range(1, cv_partitions + 1): + cv_level_path = seed_level_path / f"cv_{j}" + eval_path = cv_level_path / "evaluation_summary.csv" + if not eval_path.exists(): + continue + + df = _safe_read_csv(eval_path) + if "Row Indexes" not in df.columns or df.empty: + continue + + df = _ensure_numeric(df, metric_cols) + df_x = df.drop(columns=["Row Indexes"]) + df_x.index = df["Row Indexes"].astype(str).values # groupable labels + dfs.append(df_x) + + if not dfs: + continue + + all_x = pd.concat(dfs, axis=0) + ave_df_x = all_x.groupby(level=0).mean() + sd_df_x = all_x.groupby(level=0).std() + + mean_df = ave_df_x.reset_index().rename(columns={"index": "Row Indexes"}) + sd_df = sd_df_x.reset_index().rename(columns={"index": "Row Indexes"}) + + mean_df.to_csv(seed_level_path / "mean_CV_evaluation_summary.csv", index=False) + sd_df.to_csv(seed_level_path / "sd_CV_evaluation_summary.csv", index=False) + + # 3) Dataset-level seed summaries: mean/sd across seeds + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + dfs = [] + + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + mean_path = seed_level_path / "mean_CV_evaluation_summary.csv" + if not mean_path.exists(): + continue + + df = _safe_read_csv(mean_path) + if "Row Indexes" not in df.columns or df.empty: + continue + + df = _ensure_numeric(df, metric_cols) + df_x = df.drop(columns=["Row Indexes"]) + df_x.index = df["Row Indexes"].astype(str).values + dfs.append(df_x) + + if not dfs: + continue + + all_x = pd.concat(dfs, axis=0) + ave_df_x = all_x.groupby(level=0).mean() + sd_df_x = all_x.groupby(level=0).std() + + mean_df = ave_df_x.reset_index().rename(columns={"index": "Row Indexes"}) + sd_df = sd_df_x.reset_index().rename(columns={"index": "Row Indexes"}) + + mean_df.to_csv(data_level_path / "mean_seed_evaluation_summary.csv", index=False) + sd_df.to_csv(data_level_path / "sd_seed_evaluation_summary.csv", index=False) + + # 4) Global results lists (HEROS-style patterns) + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + # (a) all_evaluations.csv and per-rowidx splits + rows_all = [] + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + if not seed_level_path.is_dir(): + continue + + for j in range(1, cv_partitions + 1): + cv_level_path = seed_level_path / f"cv_{j}" + eval_path = cv_level_path / "evaluation_summary.csv" + if not eval_path.exists(): + continue + + df_eval = _safe_read_csv(eval_path) + if df_eval.empty or "Row Indexes" not in df_eval.columns: + continue + + df_eval = _ensure_numeric(df_eval, metric_cols) + + for _, r in df_eval.iterrows(): + rowidx = str(r["Row Indexes"]) + rr_row = {c: (r[c] if c in df_eval.columns else np.nan) for c in metric_cols} + rr_row["Row Indexes"] = rowidx + rr_row["Seed"] = i + rr_row["CV"] = j + rows_all.append(rr_row) + + if rows_all: + df_all = pd.DataFrame(rows_all) + df_all = _ensure_numeric(df_all, metric_cols + ["Seed", "CV"]) + df_all.to_csv(data_level_path / "all_evaluations.csv", index=False) + + for rowidx in sorted(df_all["Row Indexes"].dropna().unique().tolist()): + sub = df_all[df_all["Row Indexes"] == rowidx].copy() + sub.to_csv(data_level_path / f"all_{rowidx}_evaluations.csv", index=False) + + # (b) cv_ave_evaluations.csv and per-rowidx splits + rows_cv_ave = [] + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + mean_path = seed_level_path / "mean_CV_evaluation_summary.csv" + if not mean_path.exists(): + continue + + df = _safe_read_csv(mean_path) + if df.empty or "Row Indexes" not in df.columns: + continue + + df = _ensure_numeric(df, metric_cols) + + for _, r in df.iterrows(): + rowidx = str(r["Row Indexes"]) + row = {c: (r[c] if c in df.columns else np.nan) for c in metric_cols} + row["Row Indexes"] = rowidx + row["Seed"] = i + rows_cv_ave.append(row) + + if rows_cv_ave: + df_cv_ave = pd.DataFrame(rows_cv_ave) + df_cv_ave = _ensure_numeric(df_cv_ave, metric_cols + ["Seed"]) + df_cv_ave.to_csv(data_level_path / "cv_ave_evaluations.csv", index=False) + + for rowidx in sorted(df_cv_ave["Row Indexes"].dropna().unique().tolist()): + sub = df_cv_ave[df_cv_ave["Row Indexes"] == rowidx].copy() + sub.to_csv(data_level_path / f"cv_ave_{rowidx}_evaluations.csv", index=False) + + # 5) Plots (per row type) + if make_plots: + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + all_path = data_level_path / "all_evaluations.csv" + if not all_path.exists(): + continue + + df_all = _safe_read_csv(all_path) + if df_all.empty or "Row Indexes" not in df_all.columns: + continue + + df_all = _ensure_numeric(df_all, metric_cols + ["Seed", "CV"]) + + for rowidx in sorted(df_all["Row Indexes"].dropna().unique().tolist()): + sub = df_all[df_all["Row Indexes"] == rowidx].copy() + suffix = f"_{rowidx}" + + if "test_accuracy" in sub.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=sub, y="test_accuracy") + plt.xlabel("") + plt.ylabel("Test Accuracy") + plt.title(f"Balanced Testing Accuracy (All Runs) [{rowidx}]") + plt.savefig(data_level_path / f"boxplot_testing_accuracy_all{suffix}.png", bbox_inches="tight") + plt.close() + + if "num_rules" in sub.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=sub, y="num_rules") + plt.xlabel("") + plt.ylabel("Rule Count") + plt.title(f"Rule Count (All Runs) [{rowidx}]") + plt.savefig(data_level_path / f"boxplot_rule_count_all{suffix}.png", bbox_inches="tight") + plt.close() + + if "test_coverage" in sub.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=sub, y="test_coverage") + plt.xlabel("") + plt.ylabel("Test Coverage") + plt.title(f"Test Coverage (All Runs) [{rowidx}]") + plt.savefig(data_level_path / f"boxplot_testing_coverage_all{suffix}.png", bbox_inches="tight") + plt.close() + + if "train_coverage" in sub.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=sub, y="train_coverage") + plt.xlabel("") + plt.ylabel("Train Coverage") + plt.title(f"Train Coverage (All Runs) [{rowidx}]") + plt.savefig(data_level_path / f"boxplot_train_coverage_all{suffix}.png", bbox_inches="tight") + plt.close() + + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/job_ripper_hpc.py b/evaluation/experiments/comparison_algs_scripts/job_ripper_hpc.py new file mode 100644 index 0000000..f81fe69 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/job_ripper_hpc.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import os +import sys +import json +import time +import argparse +from pathlib import Path +from typing import Optional, Tuple + +import numpy as np +import pandas as pd +from sklearn.metrics import accuracy_score + +# wittgenstein +from wittgenstein import RIPPER + + +def load_df(path: str) -> pd.DataFrame: + return pd.read_csv(path, sep="\t") + + +def preprocess_df(df: pd.DataFrame, outcome_label: str, instanceID_label: str, excluded_column: str) -> pd.DataFrame: + # Keep all feature cols + outcome_label; drop bookkeeping cols if present + drop_cols = [c for c in [instanceID_label, excluded_column] if c in df.columns] + return df.drop(columns=drop_cols, errors="ignore") + + +def compute_rule_coverage(model: RIPPER, X: pd.DataFrame) -> float: + """ + Coverage defined as fraction of rows covered by at least one learned rule (excluding default). + Uses wittgenstein internals if available; otherwise falls back to conservative parsing. + """ + n = len(X) + if n == 0: + return float("nan") + + # Preferred: model.ruleset_.covers(...) exists for many versions + rs = getattr(model, "ruleset_", None) + if rs is not None: + # Try vectorized covers + covers_fn = getattr(rs, "covers", None) + if callable(covers_fn): + try: + covered = covers_fn(X) + # Some versions return list[bool], np.array, or pandas Series + covered = np.asarray(covered, dtype=bool) + return float(np.mean(covered)) + except Exception: + pass + + # Try iterating rules + rules = getattr(rs, "rules", None) + if rules is None: + rules = getattr(rs, "rule_list", None) + + if rules is not None: + covered_any = np.zeros(n, dtype=bool) + for r in rules: + # rule.covers(X) is common + rc = getattr(r, "covers", None) + if callable(rc): + try: + c = np.asarray(rc(X), dtype=bool) + covered_any |= c + except Exception: + continue + return float(np.mean(covered_any)) + + # Fallback: if we cannot evaluate coverage reliably, return NaN + return float("nan") + + +def maybe_cap_rules(model: RIPPER, max_rules: Optional[int]) -> int: + rs = getattr(model, "ruleset_", None) + if rs is None or max_rules is None: + return len(getattr(rs, "rules", [])) if rs is not None else 0 + try: + rules = list(getattr(rs, "rules", [])) + if len(rules) <= max_rules: + return len(rules) + # truncate ruleset (best-effort) + rs.rules = rules[:max_rules] + return len(rs.rules) + except Exception: + return len(getattr(rs, "rules", [])) + + +def write_rules(model: RIPPER, out_path: Path) -> int: + rs = getattr(model, "ruleset_", None) + if rs is None: + out_path.write_text("") + return 0 + # wittgenstein has readable string for ruleset + s = str(rs) + out_path.write_text(s + ("\n" if not s.endswith("\n") else "")) + # Approximate rule count + rules = getattr(rs, "rules", None) + if rules is not None: + return len(rules) + return s.count("IF ") if "IF " in s else 0 + + +def main(argv): + parser = argparse.ArgumentParser(description="RIPPER job: one CV fold + one seed") + + parser.add_argument("--d", dest="full_data_path", type=str, required=True, + help="Path to training fold: _CV_Train_k.txt") + parser.add_argument("--o", dest="outputPath", type=str, required=True, + help="Output directory for this seed+cv fold") + + parser.add_argument("--ol", dest="outcome_label", type=str, default="Class") + parser.add_argument("--il", dest="instanceID_label", type=str, default="InstanceID") + parser.add_argument("--el", dest="excluded_column", type=str, default="Group") + + parser.add_argument("--rs", dest="random_state", type=int, default=42) + parser.add_argument("--max_rules", dest="max_rules", type=int, default=None) + parser.add_argument("--verbosity", dest="verbosity", type=int, default=0) + parser.add_argument("--v", dest="verbose", action="store_true") + + opts = parser.parse_args(argv[1:]) + + train_path = opts.full_data_path + test_path = train_path.replace("Train", "Test") + if not os.path.exists(test_path): + raise FileNotFoundError(f"Expected test fold at: {test_path}") + + outdir = Path(opts.outputPath) + outdir.mkdir(parents=True, exist_ok=True) + + outcome_label = opts.outcome_label + instanceID_label = opts.instanceID_label + excluded_column = opts.excluded_column + seed = int(opts.random_state) + + # Load + train_df_raw = load_df(train_path) + test_df_raw = load_df(test_path) + + train_df = preprocess_df(train_df_raw, outcome_label, instanceID_label, excluded_column) + test_df = preprocess_df(test_df_raw, outcome_label, instanceID_label, excluded_column) + + if outcome_label not in train_df.columns or outcome_label not in test_df.columns: + raise ValueError(f"Outcome label '{outcome_label}' must exist in train and test files.") + + X_train = train_df.drop(columns=[outcome_label]) + y_train = train_df[outcome_label].astype(int).values + + X_test = test_df.drop(columns=[outcome_label]) + y_test = test_df[outcome_label].astype(int).values + + # Train RIPPER + model = RIPPER(k=20, random_state=seed, verbosity=opts.verbosity) + + t0 = time.time() + model.fit(X_train, y_train) + wall_time = time.time() - t0 + + # Optionally cap rules (best-effort) + rule_count = maybe_cap_rules(model, opts.max_rules) + + # Predict + yhat_train = model.predict(X_train) + yhat_test = model.predict(X_test) + + train_acc = float(accuracy_score(y_train, yhat_train)) + test_acc = float(accuracy_score(y_test, yhat_test)) + + train_cov = compute_rule_coverage(model, X_train) + test_cov = compute_rule_coverage(model, X_test) + + # Write rules + outputs + rules_path = outdir / "rules.txt" + rule_count_written = write_rules(model, rules_path) + if rule_count_written > 0: + rule_count = rule_count_written + + row = { + "train_file": train_path, + "test_file": test_path, + "seed": seed, + + "train_accuracy": train_acc, + "test_accuracy": test_acc, + + # Coverage = fraction covered by any learned rule; if not available => NaN + "train_coverage": train_cov, + "test_coverage": test_cov, + "train_default_rate": (float(1.0 - train_cov) if np.isfinite(train_cov) else np.nan), + "test_default_rate": (float(1.0 - test_cov) if np.isfinite(test_cov) else np.nan), + + "num_rules": int(rule_count), + + "runtime": float(wall_time), # RIPPER does not report internal runtime; keep for consistency + "wall_time": float(wall_time), + } + + pd.DataFrame([row]).to_csv(outdir / "result_row.csv", index=False) + + # HEROS-style fold eval interface + eval_df = pd.DataFrame([{ + "Row Indexes": "final", + **{k: row.get(k) for k in [ + "train_accuracy", "test_accuracy", + "train_coverage", "test_coverage", + "train_default_rate", "test_default_rate", + "num_rules", "runtime", "wall_time" + ]} + }]) + eval_df.to_csv(outdir / "evaluation_summary.csv", index=False) + + (outdir / "metrics.json").write_text(json.dumps(row, indent=2) + "\n") + + if opts.verbose: + print(f"Done seed={seed} test_acc={test_acc:.4f} test_cov={test_cov} rules={rule_count}") + + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/job_ripper_sum_hpc.py b/evaluation/experiments/comparison_algs_scripts/job_ripper_sum_hpc.py new file mode 100644 index 0000000..e73c2d1 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/job_ripper_sum_hpc.py @@ -0,0 +1,293 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import os +import sys +import argparse +from pathlib import Path +from typing import List + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns + + +def _safe_read_csv(path: Path) -> pd.DataFrame: + if not path.exists(): + raise FileNotFoundError(f"Missing expected file: {path}") + return pd.read_csv(path) + + +def _ensure_numeric(df: pd.DataFrame, cols: List[str]) -> pd.DataFrame: + out = df.copy() + for c in cols: + if c in out.columns: + out[c] = pd.to_numeric(out[c], errors="coerce") + return out + + +def _make_eval_df_from_result_row(result_row_path: Path) -> pd.DataFrame: + rr = _safe_read_csv(result_row_path) + + wanted_cols = [ + "train_accuracy", + "test_accuracy", + "train_coverage", + "test_coverage", + "train_default_rate", + "test_default_rate", + "num_rules", + "runtime", + "wall_time", + ] + + row = {} + for c in wanted_cols: + row[c] = rr[c].iloc[0] if c in rr.columns and len(rr) else np.nan + + out = pd.DataFrame([row]) + out.insert(0, "Row Indexes", "final") + return out + + +def main(argv): + parser = argparse.ArgumentParser(description="RIPPER summary job (HEROS-compatible outputs)") + + parser.add_argument("--o", dest="outputPath", type=str, required=True, + help="Path to RIPPER_ output folder (contains dataset subfolders)") + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + parser.add_argument("--plots", dest="plots", action="store_true") + + options = parser.parse_args(argv[1:]) + + outputPath = Path(options.outputPath) + cv_partitions = int(options.cv_partitions) + random_seeds = int(options.random_seeds) + make_plots = bool(options.plots) + + if not outputPath.exists(): + raise FileNotFoundError(f"Output path does not exist: {outputPath}") + + metric_cols = [ + "train_accuracy", + "test_accuracy", + "train_coverage", + "test_coverage", + "train_default_rate", + "test_default_rate", + "num_rules", + "runtime", + "wall_time", + ] + + # 1) Ensure evaluation_summary.csv exists per cv folder + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + if not seed_level_path.exists(): + continue + + for j in range(1, cv_partitions + 1): + cv_level_path = seed_level_path / f"cv_{j}" + if not cv_level_path.exists(): + continue + + eval_path = cv_level_path / "evaluation_summary.csv" + if eval_path.exists(): + continue + + rr_path = cv_level_path / "result_row.csv" + if rr_path.exists(): + eval_df = _make_eval_df_from_result_row(rr_path) + eval_df.to_csv(eval_path, index=False) + + # 2) Seed-level CV summaries + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + if not seed_level_path.is_dir(): + continue + + dfs = [] + row_names = None + + for j in range(1, cv_partitions + 1): + cv_level_path = seed_level_path / f"cv_{j}" + eval_path = cv_level_path / "evaluation_summary.csv" + if not eval_path.exists(): + continue + + df = _safe_read_csv(eval_path) + if "Row Indexes" not in df.columns: + continue + + row_names = df["Row Indexes"] + df_x = df.drop(columns=["Row Indexes"]) + df_x = _ensure_numeric(df_x, list(df_x.columns)) + dfs.append(df_x) + + if not dfs: + continue + + ave_df_x = pd.concat(dfs).groupby(level=0).mean() + mean_df = pd.concat([row_names, ave_df_x], axis=1) + mean_df.to_csv(seed_level_path / "mean_CV_evaluation_summary.csv", index=False) + + sd_df_x = pd.concat(dfs).groupby(level=0).std() + sd_df = pd.concat([row_names, sd_df_x], axis=1) + sd_df.to_csv(seed_level_path / "sd_CV_evaluation_summary.csv", index=False) + + # 3) Dataset-level seed summaries + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + dfs = [] + row_names = None + + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + mean_path = seed_level_path / "mean_CV_evaluation_summary.csv" + if not mean_path.exists(): + continue + + df = _safe_read_csv(mean_path) + if "Row Indexes" not in df.columns: + continue + + row_names = df["Row Indexes"] + df_x = df.drop(columns=["Row Indexes"]) + df_x = _ensure_numeric(df_x, list(df_x.columns)) + dfs.append(df_x) + + if not dfs: + continue + + ave_df_x = pd.concat(dfs).groupby(level=0).mean() + mean_df = pd.concat([row_names, ave_df_x], axis=1) + mean_df.to_csv(data_level_path / "mean_seed_evaluation_summary.csv", index=False) + + sd_df_x = pd.concat(dfs).groupby(level=0).std() + sd_df = pd.concat([row_names, sd_df_x], axis=1) + sd_df.to_csv(data_level_path / "sd_seed_evaluation_summary.csv", index=False) + + # 4) Global results lists + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + rows_all = [] + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + if not seed_level_path.is_dir(): + continue + + for j in range(1, cv_partitions + 1): + cv_level_path = seed_level_path / f"cv_{j}" + rr_path = cv_level_path / "result_row.csv" + if not rr_path.exists(): + continue + + rr = _safe_read_csv(rr_path) + rr_row = {c: (rr[c].iloc[0] if c in rr.columns and len(rr) else np.nan) for c in metric_cols} + rr_row["Seed"] = i + rr_row["CV"] = j + rows_all.append(rr_row) + + if rows_all: + df_all = pd.DataFrame(rows_all) + df_all = _ensure_numeric(df_all, metric_cols + ["Seed", "CV"]) + df_all.to_csv(data_level_path / "all_final_evaluations.csv", index=False) + + rows_cv_ave = [] + for i in range(0, random_seeds): + seed_level_path = data_level_path / f"seed_{i}" + mean_path = seed_level_path / "mean_CV_evaluation_summary.csv" + if not mean_path.exists(): + continue + + df = _safe_read_csv(mean_path) + df = _ensure_numeric(df, metric_cols) + + if "Row Indexes" not in df.columns: + continue + df_final = df[df["Row Indexes"] == "final"].copy() + if df_final.empty: + continue + + row = {c: (df_final[c].iloc[0] if c in df_final.columns else np.nan) for c in metric_cols} + row["Seed"] = i + rows_cv_ave.append(row) + + if rows_cv_ave: + df_cv_ave = pd.DataFrame(rows_cv_ave) + df_cv_ave = _ensure_numeric(df_cv_ave, metric_cols + ["Seed"]) + df_cv_ave.to_csv(data_level_path / "cv_ave_final_evaluations.csv", index=False) + + # 5) Plots + if make_plots: + for entry in os.listdir(outputPath): + data_level_path = outputPath / entry + if not data_level_path.is_dir(): + continue + + all_path = data_level_path / "all_final_evaluations.csv" + if not all_path.exists(): + continue + + df_all = _safe_read_csv(all_path) + df_all = _ensure_numeric(df_all, metric_cols + ["Seed", "CV"]) + + if "test_accuracy" in df_all.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=df_all, y="test_accuracy") + plt.xlabel("") + plt.ylabel("Test Accuracy") + plt.title("Testing Accuracy (All Runs)") + plt.savefig(data_level_path / "boxplot_testing_accuracy_all.png", bbox_inches="tight") + plt.close() + + if "num_rules" in df_all.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=df_all, y="num_rules") + plt.xlabel("") + plt.ylabel("Rule Count") + plt.title("Rule Count (All Runs)") + plt.savefig(data_level_path / "boxplot_rule_count_all.png", bbox_inches="tight") + plt.close() + + if "test_coverage" in df_all.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=df_all, y="test_coverage") + plt.xlabel("") + plt.ylabel("Test Coverage") + plt.title("Test Coverage (All Runs)") + plt.savefig(data_level_path / "boxplot_testing_coverage_all.png", bbox_inches="tight") + plt.close() + + if "train_coverage" in df_all.columns: + plt.figure(figsize=(10, 6)) + sns.boxplot(data=df_all, y="train_coverage") + plt.xlabel("") + plt.ylabel("Train Coverage") + plt.title("Train Coverage (All Runs)") + plt.savefig(data_level_path / "boxplot_train_coverage_all.png", bbox_inches="tight") + plt.close() + + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/job_sum_table_hpc.py b/evaluation/experiments/comparison_algs_scripts/job_sum_table_hpc.py new file mode 100644 index 0000000..4d29062 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/job_sum_table_hpc.py @@ -0,0 +1,342 @@ +#!/usr/bin/env python3 +""" +Summarize BioHEL + RIPPER from ONLY TWO folder inputs, using metrics.json as source of truth. + +Key requirement implemented: +- If BioHEL metrics.json contains BOTH "raw" and "final": + * include TWO rows: + - BioHEL_noRPE from "raw" (matches result_row_raw.csv semantics) + - BioHEL_RPE from "final" (matches result_row.csv semantics) +- If BioHEL metrics.json is flat (no raw/final): + * include ONE row: BioHEL_noRPE +- If BioHEL metrics.json has only "final" (edge case): + * include ONE row: + - BioHEL_RPE if postprocess_* present + - else BioHEL_noRPE + +RPE runtime rule: + final_runtime_seconds = wall_time + postprocess_wall_time +(preprocess_time is extracted from metrics.json if present under known keys; else 0.) + +RIPPER metrics.json is flat: + include ONE row: RIPPER (final_runtime_seconds = wall_time) + +Outputs: + /combined_runs_long.csv + /summary_by_dataset.csv + /summary_multiplexer_only.csv (Ideal Solution k/n for MUX datasets) + /summary_gametes_only.csv + +Run: + python job_sum_table_hpc.py \ + --biohel_root /project/kamoun_shared/output_shared/biohel_gecco \ + --ripper_root /project/kamoun_shared/output_shared/ripper_gecco \ + --out /project/kamoun_shared/output_shared/paper_tables +""" + +import os +import re +import json +import math +import argparse +from typing import Any, Dict, List, Optional, Tuple + +import numpy as np +import pandas as pd + + +# ----------------------------- +# Multiplexer ideal rule counts +# ----------------------------- +IDEAL_COUNTS: Dict[str, int] = { + "A_multiplexer_6_bit_500_inst": 5, + "B_multiplexer_11_bit_5000_inst": 9, + "C_multiplexer_20_bit_10000_inst": 17, + "D_multiplexer_37_bit_10000_inst": 33, + "E_multiplexer_70_bit_20000_inst": 65, +} +IDEAL_ACC = 1.0 + + +# ----------------------------- +# Dataset name inference +# ----------------------------- +CV_TRAIN_RE = re.compile(r"([^/]+)_CV_Train_\d+\.txt$") + + +def infer_dataset_name(train_file: str) -> str: + if isinstance(train_file, str): + m = CV_TRAIN_RE.search(train_file) + if m: + return m.group(1) + parts = os.path.normpath(train_file).split(os.sep) + if len(parts) >= 2: + return parts[-2] + return "UNKNOWN" + + +# ----------------------------- +# File discovery / JSON parsing +# ----------------------------- +def find_files(root: str, filename: str) -> List[str]: + out = [] + for dirpath, _, filenames in os.walk(root): + if filename in filenames: + out.append(os.path.join(dirpath, filename)) + return out + + +def load_json(path: str) -> Optional[Dict[str, Any]]: + try: + with open(path, "r") as f: + return json.load(f) + except Exception: + return None + + +def coerce_float(x: Any) -> Optional[float]: + try: + return float(x) + except Exception: + return None + + +def coerce_int(x: Any) -> Optional[int]: + try: + return int(float(x)) + except Exception: + return None + + +def is_rpe_final_block(d: Dict[str, Any]) -> bool: + return ("postprocess_wall_time" in d) or ("postprocess_num_rules" in d) + + +# ----------------------------- +# Long-form row construction +# ----------------------------- +def _make_row( + algorithm_family: str, + scenario: str, + metrics_json_path: str, + metrics_obj: Dict[str, Any], + block: Dict[str, Any] +) -> Dict[str, Any]: + """ + Construct one normalized long-form row from a block dict. + scenario determines runtime handling (BioHEL_RPE adds postprocess). + """ + runtime = coerce_float(block.get("runtime")) + postprocess = coerce_float(block.get("postprocess_wall_time")) if scenario == "BioHEL_RPE" else None + + final_runtime = None + if runtime is not None: + final_runtime = coerce_float(block.get("wall_time")) + float(postprocess or 0.0) + + # rule_count: for RPE prefer postprocess_num_rules if available + if scenario == "BioHEL_RPE" and ("postprocess_num_rules" in block): + rule_count = coerce_int(block.get("postprocess_num_rules")) + else: + rule_count = coerce_int(block.get("num_rules")) + + train_file = block.get("train_file") + dataset = infer_dataset_name(train_file) if isinstance(train_file, str) else "UNKNOWN" + + return { + "AlgorithmFamily": algorithm_family, + "Scenario": scenario, + "Dataset": dataset, + "seed": coerce_int(block.get("seed")), + "train_file": block.get("train_file"), + "test_file": block.get("test_file"), + "train_accuracy": coerce_float(block.get("train_accuracy")), + "test_accuracy": coerce_float(block.get("test_accuracy")), + "train_coverage": coerce_float(block.get("train_coverage")), + "test_coverage": coerce_float(block.get("test_coverage")), + "train_default_rate": coerce_float(block.get("train_default_rate")), + "test_default_rate": coerce_float(block.get("test_default_rate")), + "num_rules": coerce_int(block.get("num_rules")), + "rule_count": rule_count, + "runtime": runtime, + "wall_time": coerce_float(block.get("wall_time")), + "postprocess_wall_time": coerce_float(block.get("postprocess_wall_time")), + "postprocess_num_rules": coerce_int(block.get("postprocess_num_rules")), + "final_runtime": final_runtime, + "run_time_minutes": (final_runtime / 60.0) if final_runtime is not None else None, + "_source_json": metrics_json_path, + "_source_dir": os.path.dirname(metrics_json_path), + } + + +def build_long_rows_from_biohel(biohel_root: str) -> Tuple[pd.DataFrame, int]: + """ + BioHEL: + - If both "raw" and "final" exist -> create two rows (noRPE from raw, RPE from final). + - Else if flat dict -> one row noRPE. + - Else if only "final" -> one row, scenario depends on postprocess_* presence. + - Else if only "raw" -> one row noRPE. + + """ + paths = find_files(biohel_root, "metrics.json") + rows: List[Dict[str, Any]] = [] + + for p in paths: + obj = load_json(p) + if obj is None or not isinstance(obj, dict): + continue + + has_raw = isinstance(obj.get("raw"), dict) + has_final = isinstance(obj.get("final"), dict) + + if has_raw and has_final: + # Always include BOTH: + # - raw as BioHEL_noRPE + rows.append(_make_row("BioHEL", "BioHEL_noRPE", p, obj, obj["raw"])) + # - final as BioHEL_RPE (even if postprocess keys absent, per your rule final == RPE output) + rows.append(_make_row("BioHEL", "BioHEL_RPE", p, obj, obj["final"])) + + # Only final + if has_final and not has_raw: + final_block = obj["final"] + scenario = "BioHEL_RPE" if is_rpe_final_block(final_block) else "BioHEL_noRPE" + rows.append(_make_row("BioHEL", scenario, p, obj, final_block)) + + # Only raw + if has_raw and not has_final: + rows.append(_make_row("BioHEL", "BioHEL_noRPE", p, obj, obj["raw"])) + continue + + # Flat dict (no raw/final): treat as noRPE + if "train_file" in obj and "runtime" in obj: + rows.append(_make_row("BioHEL", "BioHEL_noRPE", p, obj, obj)) + continue + + if not rows: + return pd.DataFrame() + return pd.DataFrame(rows) + + +def build_long_rows_from_ripper(ripper_root: str) -> pd.DataFrame: + """ + RIPPER metrics.json is flat; no raw/final. + """ + paths = find_files(ripper_root, "metrics.json") + rows: List[Dict[str, Any]] = [] + + for p in paths: + obj = load_json(p) + if obj is None or not isinstance(obj, dict): + continue + if "train_file" not in obj or "runtime" not in obj: + continue + + rows.append(_make_row("RIPPER", "RIPPER", p, obj, obj)) + + if not rows: + return pd.DataFrame() + return pd.DataFrame(rows) + + +# ----------------------------- +# Summary tables +# ----------------------------- +def ideal_solution_k_over_n(sub: pd.DataFrame, dataset: str, scenario:str) -> str: + if dataset not in IDEAL_COUNTS: + return "" + if sub.empty: + return "0/0" + acc = pd.to_numeric(sub["test_accuracy"], errors="coerce") + rules = pd.to_numeric(sub["rule_count"], errors="coerce") + n = int(sub.shape[0]) + ideal_count = IDEAL_COUNTS[dataset] if scenario != "RIPPER" else IDEAL_COUNTS[dataset] - 1 + k = int(((acc == IDEAL_ACC) & (rules == ideal_count)).sum()) + return f"{k}/{n}" + + +def fmt_mean_std(series: pd.Series, digits: Optional[int]) -> str: + s = pd.to_numeric(series, errors="coerce").dropna() + if s.empty: + return "NA" + mean = float(s.mean()) + std = float(s.std()) + if digits is None: + if float(mean).is_integer() and float(std).is_integer(): + return f"{int(mean)} ({int(std)})" + return f"{mean} ({std})" + return f"{float(mean):.{digits}f}({float(std):.{digits}f})" + # return f"{round(mean, digits)} ({round(std, digits)})" + + +def build_summary(df_long: pd.DataFrame) -> pd.DataFrame: + if df_long.empty: + return pd.DataFrame(columns=["Dataset", "Scenario", "Test Acc.", "Test Cover", "Rule Count", "Run Time", "Ideal Solution"]) + + rows = [] + for (dataset, scenario), g in df_long.groupby(["Dataset", "Scenario"], dropna=False): + rows.append({ + "Dataset": dataset, + "Scenario": scenario, + "Test Acc.": fmt_mean_std(g["test_accuracy"], 3), + "Test Cover": fmt_mean_std(g["test_coverage"], 3), + "Rule Count": fmt_mean_std(g["rule_count"], 1), + "Run Time": fmt_mean_std(g["run_time_minutes"], 1), + "Ideal Solution": ideal_solution_k_over_n(g, dataset, scenario), + }) + + return ( + pd.DataFrame(rows) + .sort_values(["Dataset", "Scenario"], kind="mergesort") + .reset_index(drop=True) + ) + + +# ----------------------------- +# Main +# ----------------------------- +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--biohel_root", required=True, type=str, help="Parent folder containing BioHEL no-RPE and RPE outputs.") + ap.add_argument("--ripper_root", required=True, type=str, help="Root folder for RIPPER outputs.") + ap.add_argument("--out", required=True, type=str, help="Output folder for summary CSVs.") + args = ap.parse_args() + + os.makedirs(args.out, exist_ok=True) + + biohel_df = build_long_rows_from_biohel(args.biohel_root) + ripper_df = build_long_rows_from_ripper(args.ripper_root) + combined = pd.concat([biohel_df, ripper_df], axis=0, ignore_index=True, sort=False) + + long_cols = [ + "AlgorithmFamily", "Scenario", "Dataset", + "seed", "train_file", "test_file", + "test_accuracy", "test_coverage", + "rule_count", + "runtime", "postprocess_wall_time", "preprocess_time", "final_runtime", "run_time_minutes", + "_source_json", + ] + long_out = combined[[c for c in long_cols if c in combined.columns]].copy() + long_path = os.path.join(args.out, "combined_runs_long.csv") + long_out.to_csv(long_path, index=False) + + summary = build_summary(combined) + summary_path = os.path.join(args.out, "summary_by_dataset.csv") + summary.to_csv(summary_path, index=False) + + mux = summary[summary["Dataset"].isin(IDEAL_COUNTS.keys())].copy() + nonmux = summary[~summary["Dataset"].isin(IDEAL_COUNTS.keys())].copy() + + mux_path = os.path.join(args.out, "summary_multiplexer_only.csv") + nonmux_path = os.path.join(args.out, "summary_gametes_only.csv") + mux.to_csv(mux_path, index=False) + nonmux.to_csv(nonmux_path, index=False) + + print(f"[OK] Wrote: {long_path}") + print(f"[OK] Wrote: {summary_path}") + print(f"[OK] Wrote: {mux_path}") + print(f"[OK] Wrote: {nonmux_path}") + + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/evaluation/experiments/comparison_algs_scripts/postprocess b/evaluation/experiments/comparison_algs_scripts/postprocess new file mode 100755 index 0000000..fd84866 Binary files /dev/null and b/evaluation/experiments/comparison_algs_scripts/postprocess differ diff --git a/evaluation/experiments/comparison_algs_scripts/postprocess.conf b/evaluation/experiments/comparison_algs_scripts/postprocess.conf new file mode 100644 index 0000000..fdcc5db --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/postprocess.conf @@ -0,0 +1,43 @@ +# Original BioHEL-RPE postprocess configuration + +crossover operator 1px +default class major +fitness function mdl +initialization min classifiers 20 +initialization max classifiers 20 +iterations 50 +mdl initial tl ratio 0.25 +mdl iteration 10 +mdl weight relax factor 0.90 +pop size 500 +prob crossover 0.6 +prob individual mutation 0.6 +prob one 0.75 +selection algorithm tournamentwor +tournament size 4 +windowing ilas 1 +dump evolution stats +smart init +class wise init +coverage breakpoint 0.01 +repetitions of rule learning 2 +coverage ratio 0.90 + +kr hyperrect +num expressed attributes init 15 +hyperrectangle uses list of attributes +prob generalize list 0.10 +prob specialize list 0.10 + +# BioHEL-RPE postprocess configuration +# Operator policies (keep exactly as requested) + +operator 1 policy cl +operator 2 policy pr +operator 3 policy cl2 +operator 4 policy pr +operator 5 policy sw + +# Optional: keep stats concise (END) vs verbose (ALL) +trainset stats enabled END +testset stats enabled END diff --git a/evaluation/experiments/comparison_algs_scripts/run_biohel_hpc.py b/evaluation/experiments/comparison_algs_scripts/run_biohel_hpc.py new file mode 100644 index 0000000..ec22697 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/run_biohel_hpc.py @@ -0,0 +1,256 @@ +#!/usr/bin/env python3 +import sys +import os +import time +import argparse +from pathlib import Path + + +def main(argv): + parser = argparse.ArgumentParser(description="Submit BioHEL jobs across datasets × seeds × CV folds") + + # Paths + parser.add_argument("--d", dest="datafolder", type=str, required=True, + help="Path to data folder containing dataset subfolders.") + parser.add_argument("--w", dest="writepath", type=str, required=True, + help="Base folder where output/, scratch/, logs/ will be written.") + parser.add_argument("--o", dest="outputfolder", type=str, required=True, + help="Unique analysis name (used as BioHEL_).") + + # Dataset columns + parser.add_argument("--ol", dest="outcome_label", type=str, default="Class") + parser.add_argument("--il", dest="instanceID_label", type=str, default="InstanceID") + parser.add_argument("--el", dest="excluded_column", type=str, default="Group") + + # Experiment loop + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + parser.add_argument("--rs0", dest="seed_start", type=int, default=0, + help="Seed index start (default 0). Useful for partial runs.") + + # Binaries + parser.add_argument("--biohel_bin", dest="biohel_bin", type=str, default="./biohel", + help="BioHEL binary name or full path.") + parser.add_argument("--enable_rpe", dest="enable_rpe", action="store_true", + help="Enable BioHEL-RPE postprocessing stage.") + parser.add_argument("--postprocess_bin", dest="postprocess_bin", type=str, default="./postprocess", + help="RPE binary name (postprocess or postprocessing) or full path.") + parser.add_argument("--postprocess_conf", dest="postprocess_conf", type=str, default="postprocess.conf", + help="Path to RPE config file (e.g., test-pp.conf).") + + # HPC + parser.add_argument("--rc", dest="run_cluster", type=str, default="LSF", choices=["LSF", "SLURM"]) + parser.add_argument("--rm", dest="reserved_memory", type=int, default=4) + parser.add_argument("--q", dest="queue", type=str, default="i2c2_normal") + + # Check/resubmit + parser.add_argument("--check", dest="check", action="store_true", + help="If set: do not submit new jobs, only report missing folds (result_row.csv).") + parser.add_argument("--resub", dest="resubmit", action="store_true", + help="If set with --check: resubmit missing folds.") + + parser.add_argument("--v", dest="verbose", action="store_true") + + opts = parser.parse_args(argv[1:]) + + datafolder = Path(opts.datafolder) + writepath = Path(opts.writepath) + outputfolder = opts.outputfolder + + outcome_label = opts.outcome_label + instanceID_label = opts.instanceID_label + excluded_column = opts.excluded_column + + cv_partitions = int(opts.cv_partitions) + random_seeds = int(opts.random_seeds) + seed_start = int(opts.seed_start) + + biohel_bin = opts.biohel_bin + enable_rpe = bool(opts.enable_rpe) + postprocess_bin = opts.postprocess_bin + postprocess_conf = opts.postprocess_conf + + run_cluster = opts.run_cluster + reserved_memory = int(opts.reserved_memory) + queue = opts.queue + + check = bool(opts.check) + resubmit = bool(opts.resubmit) + verbose = bool(opts.verbose) + + algorithm = "BioHEL" + + # Folder management + writepath.mkdir(parents=True, exist_ok=True) + + base_output_root = writepath / "output" + base_output_root.mkdir(exist_ok=True) + + scratchPath = writepath / "scratch" + scratchPath.mkdir(exist_ok=True) + + logPath = writepath / "logs" + logPath.mkdir(exist_ok=True) + + base_output_path_0 = base_output_root / f"{algorithm}_{outputfolder}" + base_output_path_0.mkdir(exist_ok=True) + + # Loop and submit + jobCount = 0 + missing_count = 0 + + for entry in sorted(os.listdir(datafolder)): + dataset_dir = datafolder / entry + if not dataset_dir.is_dir(): + continue + + dataset_out_dir = base_output_path_0 / entry + dataset_out_dir.mkdir(exist_ok=True) + + # Submit for each seed and CV fold + for seed_idx in range(seed_start, random_seeds): + seed_out_dir = dataset_out_dir / f"seed_{seed_idx}" + seed_out_dir.mkdir(exist_ok=True) + + for cv_idx in range(1, cv_partitions + 1): + train_path = dataset_dir / f"{entry}_CV_Train_{cv_idx}.txt" + if not train_path.exists(): + # Skip silently if not a CV dataset folder + continue + + cv_out_dir = seed_out_dir / f"cv_{cv_idx}" + cv_out_dir.mkdir(exist_ok=True) + + sentinel = cv_out_dir / "result_row.csv" + + if check: + if not sentinel.exists(): + missing_count += 1 + print(f"Missing: {cv_out_dir}") + if resubmit: + _submit_one( + run_cluster=run_cluster, + scratchPath=scratchPath, + logPath=logPath, + reserved_memory=reserved_memory, + queue=queue, + job_label=f"{entry}_seed_{seed_idx}_cv_{cv_idx}", + train_path=str(train_path), + output_dir=str(cv_out_dir), + outcome_label=outcome_label, + instanceID_label=instanceID_label, + excluded_column=excluded_column, + seed=seed_idx, + biohel_bin=biohel_bin, + enable_rpe=enable_rpe, + postprocess_bin=postprocess_bin, + postprocess_conf=postprocess_conf, + verbose=verbose, + ) + jobCount += 1 + continue + + # Normal run: submit if not complete + if not sentinel.exists(): + _submit_one( + run_cluster=run_cluster, + scratchPath=scratchPath, + logPath=logPath, + reserved_memory=reserved_memory, + queue=queue, + job_label=f"{entry}_seed_{seed_idx}_cv_{cv_idx}", + train_path=str(train_path), + output_dir=str(cv_out_dir), + outcome_label=outcome_label, + instanceID_label=instanceID_label, + excluded_column=excluded_column, + seed=seed_idx, + biohel_bin=biohel_bin, + enable_rpe=enable_rpe, + postprocess_bin=postprocess_bin, + postprocess_conf=postprocess_conf, + verbose=verbose, + ) + jobCount += 1 + else: + if verbose: + print(f"Exists: {sentinel}") + + if check: + print(f"{missing_count} folds incomplete.") + if resubmit: + print(f"{jobCount} jobs resubmitted.") + else: + print(f"{jobCount} jobs submitted.") + + +def _submit_one( + run_cluster: str, + scratchPath: Path, + logPath: Path, + reserved_memory: int, + queue: str, + job_label: str, + train_path: str, + output_dir: str, + outcome_label: str, + instanceID_label: str, + excluded_column: str, + seed: int, + biohel_bin: str, + enable_rpe: bool, + postprocess_bin: str, + postprocess_conf: str, + verbose: bool, +): + job_ref = str(time.time()) + job_name = f"BIOHEL_{job_label}_{job_ref}" + job_path = scratchPath / f"{job_name}_run.sh" + + cmd = ( + f"python job_biohel_hpc.py" + f" --d {train_path}" + f" --o {output_dir}" + f" --biohel {biohel_bin}" + f" --ol {outcome_label}" + f" --il {instanceID_label}" + f" --el {excluded_column}" + f" --rs {seed}" + ) + + if enable_rpe: + cmd += ( + f" --enable_rpe" + f" --postprocess_bin {postprocess_bin}" + f" --postprocess_conf {postprocess_conf}" + ) + + if verbose: + cmd += " --v" + + with open(job_path, "w") as sh: + sh.write("#!/bin/bash\n") + if run_cluster == "LSF": + sh.write(f"#BSUB -q {queue}\n") + sh.write(f"#BSUB -J {job_name}\n") + sh.write(f'#BSUB -R "rusage[mem={reserved_memory}G]"\n') + sh.write(f"#BSUB -M {reserved_memory}GB\n") + sh.write(f"#BSUB -o {logPath}/{job_name}.o\n") + sh.write(f"#BSUB -e {logPath}/{job_name}.e\n") + sh.write(cmd + "\n") + else: + sh.write(f"#SBATCH -p {queue}\n") + sh.write(f"#SBATCH --job-name={job_name}\n") + sh.write(f"#SBATCH --mem={reserved_memory}G\n") + sh.write(f"#SBATCH -o {logPath}/{job_name}.o\n") + sh.write(f"#SBATCH -e {logPath}/{job_name}.e\n") + sh.write("srun " + cmd + "\n") + + if run_cluster == "LSF": + os.system(f"bsub < {job_path}") + else: + os.system(f"sbatch {job_path}") + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/run_biohel_sum_hpc.py b/evaluation/experiments/comparison_algs_scripts/run_biohel_sum_hpc.py new file mode 100644 index 0000000..0124907 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/run_biohel_sum_hpc.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import sys +import os +import time +import argparse + + +def main(argv): + parser = argparse.ArgumentParser(description="BioHEL summary submission (LSF/Slurm/Local)") + + # Script parameters + parser.add_argument("--w", dest="writepath", type=str, required=True, + help="Path where outputs/logs/scratch live") + parser.add_argument("--o", dest="outputfolder", type=str, required=True, + help="Unique folder name for this analysis") + + # Experiment parameters + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + + # HPC parameters + parser.add_argument("--rc", dest="run_cluster", type=str, default="LSF", + help="Cluster type: LSF, SLURM, or LOCAL") + parser.add_argument("--rm", dest="reserved_memory", type=int, default=4, + help="Reserved memory (GB)") + parser.add_argument("--q", dest="queue", type=str, default="i2c2_normal", + help="LSF queue or Slurm partition") + parser.add_argument("--python", dest="python_cmd", type=str, default="python", + help="Python executable") + parser.add_argument("--job", dest="job_script", type=str, default="job_biohel_sum_hpc.py", + help="Summary worker script") + + parser.add_argument("--plots", dest="plots", action="store_true", + help="Generate plots in summary") + + options = parser.parse_args(argv[1:]) + + writepath = options.writepath + outputfolder = options.outputfolder + cv_partitions = options.cv_partitions + random_seeds = options.random_seeds + + run_cluster = options.run_cluster.upper() + reserved_memory = options.reserved_memory + queue = options.queue + python_cmd = options.python_cmd + job_script = options.job_script + plots = options.plots + + algorithm = "BioHEL" + + # Folder management (mirror HEROS) + if not os.path.exists(writepath): + os.mkdir(writepath) + + base_output_path = os.path.join(writepath, "output") + if not os.path.exists(base_output_path): + os.mkdir(base_output_path) + + scratchPath = os.path.join(writepath, "scratch") + if not os.path.exists(scratchPath): + os.mkdir(scratchPath) + + logPath = os.path.join(writepath, "logs") + if not os.path.exists(logPath): + os.mkdir(logPath) + + base_output_path_0 = os.path.join(base_output_path, f"{algorithm}_{outputfolder}") + if not os.path.exists(base_output_path_0): + os.mkdir(base_output_path_0) + + if run_cluster == "LSF": + submit_lsf_cluster_job( + scratchPath, logPath, reserved_memory, queue, + base_output_path_0, cv_partitions, random_seeds, + outputfolder, python_cmd, job_script, plots + ) + elif run_cluster == "SLURM": + submit_slurm_cluster_job( + scratchPath, logPath, reserved_memory, queue, + base_output_path_0, cv_partitions, random_seeds, + outputfolder, python_cmd, job_script, plots + ) + elif run_cluster == "LOCAL": + cmd = ( + f"{python_cmd} {job_script}" + f" --o {base_output_path_0}" + f" --cv {cv_partitions}" + f" --r {random_seeds}" + + (" --plots" if plots else "") + ) + rc = os.system(cmd) + if rc != 0: + print("LOCAL summary failed.") + return 1 + else: + print("ERROR: Cluster type not found") + return 1 + + print("1 job submitted successfully") + return 0 + + +def submit_lsf_cluster_job( + scratchPath, logPath, reserved_memory, queue, + base_output_path_0, cv_partitions, random_seeds, + outputfolder, python_cmd, job_script, plots +): + job_ref = str(time.time()) + job_name = f"BIOHEL_summary_{outputfolder}_{job_ref}" + job_path = os.path.join(scratchPath, job_name + "_run.sh") + + with open(job_path, "w") as sh: + sh.write("#!/bin/bash\n") + sh.write("#BSUB -q " + queue + "\n") + sh.write("#BSUB -J " + job_name + "\n") + sh.write("#BSUB -n 1\n") + sh.write('#BSUB -R "rusage[mem=' + str(reserved_memory) + 'G]"\n') + sh.write("#BSUB -M " + str(reserved_memory) + "GB\n") + sh.write("#BSUB -o " + os.path.join(logPath, job_name) + ".o\n") + sh.write("#BSUB -e " + os.path.join(logPath, job_name) + ".e\n") + + cmd = ( + f"{python_cmd} {job_script}" + f" --o {base_output_path_0}" + f" --cv {cv_partitions}" + f" --r {random_seeds}" + + (" --plots" if plots else "") + ) + sh.write(cmd + "\n") + + os.system("bsub < " + job_path) + + +def submit_slurm_cluster_job( + scratchPath, logPath, reserved_memory, queue, + base_output_path_0, cv_partitions, random_seeds, + outputfolder, python_cmd, job_script, plots +): + job_ref = str(time.time()) + job_name = f"BIOHEL_summary_{outputfolder}_{job_ref}" + job_path = os.path.join(scratchPath, job_name + "_run.sh") + + with open(job_path, "w") as sh: + sh.write("#!/bin/bash\n") + sh.write("#SBATCH -p " + queue + "\n") + sh.write("#SBATCH --job-name=" + job_name + "\n") + sh.write("#SBATCH --mem=" + str(reserved_memory) + "G\n") + sh.write("#SBATCH -o " + os.path.join(logPath, job_name) + ".o\n") + sh.write("#SBATCH -e " + os.path.join(logPath, job_name) + ".e\n") + + cmd = ( + f"srun {python_cmd} {job_script}" + f" --o {base_output_path_0}" + f" --cv {cv_partitions}" + f" --r {random_seeds}" + + (" --plots" if plots else "") + ) + sh.write(cmd + "\n") + + os.system("sbatch " + job_path) + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/run_commands.txt b/evaluation/experiments/comparison_algs_scripts/run_commands.txt new file mode 100644 index 0000000..96c7d81 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/run_commands.txt @@ -0,0 +1,228 @@ +############################################################ +# SHARED: CREATE CV FOLDS (already same as HEROS) +############################################################ + +# GAMETES +python run_CV_Partitioner.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data \ + --w /project/kamoun_shared/data_shared/heros_sim_data \ + --o gametes_data_cv \ + --cv 10 \ + --l Class + +# MULTIPLEXER +python run_CV_Partitioner.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data \ + --w /project/kamoun_shared/data_shared/heros_sim_data \ + --o multiplexer_data_cv \ + --cv 10 \ + --l Class + + + +############################################################ +# BIOHEL PIPELINE +############################################################ + +# ------------------------------------------------------------ +# BioHEL single-fold debug run (no HPC) – Multiplexer example +# ------------------------------------------------------------ +python job_biohel_hpc.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv/A_multiplexer_6_bit_500_inst/A_multiplexer_6_bit_500_inst_CV_Train_1.txt \ + --o /project/kamoun_shared/output_shared/biohel_debug/A_multiplexer_6_bit_500_inst/seed_0/cv_1 \ + --ol Class \ + --il InstanceID \ + --el Group \ + --rs 0 \ + --enable_rpe \ + --v + + + +# ------------------------------------------------------------ +# BioHEL Training on HPC (LSF) – Multiplexer (seed × CV) +# ------------------------------------------------------------ +python run_biohel_hpc.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv \ + --w /project/kamoun_shared/output_shared/biohel_gecco \ + --o multiplexer_cv \ + --ol Class \ + --il InstanceID \ + --el Group \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --enable_rpe + + +# ------------------------------------------------------------ +# BioHEL Training on HPC (LSF) – GAMETES (seed × CV) +# ------------------------------------------------------------ +python run_biohel_hpc.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv \ + --w /project/kamoun_shared/output_shared/biohel_gecco \ + --o gametes_cv \ + --ol Class \ + --il InstanceID \ + --el Model \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --enable_rpe + + + +# ------------------------------------------------------------ +# BioHEL SUMMARY (one summary job) – Multiplexer +# ------------------------------------------------------------ +python run_biohel_sum_hpc.py \ + --w /project/kamoun_shared/output_shared/biohel_gecco \ + --o multiplexer_cv \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 + + +# ------------------------------------------------------------ +# BioHEL SUMMARY (one summary job) – GAMETES +# ------------------------------------------------------------ +python run_biohel_sum_hpc.py \ + --w /project/kamoun_shared/output_shared/biohel_gecco \ + --o gametes_cv \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 + + + +############################################################ +# RIPPER PIPELINE (wittgenstein) +############################################################ + +# ------------------------------------------------------------ +# RIPPER single-fold debug run (no HPC) – Multiplexer example +# ------------------------------------------------------------ +python job_ripper_hpc.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv/A_multiplexer_6_bit_500_inst/A_multiplexer_6_bit_500_inst_CV_Train_1.txt \ + --o /project/kamoun_shared/output_shared/ripper_debug/A_multiplexer_6_bit_500_inst/seed_0/cv_1 \ + --ol Class \ + --il InstanceID \ + --el Group \ + --rs 0 \ + --verbosity 0 \ + --v + + + +# ------------------------------------------------------------ +# RIPPER Training on HPC (LSF) – Multiplexer (seed × CV) +# ------------------------------------------------------------ +python run_ripper_hpc.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv \ + --w /project/kamoun_shared/output_shared/ripper_gecco \ + --o multiplexer_cv \ + --ol Class \ + --il InstanceID \ + --el Group \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --verbosity 0 + + +# ------------------------------------------------------------ +# RIPPER Training on HPC (LSF) – GAMETES (seed × CV) +# ------------------------------------------------------------ + +python run_ripper_hpc.py \ + --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv \ + --w /project/kamoun_shared/output_shared/ripper_gecco \ + --o gametes_cv \ + --ol Class \ + --il InstanceID \ + --el Model \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --verbosity 0 + + +# ------------------------------------------------------------ +# RIPPER SUMMARY (one summary job) – Multiplexer +# ------------------------------------------------------------ +python run_ripper_sum_hpc.py \ + --w /project/kamoun_shared/output_shared/ripper_gecco \ + --o multiplexer_cv \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --plots + + +# ------------------------------------------------------------ +# RIPPER SUMMARY (one summary job) – GAMETES +# ------------------------------------------------------------ +python run_ripper_sum_hpc.py \ + --w /project/kamoun_shared/output_shared/ripper_gecco \ + --o gametes_cv \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal \ + --cv 10 \ + --r 20 \ + --plots + + +############################################################ +# Final Paper Tables +############################################################ + +# For Primary Empherical Performance Tables +python job_sum_table_hpc.py \ + --biohel_root /project/kamoun_shared/output_shared/biohel_gecco \ + --ripper_root /project/kamoun_shared/output_shared/ripper_gecco \ + --out /project/kamoun_shared/output_shared/paper_tables + +# For Statistic Significance Test Tables +## Runs from HEROS has to be complete + +python stats_scripts/combine_heros_for_stats.py \ + --root /project/kamoun_shared/gabe/I2C2-Documentation/output \ + --outdir /project/kamoun_shared/output_shared/paper_tables \ + --outname combined_heros_cv_default_runs_long.csv + +python stats_scripts/job_statistical_test.py \ + --heros_csv /project/kamoun_shared/output_shared/paper_tables/combined_heros_cv_default_runs_long.csv \ + --other_csv /project/kamoun_shared/output_shared/paper_tables/combined_runs_long.csv \ + --outdir /project/kamoun_shared/output_shared/paper_tables \ + --prefix heros_baseline_wilcoxon \ + --alpha 0.05 + + +############################################################ +# OPTIONAL: CLEANUP (remove scratch scripts + logs) +############################################################ + +# BioHEL cleanup +python cleanup_hpc_artifacts.py \ + --w /project/kamoun_shared/output_shared/biohel_gecco \ + --yes + +# RIPPER cleanup +python cleanup_hpc_artifacts.py \ + --w /project/kamoun_shared/output_shared/ripper_gecco \ + --yes diff --git a/evaluation/experiments/comparison_algs_scripts/run_ripper_hpc.py b/evaluation/experiments/comparison_algs_scripts/run_ripper_hpc.py new file mode 100644 index 0000000..e6c3278 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/run_ripper_hpc.py @@ -0,0 +1,211 @@ +#!/usr/bin/env python3 +import sys +import os +import time +import argparse +from pathlib import Path + + +def main(argv): + parser = argparse.ArgumentParser(description="Submit RIPPER (wittgenstein) jobs across datasets × seeds × CV folds") + + # Paths + parser.add_argument("--d", dest="datafolder", type=str, required=True, + help="Path to data folder containing dataset subfolders.") + parser.add_argument("--w", dest="writepath", type=str, required=True, + help="Base folder where output/, scratch/, logs/ will be written.") + parser.add_argument("--o", dest="outputfolder", type=str, required=True, + help="Unique analysis name (used as RIPPER_).") + + # Dataset columns + parser.add_argument("--ol", dest="outcome_label", type=str, default="Class") + parser.add_argument("--il", dest="instanceID_label", type=str, default="InstanceID") + parser.add_argument("--el", dest="excluded_column", type=str, default="Group") + + # Experiment loop + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + parser.add_argument("--rs0", dest="seed_start", type=int, default=0) + + # RIPPER params (subset of common ones; extend as needed) + parser.add_argument("--max_rules", dest="max_rules", type=int, default=None, + help="Optional cap on number of rules.") + parser.add_argument("--verbosity", dest="ripper_verbosity", type=int, default=0, + help="wittgenstein verbosity (0 is quiet).") + + # HPC + parser.add_argument("--rc", dest="run_cluster", type=str, default="LSF", choices=["LSF", "SLURM"]) + parser.add_argument("--rm", dest="reserved_memory", type=int, default=4) + parser.add_argument("--q", dest="queue", type=str, default="i2c2_normal") + + # Check/resubmit + parser.add_argument("--check", dest="check", action="store_true") + parser.add_argument("--resub", dest="resubmit", action="store_true") + + parser.add_argument("--v", dest="verbose", action="store_true") + + opts = parser.parse_args(argv[1:]) + + datafolder = Path(opts.datafolder) + writepath = Path(opts.writepath) + outputfolder = opts.outputfolder + + outcome_label = opts.outcome_label + instanceID_label = opts.instanceID_label + excluded_column = opts.excluded_column + + cv_partitions = int(opts.cv_partitions) + random_seeds = int(opts.random_seeds) + seed_start = int(opts.seed_start) + + max_rules = opts.max_rules + ripper_verbosity = int(opts.ripper_verbosity) + + run_cluster = opts.run_cluster + reserved_memory = int(opts.reserved_memory) + queue = opts.queue + + check = bool(opts.check) + resubmit = bool(opts.resubmit) + verbose = bool(opts.verbose) + + algorithm = "RIPPER" + + # Folder management + writepath.mkdir(parents=True, exist_ok=True) + (writepath / "output").mkdir(exist_ok=True) + (writepath / "scratch").mkdir(exist_ok=True) + (writepath / "logs").mkdir(exist_ok=True) + + base_output_path_0 = writepath / "output" / f"{algorithm}_{outputfolder}" + base_output_path_0.mkdir(exist_ok=True) + + jobCount = 0 + missing_count = 0 + + for entry in sorted(os.listdir(datafolder)): + dataset_dir = datafolder / entry + if not dataset_dir.is_dir(): + continue + + dataset_out_dir = base_output_path_0 / entry + dataset_out_dir.mkdir(exist_ok=True) + + for seed_idx in range(seed_start, random_seeds): + seed_out_dir = dataset_out_dir / f"seed_{seed_idx}" + seed_out_dir.mkdir(exist_ok=True) + + for cv_idx in range(1, cv_partitions + 1): + train_path = dataset_dir / f"{entry}_CV_Train_{cv_idx}.txt" + if not train_path.exists(): + continue + + cv_out_dir = seed_out_dir / f"cv_{cv_idx}" + cv_out_dir.mkdir(exist_ok=True) + + sentinel = cv_out_dir / "result_row.csv" + + if check: + if not sentinel.exists(): + missing_count += 1 + print(f"Missing: {cv_out_dir}") + if resubmit: + _submit_one( + run_cluster, writepath, reserved_memory, queue, + job_label=f"{entry}_seed_{seed_idx}_cv_{cv_idx}", + train_path=str(train_path), + output_dir=str(cv_out_dir), + outcome_label=outcome_label, + instanceID_label=instanceID_label, + excluded_column=excluded_column, + seed=seed_idx, + max_rules=max_rules, + ripper_verbosity=ripper_verbosity, + verbose=verbose, + ) + jobCount += 1 + continue + + if not sentinel.exists(): + _submit_one( + run_cluster, writepath, reserved_memory, queue, + job_label=f"{entry}_seed_{seed_idx}_cv_{cv_idx}", + train_path=str(train_path), + output_dir=str(cv_out_dir), + outcome_label=outcome_label, + instanceID_label=instanceID_label, + excluded_column=excluded_column, + seed=seed_idx, + max_rules=max_rules, + ripper_verbosity=ripper_verbosity, + verbose=verbose, + ) + jobCount += 1 + else: + if verbose: + print(f"Exists: {sentinel}") + + if check: + print(f"{missing_count} folds incomplete.") + if resubmit: + print(f"{jobCount} jobs resubmitted.") + else: + print(f"{jobCount} jobs submitted.") + return 0 + + +def _submit_one(run_cluster, writepath: Path, reserved_memory: int, queue: str, + job_label: str, train_path: str, output_dir: str, + outcome_label: str, instanceID_label: str, excluded_column: str, + seed: int, max_rules, ripper_verbosity: int, verbose: bool): + + scratchPath = writepath / "scratch" + logPath = writepath / "logs" + job_ref = str(time.time()) + job_name = f"RIPPER_{job_label}_{job_ref}" + job_path = scratchPath / f"{job_name}_run.sh" + + cmd = ( + f"python job_ripper_hpc.py" + f" --d {train_path}" + f" --o {output_dir}" + f" --ol {outcome_label}" + f" --il {instanceID_label}" + f" --el {excluded_column}" + f" --rs {seed}" + f" --verbosity {ripper_verbosity}" + ) + if max_rules is not None: + cmd += f" --max_rules {int(max_rules)}" + if verbose: + cmd += " --v" + + with open(job_path, "w") as sh: + sh.write("#!/bin/bash\n") + if run_cluster == "LSF": + sh.write(f"#BSUB -q {queue}\n") + sh.write(f"#BSUB -J {job_name}\n") + sh.write("#BSUB -n 1\n") + sh.write(f'#BSUB -R "select[type==local] span[hosts=1] rusage[mem={reserved_memory}G]"\n') + # sh.write(f'#BSUB -R "span[hosts=1] rusage[mem={reserved_memory}G]"\n') + # sh.write(f'#BSUB -R "rusage[mem={reserved_memory}G]"\n') + sh.write(f"#BSUB -M {reserved_memory}GB\n") + sh.write(f"#BSUB -o {logPath}/{job_name}.o\n") + sh.write(f"#BSUB -e {logPath}/{job_name}.e\n") + sh.write(cmd + "\n") + else: + sh.write(f"#SBATCH -p {queue}\n") + sh.write(f"#SBATCH --job-name={job_name}\n") + sh.write(f"#SBATCH --mem={reserved_memory}G\n") + sh.write(f"#SBATCH -o {logPath}/{job_name}.o\n") + sh.write(f"#SBATCH -e {logPath}/{job_name}.e\n") + sh.write("srun " + cmd + "\n") + + if run_cluster == "LSF": + os.system(f"bsub < {job_path}") + else: + os.system(f"sbatch {job_path}") + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/run_ripper_sum_hpc.py b/evaluation/experiments/comparison_algs_scripts/run_ripper_sum_hpc.py new file mode 100644 index 0000000..e7f4b57 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/run_ripper_sum_hpc.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python3 +import sys +import os +import time +import argparse +from pathlib import Path + + +def main(argv): + parser = argparse.ArgumentParser(description="Submit RIPPER summary job (HEROS-like outputs)") + + parser.add_argument("--w", dest="writepath", type=str, required=True) + parser.add_argument("--o", dest="outputfolder", type=str, required=True) + + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + + parser.add_argument("--rc", dest="run_cluster", type=str, default="LSF", choices=["LSF", "SLURM"]) + parser.add_argument("--rm", dest="reserved_memory", type=int, default=1) + parser.add_argument("--q", dest="queue", type=str, default="i2c2_normal") + + parser.add_argument("--plots", dest="plots", action="store_true", + help="Generate boxplots (testing accuracy, rule count, coverage).") + + opts = parser.parse_args(argv[1:]) + + writepath = Path(opts.writepath) + outputfolder = opts.outputfolder + + cv_partitions = int(opts.cv_partitions) + random_seeds = int(opts.random_seeds) + + run_cluster = opts.run_cluster + reserved_memory = int(opts.reserved_memory) + queue = opts.queue + plots = bool(opts.plots) + + algorithm = "RIPPER" + + base_output_path_0 = writepath / "output" / f"{algorithm}_{outputfolder}" + if not base_output_path_0.exists(): + raise FileNotFoundError(f"Expected output folder not found: {base_output_path_0}") + + scratchPath = writepath / "scratch" + scratchPath.mkdir(parents=True, exist_ok=True) + + logPath = writepath / "logs" + logPath.mkdir(parents=True, exist_ok=True) + + job_ref = str(time.time()) + job_name = f"RIPPER_summary_{outputfolder}_{job_ref}" + job_path = scratchPath / f"{job_name}_run.sh" + + cmd = ( + f"python job_ripper_sum_hpc.py" + f" --o {base_output_path_0}" + f" --cv {cv_partitions}" + f" --r {random_seeds}" + ) + if plots: + cmd += " --plots" + + with open(job_path, "w") as sh: + sh.write("#!/bin/bash\n") + if run_cluster == "LSF": + sh.write(f"#BSUB -q {queue}\n") + sh.write(f"#BSUB -J {job_name}\n") + sh.write(f'#BSUB -R "rusage[mem={reserved_memory}G]"\n') + sh.write(f"#BSUB -M {reserved_memory}GB\n") + sh.write(f"#BSUB -o {logPath}/{job_name}.o\n") + sh.write(f"#BSUB -e {logPath}/{job_name}.e\n") + sh.write(cmd + "\n") + else: + sh.write(f"#SBATCH -p {queue}\n") + sh.write(f"#SBATCH --job-name={job_name}\n") + sh.write(f"#SBATCH --mem={reserved_memory}G\n") + sh.write(f"#SBATCH -o {logPath}/{job_name}.o\n") + sh.write(f"#SBATCH -e {logPath}/{job_name}.e\n") + sh.write("srun " + cmd + "\n") + + if run_cluster == "LSF": + os.system(f"bsub < {job_path}") + else: + os.system(f"sbatch {job_path}") + + print("1 job submitted successfully") + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/comparison_algs_scripts/stats_scripts/combine_heros_for_stats.py b/evaluation/experiments/comparison_algs_scripts/stats_scripts/combine_heros_for_stats.py new file mode 100644 index 0000000..bb07680 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/stats_scripts/combine_heros_for_stats.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +from pathlib import Path +import sys + +import numpy as np +import pandas as pd + + +DEFAULT_ROOT = Path("/project/kamoun_shared/gabe/I2C2-Documentation/output") +DEFAULT_OUTDIR = Path("/project/kamoun_shared/output_shared/paper_tables") +DEFAULT_OUTNAME = "combined_heros_cv_default_runs_long.csv" + + +def is_cv_default(path: Path) -> bool: + """ + Keep ONLY cv_default runs. + Exclude cv_equal, tree_init, fb_tree_init, etc. + """ + p = str(path) + return ("cv_default" in p) and ("cv_equal" not in p) and ("tree_init" not in p) + + +def parse_metadata(csv_path: Path) -> dict: + """ + Extract metadata from directory structure: + .../HEROS_mux_cv_default/A_multiplexer_6_bit_500_inst/all_default_model_200_evaluations.csv + """ + dataset_dir = csv_path.parent.name # A_multiplexer_6_bit_500_inst + run_group_dir = csv_path.parent.parent.name # HEROS_mux_cv_default + + alg = "HEROS" + sim = "MUX" if "mux" in run_group_dir.lower() else "GAMETES" + cv_scheme = "cv_default" + rep = dataset_dir.split("_")[0] # A / B / C / ... + + return { + "AlgorithmFamily": alg, + "Simulation": sim, + "CVScheme": cv_scheme, + "Dataset": dataset_dir, + "SimulationRep": rep, + "Scenario": "default_model", + } + + +def combine_cv_default_runs(root: Path) -> pd.DataFrame: + csvs = [p for p in root.rglob("all_default_model_200_evaluations.csv") if is_cv_default(p)] + if not csvs: + raise RuntimeError( + f"No cv_default evaluation files found under: {root}\n" + "Expected files named: all_default_model_200_evaluations.csv" + ) + + frames: list[pd.DataFrame] = [] + for csv_path in sorted(csvs): + meta = parse_metadata(csv_path) + df = pd.read_csv(csv_path) + + # Insert identifiers up front + df.insert(0, "_source_csv", str(csv_path)) + for k, v in meta.items(): + df.insert(0, k, v) + + # Seed surrogate (row index) to mirror long-runs-style outputs + df.insert(0, "seed", np.arange(len(df), dtype=int)) + + # Normalize columns to long-runs style (best-effort) + if "run_time" in df.columns: + df["runtime"] = df["run_time"] + df["final_runtime"] = df["run_time"] + df["run_time_minutes"] = df["run_time"] / 60.0 + else: + df["runtime"] = np.nan + df["final_runtime"] = np.nan + df["run_time_minutes"] = np.nan + + if "test_balanced_accuracy" in df.columns: + df["test_accuracy"] = df["test_balanced_accuracy"] + + frames.append(df) + + combined = pd.concat(frames, ignore_index=True, sort=False) + return combined + + +def build_argparser() -> argparse.ArgumentParser: + p = argparse.ArgumentParser( + description=( + "Recursively combine HEROS cv_default evaluation CSVs named " + "'all_default_model_200_evaluations.csv' into a single long-runs-style CSV." + ) + ) + p.add_argument( + "--root", + type=Path, + default=DEFAULT_ROOT, + help=f"Root directory to search recursively (default: {DEFAULT_ROOT})", + ) + p.add_argument( + "--outdir", + type=Path, + default=DEFAULT_OUTDIR, + help=f"Output directory (default: {DEFAULT_OUTDIR})", + ) + p.add_argument( + "--outname", + type=str, + default=DEFAULT_OUTNAME, + help=f"Output CSV filename (default: {DEFAULT_OUTNAME})", + ) + p.add_argument( + "--dry-run", + action="store_true", + help="Do not write output; only print discovered file count and sample paths.", + ) + return p + + +def main(argv: list[str]) -> int: + args = build_argparser().parse_args(argv) + + root: Path = args.root + outdir: Path = args.outdir + outpath: Path = outdir / args.outname + + # Find first (for dry-run info too) + csvs = [p for p in root.rglob("all_default_model_200_evaluations.csv") if is_cv_default(p)] + if not csvs: + print( + f"ERROR: No cv_default evaluation files found under: {root}\n" + "Expected files named: all_default_model_200_evaluations.csv", + file=sys.stderr, + ) + return 2 + + print(f"Found {len(csvs)} cv_default files under: {root}") + for pth in sorted(csvs)[:5]: + print(f" - {pth}") + if len(csvs) > 5: + print(" ...") + + if args.dry_run: + print("Dry-run enabled; not writing output.") + return 0 + + combined = combine_cv_default_runs(root) + + outdir.mkdir(parents=True, exist_ok=True) + combined.to_csv(outpath, index=False) + + print(f"Wrote: {outpath}") + print(f"Rows: {combined.shape[0]} | Cols: {combined.shape[1]}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/evaluation/experiments/comparison_algs_scripts/stats_scripts/job_statistical_test.py b/evaluation/experiments/comparison_algs_scripts/stats_scripts/job_statistical_test.py new file mode 100644 index 0000000..0defc01 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/stats_scripts/job_statistical_test.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import sys +import argparse +import re +from pathlib import Path +from typing import List, Dict, Optional, Tuple + +import numpy as np +import pandas as pd +from scipy import stats +from statsmodels.stats.multitest import multipletests + + +DEFAULT_HEROS_CSV = "/project/kamoun_shared/output_shared/paper_tables/combined_heros_cv_default_runs_long.csv" +DEFAULT_OTHER_CSV = "/project/kamoun_shared/output_shared/paper_tables/combined_runs_long.csv" +DEFAULT_OUTDIR = "/project/kamoun_shared/output_shared/paper_tables" +DEFAULT_PREFIX = "heros_baseline_wilcoxon" + +# Only test these metrics (exact list requested) +METRICS = ["test_balanced_accuracy", "test_coverage", "rule_count", "run_time"] + +# Comparators (AlgorithmFamily, Scenario) in combined_runs_long.csv +COMPARATORS = [ + ("RIPPER", "RIPPER"), + ("BioHEL", "BioHEL_noRPE"), + ("BioHEL", "BioHEL_RPE"), +] + + +def mann_whitney_two_sided(x: np.ndarray, y: np.ndarray) -> Tuple[float, float]: + """Wilcoxon rank-sum equivalent for independent samples (Mann–Whitney U), two-sided.""" + res = stats.mannwhitneyu(x, y, alternative="two-sided", method="auto") + return float(res.statistic), float(res.pvalue) + + +def extract_numeric(series: pd.Series) -> np.ndarray: + x = pd.to_numeric(series, errors="coerce").to_numpy(dtype=float) + x = x[np.isfinite(x)] + return x + + +def choose_dataset_col(heros: pd.DataFrame, other: pd.DataFrame) -> str: + if "Dataset" in heros.columns and "Dataset" in other.columns: + return "Dataset" + if "dataset" in heros.columns and "dataset" in other.columns: + return "dataset" + raise ValueError("Expected a shared dataset identifier column ('Dataset' or 'dataset').") + + +def metric_column_mapping(df: pd.DataFrame) -> Dict[str, Optional[str]]: + """ + Map requested metrics to available columns. + We still ONLY TEST the requested METRICS. + """ + m: Dict[str, Optional[str]] = {} + + # Balanced accuracy + if "test_balanced_accuracy" in df.columns: + m["test_balanced_accuracy"] = "test_balanced_accuracy" + elif "test_accuracy" in df.columns: + # common in combined_runs_long + m["test_balanced_accuracy"] = "test_accuracy" + else: + m["test_balanced_accuracy"] = None + + m["test_coverage"] = "test_coverage" if "test_coverage" in df.columns else None + m["rule_count"] = "rule_count" if "rule_count" in df.columns else None + + # Runtime + if "run_time" in df.columns: + m["run_time"] = "run_time" + elif "runtime" in df.columns: + m["run_time"] = "runtime" + elif "final_runtime" in df.columns: + m["run_time"] = "final_runtime" + else: + m["run_time"] = None + + return m + + +def dataset_type(ds: str) -> str: + s = str(ds).upper() + if "MULTIPLEXER" in s: + return "MUX" + return "GAMETES" + + +def dataset_rep(ds: str) -> str: + """ + Extract A/B/C replicate for sorting. + Handles: MUX_A_..., GAMETES_B_... + """ + s = str(ds).upper() + s = s.split("_")[0] + return s + + +def rep_sort_key(rep: str) -> int: + if isinstance(rep, str) and rep and rep[0].isalpha(): + return ord(rep[0].upper()) + return 999 + + +def run_tests_and_build_wide( + heros_csv: Path, + other_csv: Path, + alpha: float, +) -> Tuple[pd.DataFrame, pd.DataFrame]: + """ + Returns: + long_df: one row per dataset × comparator × metric with p, fdr, direction + wide_df: one row per dataset × comparator, metric results spread into columns + """ + heros = pd.read_csv(heros_csv) + other = pd.read_csv(other_csv) + + dscol = choose_dataset_col(heros, other) + + # Baseline HEROS rows + if "AlgorithmFamily" in heros.columns: + heros_base = heros[heros["AlgorithmFamily"].astype(str).str.upper() == "HEROS"].copy() + else: + heros_base = heros.copy() + + map_heros = metric_column_mapping(heros_base) + map_other = metric_column_mapping(other) + + metrics_to_test = [m for m in METRICS if map_heros.get(m) and map_other.get(m)] + if not metrics_to_test: + raise RuntimeError( + "None of the requested metrics could be mapped in both inputs.\n" + f"Requested: {METRICS}\n" + f"HEROS mapping: {map_heros}\n" + f"OTHER mapping: {map_other}" + ) + + # Dataset overlap + ds_common = sorted(set(heros_base[dscol].dropna().unique()) & set(other[dscol].dropna().unique())) + if not ds_common: + raise RuntimeError(f"No overlapping datasets found between files using column '{dscol}'.") + + rows = [] + for ds in ds_common: + base_ds = heros_base[heros_base[dscol] == ds] + if base_ds.empty: + continue + + for alg, scen in COMPARATORS: + comp_ds = other[ + (other["AlgorithmFamily"].astype(str) == alg) + & (other["Scenario"].astype(str) == scen) + & (other[dscol] == ds) + ] + if comp_ds.empty: + continue + + for metric in metrics_to_test: + bcol = map_heros[metric] + ccol = map_other[metric] + assert bcol and ccol + + base_vals = extract_numeric(base_ds[bcol]) + comp_vals = extract_numeric(comp_ds[ccol]) + + if base_vals.size < 2 or comp_vals.size < 2: + continue + + _, p_val = mann_whitney_two_sided(base_vals, comp_vals) + + base_med = float(np.median(base_vals)) + comp_med = float(np.median(comp_vals)) + diff = comp_med - base_med + direction = ( + "Comparator higher" if diff > 0 else + "Comparator lower" if diff < 0 else + "Tie (median)" + ) + + rows.append({ + "Dataset": ds, + "DatasetType": dataset_type(ds), + "Rep": dataset_rep(ds), + "BaselineAlgorithm": "HEROS", + "BaselineScenario": "default_model", + "ComparatorAlgorithm": alg, + "ComparatorScenario": scen, + "Metric": metric, + "p_value": float(p_val), + "direction": direction, + }) + + long_df = pd.DataFrame(rows) + if long_df.empty: + raise RuntimeError("No tests were run; check filters, dataset overlap, and metric mappings.") + + # FDR across ALL tests (dataset×comparator×metric) + rej, p_adj, _, _ = multipletests(long_df["p_value"].to_numpy(), alpha=alpha, method="fdr_bh") + long_df["p_value_fdr_bh"] = p_adj + long_df["significant"] = rej + + # Build wide by columns per metric (p, fdr, dir), with Algorithm+Scenario as columns (per row) + wide = long_df.pivot_table( + index=[ + "Dataset", "DatasetType", "Rep", + "ComparatorAlgorithm", "ComparatorScenario", + ], + columns="Metric", + values=["p_value", "p_value_fdr_bh", "direction", "significant"], + aggfunc="first", + ) + + # Flatten columns: (stat, metric) -> f"{metric}__{stat}" + wide.columns = [f"{metric}__{stat}" for stat, metric in wide.columns] + wide = wide.reset_index() + + return long_df, wide + + +def keep_only_significant_metric_columns(wide: pd.DataFrame) -> pd.DataFrame: + """ + Keep only metric column-groups (for each metric: p, fdr, dir) that are ever significant + in ANY row, based on the corresponding metric__significant column. + Always keep identifier columns. + """ + id_cols = ["Dataset", "DatasetType", "Rep", "ComparatorAlgorithm", "ComparatorScenario"] + + # Determine which metrics are ever significant + keep_metrics: List[str] = [] + for m in METRICS: + sig_col = f"{m}__significant" + if sig_col in wide.columns and bool(wide[sig_col].fillna(False).any()): + keep_metrics.append(m) + + # Build final column list: per metric keep only p, fdr, dir (not the boolean) + keep_cols = id_cols[:] + for m in keep_metrics: + for suffix in ["p_value", "p_value_fdr_bh", "direction"]: + c = f"{m}__{suffix}" + if c in wide.columns: + keep_cols.append(c) + + out = wide[keep_cols].copy() + return out + + +def sort_output(df: pd.DataFrame) -> pd.DataFrame: + """ + Sort by dataset type (MUX then GAMETES), then A/B/C, then algorithm (and scenario), then dataset string. + """ + type_order = {"MUX": 0, "GAMETES": 1, "OTHER": 99} + df = df.copy() + df["_type_sort"] = df["DatasetType"].map(lambda x: type_order.get(str(x), 99)) + df["_rep_sort"] = df["Rep"].map(rep_sort_key) + df = df.sort_values( + by=["_type_sort", "_rep_sort", "ComparatorAlgorithm", "ComparatorScenario", "Dataset"], + kind="mergesort", + ).drop(columns=["_type_sort", "_rep_sort"]) + return df + + +def write_outputs( + df_all: pd.DataFrame, + outdir: Path, + prefix: str, +) -> Tuple[Path, Path, Path]: + outdir.mkdir(parents=True, exist_ok=True) + + all_path = outdir / f"{prefix}_significant_only_all.csv" + mux_path = outdir / f"{prefix}_significant_only_mux.csv" + gam_path = outdir / f"{prefix}_significant_only_gametes.csv" + + df_all.to_csv(all_path, index=False) + df_all[df_all["DatasetType"] == "MUX"].to_csv(mux_path, index=False) + df_all[df_all["DatasetType"] == "GAMETES"].to_csv(gam_path, index=False) + + return all_path, mux_path, gam_path + + +def build_argparser() -> argparse.ArgumentParser: + p = argparse.ArgumentParser( + description=( + "Wilcoxon rank-sum (Mann–Whitney U) per-dataset tests using HEROS as baseline.\n" + "Outputs WIDE tables with Algorithm+Scenario as key columns, and metrics as column groups.\n" + "Keeps ONLY metric column groups that are significant (FDR-BH) anywhere.\n" + "Also writes MUX-only and GAMETES-only subsets." + ) + ) + p.add_argument("--heros_csv", type=Path, default=Path(DEFAULT_HEROS_CSV), help="HEROS combined CSV") + p.add_argument("--other_csv", type=Path, default=Path(DEFAULT_OTHER_CSV), help="Other algorithms combined CSV") + p.add_argument("--outdir", type=Path, default=Path(DEFAULT_OUTDIR), help=f"Output directory (default: {DEFAULT_OUTDIR})") + p.add_argument("--prefix", type=str, default=DEFAULT_PREFIX, help="Filename prefix for outputs") + p.add_argument("--alpha", type=float, default=0.05, help="Alpha for FDR-BH significance (default: 0.05)") + return p + + +def main(argv: List[str]) -> int: + args = build_argparser().parse_args(argv) + + _, wide = run_tests_and_build_wide( + heros_csv=args.heros_csv, + other_csv=args.other_csv, + alpha=args.alpha, + ) + + wide_sig_only = keep_only_significant_metric_columns(wide) + wide_sig_only = sort_output(wide_sig_only) + + all_path, mux_path, gam_path = write_outputs(wide_sig_only, args.outdir, args.prefix) + + print(f"Wrote:\n {all_path}\n {mux_path}\n {gam_path}") + print(f"Rows (all): {wide_sig_only.shape[0]} | Cols: {wide_sig_only.shape[1]}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/evaluation/experiments/comparison_algs_scripts/stats_scripts/job_statistical_test_old.py b/evaluation/experiments/comparison_algs_scripts/stats_scripts/job_statistical_test_old.py new file mode 100644 index 0000000..4dccce6 --- /dev/null +++ b/evaluation/experiments/comparison_algs_scripts/stats_scripts/job_statistical_test_old.py @@ -0,0 +1,263 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import sys +import argparse +from pathlib import Path +from typing import Iterable, Optional, Tuple, List, Dict + +import numpy as np +import pandas as pd +from scipy import stats +from statsmodels.stats.multitest import multipletests + + +DEFAULT_HEROS_CSV = "/project/kamoun_shared/output_shared/paper_tables/combined_heros_cv_default_runs_long.csv" +DEFAULT_OTHER_CSV = "/project/kamoun_shared/output_shared/paper_tables/combined_runs_long.csv" +DEFAULT_OUT = "/project/kamoun_shared/output_shared/paper_tables/heros_baseline_wilcoxon_ranksum_by_dataset.csv" + +# Only test these metrics (as requested) +METRICS = ["test_balanced_accuracy", "test_coverage", "rule_count", "run_time"] + + +def cliffs_delta(baseline: np.ndarray, comparator: np.ndarray) -> float: + """ + Cliff's delta for comparator vs baseline. + Positive => comparator tends to be larger than baseline. + """ + baseline = baseline.astype(float) + comparator = comparator.astype(float) + + # O(n*m) exact computation; fine for typical eval sizes (e.g., 200 vs 200). + diffs = comparator[:, None] - baseline[None, :] + gt = np.sum(diffs > 0) + lt = np.sum(diffs < 0) + return float((gt - lt) / (len(baseline) * len(comparator))) + + +def mann_whitney_two_sided(x: np.ndarray, y: np.ndarray) -> Tuple[float, float]: + """ + Mann-Whitney U test, two-sided. + SciPy calls this MannWhitneyU; it's equivalent to Wilcoxon rank-sum for independent samples. + Returns (U, p). + """ + res = stats.mannwhitneyu(x, y, alternative="two-sided", method="auto") + return float(res.statistic), float(res.pvalue) + + +def choose_dataset_key(heros: pd.DataFrame, other: pd.DataFrame) -> str: + """ + Prefer "Dataset" if it intersects; otherwise fall back to "dataset" if present. + """ + if "Dataset" in heros.columns and "Dataset" in other.columns: + return "Dataset" + if "dataset" in heros.columns and "dataset" in other.columns: + return "dataset" + raise ValueError("Could not find a shared dataset identifier column (expected 'Dataset' or 'dataset').") + + +def metric_column_mapping(df: pd.DataFrame) -> Dict[str, Optional[str]]: + """ + Map requested metric names to actual columns present. + We *only* compute tests for metrics we can locate. + + - test_balanced_accuracy: + - if present, use directly + - else fall back to test_accuracy if present (common in combined_runs_long) + - test_coverage: must exist + - rule_count: must exist + - run_time: + - prefer run_time + - else fall back to runtime / final_runtime + """ + mapping: Dict[str, Optional[str]] = {} + + # balanced accuracy + if "test_balanced_accuracy" in df.columns: + mapping["test_balanced_accuracy"] = "test_balanced_accuracy" + elif "test_accuracy" in df.columns: + mapping["test_balanced_accuracy"] = "test_accuracy" + else: + mapping["test_balanced_accuracy"] = None + + mapping["test_coverage"] = "test_coverage" if "test_coverage" in df.columns else None + mapping["rule_count"] = "rule_count" if "rule_count" in df.columns else None + + # runtime naming + if "run_time" in df.columns: + mapping["run_time"] = "run_time" + elif "runtime" in df.columns: + mapping["run_time"] = "runtime" + elif "final_runtime" in df.columns: + mapping["run_time"] = "final_runtime" + else: + mapping["run_time"] = None + + return mapping + + +def extract_numeric(series: pd.Series) -> np.ndarray: + """ + Extract numeric values safely, dropping NaNs and non-finite values. + """ + x = pd.to_numeric(series, errors="coerce").to_numpy(dtype=float) + x = x[np.isfinite(x)] + return x + + +def run_tests( + heros_csv: Path, + other_csv: Path, + out_csv: Path, + alpha: float = 0.05, +) -> pd.DataFrame: + heros = pd.read_csv(heros_csv) + other = pd.read_csv(other_csv) + + dataset_col = choose_dataset_key(heros, other) + + # Baseline filter: HEROS in the HEROS file (it’s already standardized in your combined_heros... output) + if "AlgorithmFamily" in heros.columns: + heros_base = heros[heros["AlgorithmFamily"].astype(str).str.upper() == "HEROS"].copy() + else: + heros_base = heros.copy() + + # Comparators in combined_runs_long.csv + # Adjust these if your "other" file uses different labels. + comparators = [ + ("RIPPER", "RIPPER"), + ("BioHEL", "BioHEL_noRPE"), + ("BioHEL", "BioHEL_RPE"), + ] + + # Determine which actual columns to use for each requested metric in each df + map_heros = metric_column_mapping(heros_base) + map_other = metric_column_mapping(other) + + # We will only test metrics resolvable in BOTH dataframes + metrics_to_test: List[str] = [] + for m in METRICS: + if map_heros.get(m) is not None and map_other.get(m) is not None: + metrics_to_test.append(m) + + if not metrics_to_test: + raise RuntimeError( + "None of the requested metrics could be mapped in both files.\n" + f"Requested: {METRICS}\n" + f"HEROS mapping: {map_heros}\n" + f"OTHER mapping: {map_other}" + ) + + # Use datasets present in both files (intersection) + ds_common = sorted(set(heros_base[dataset_col].dropna().unique()) & set(other[dataset_col].dropna().unique())) + if not ds_common: + raise RuntimeError(f"No overlapping datasets found between files using column '{dataset_col}'.") + + rows = [] + for ds in ds_common: + base_ds = heros_base[heros_base[dataset_col] == ds] + + for alg, scen in comparators: + comp_ds = other[ + (other["AlgorithmFamily"].astype(str) == alg) + & (other["Scenario"].astype(str) == scen) + & (other[dataset_col] == ds) + ] + + if comp_ds.empty or base_ds.empty: + continue + + for metric in metrics_to_test: + bcol = map_heros[metric] + ccol = map_other[metric] + assert bcol is not None and ccol is not None + + base_vals = extract_numeric(base_ds[bcol]) + comp_vals = extract_numeric(comp_ds[ccol]) + + # Need at least 2 observations each for a meaningful rank-sum test + if base_vals.size < 2 or comp_vals.size < 2: + continue + + u_stat, p_val = mann_whitney_two_sided(base_vals, comp_vals) + + base_med = float(np.median(base_vals)) + comp_med = float(np.median(comp_vals)) + med_diff = comp_med - base_med + + # Note: “better” depends on the metric. We only record direction; interpret accordingly. + rows.append( + { + "Dataset": ds, + "Metric": metric, + "Baseline": "HEROS_default_model", + "ComparatorAlgorithm": alg, + "ComparatorScenario": scen, + # "n_baseline": int(base_vals.size), + # "n_comp": int(comp_vals.size), + "baseline_median": base_med, + "comp_median": comp_med, + "median_diff_comp_minus_base": float(med_diff), + # "cliffs_delta_comp_vs_base": float(cliffs_delta(base_vals, comp_vals)), + "u_statistic": u_stat, + "p_value": p_val, + } + ) + + results = pd.DataFrame(rows) + if results.empty: + raise RuntimeError("No tests were run (empty results). Check filters, dataset overlap, and metric mappings.") + + # Multiple-testing correction across ALL dataset×comparator×metric tests + rej, p_adj, _, _ = multipletests(results["p_value"].to_numpy(), alpha=alpha, method="fdr_bh") + results["p_value_fdr_bh"] = p_adj + results[f"significant_fdr_bh_alpha_{alpha:g}"] = rej + + results["direction_by_median"] = np.where( + results["median_diff_comp_minus_base"] > 0, + "Comparator higher", + np.where(results["median_diff_comp_minus_base"] < 0, "Comparator lower", "Tie (median)"), + ) + + # Stable sorting for readability + results = results.sort_values( + ["Metric", "ComparatorAlgorithm", "ComparatorScenario", "Dataset"], + kind="mergesort", + ).reset_index(drop=True) + + out_csv.parent.mkdir(parents=True, exist_ok=True) + results.to_csv(out_csv, index=False) + return results + + +def build_argparser() -> argparse.ArgumentParser: + p = argparse.ArgumentParser( + description=( + "Wilcoxon rank-sum (Mann–Whitney U) significance testing per dataset, " + "using HEROS as baseline and comparing RIPPER/BioHEL scenarios.\n" + "Only tests metrics: test_balanced_accuracy, test_coverage, rule_count, run_time." + ) + ) + p.add_argument("--heros_csv", type=Path, default=Path(DEFAULT_HEROS_CSV), help="HEROS combined runs long CSV") + p.add_argument("--other_csv", type=Path, default=Path(DEFAULT_OTHER_CSV), help="Combined runs long CSV (RIPPER/BioHEL)") + p.add_argument("--out_csv", type=Path, default=Path(DEFAULT_OUT), help="Output CSV path") + p.add_argument("--alpha", type=float, default=0.05, help="Alpha for FDR-BH significance flag (default: 0.05)") + return p + + +def main(argv: List[str]) -> int: + args = build_argparser().parse_args(argv) + res = run_tests( + heros_csv=args.heros_csv, + other_csv=args.other_csv, + out_csv=args.out_csv, + alpha=args.alpha, + ) + print(f"Wrote: {args.out_csv}") + print(f"Rows: {res.shape[0]} | Cols: {res.shape[1]}") + print(f"Metrics tested (effective): {sorted(res['Metric'].unique().tolist())}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main(sys.argv[1:])) diff --git a/evaluation/experiments/job_heros_hpc.py b/evaluation/experiments/heros_scripts/job_heros.py similarity index 72% rename from evaluation/experiments/job_heros_hpc.py rename to evaluation/experiments/heros_scripts/job_heros.py index 93c27f4..4a84631 100644 --- a/evaluation/experiments/job_heros_hpc.py +++ b/evaluation/experiments/heros_scripts/job_heros.py @@ -1,15 +1,18 @@ import os -import sys +import sys import argparse import pickle import pandas as pd import numpy as np +import matplotlib +matplotlib.use("Agg") import matplotlib.pyplot as plt from sklearn.metrics import confusion_matrix -sys.path.append('/project/kamoun_shared/code_shared/scikit-heros/') +#UPDATE Path below as needed!!! +sys.path.append('/project/kamoun_shared/output_shared/heros_v0.3_dev/heros/src') #sys.path.append('/project/kamoun_shared/code_shared/new_heros/scikit-heros/') -from src.skheros.heros import HEROS -#from skheros.heros import HEROS #PIP INSTALL RUN +#from src.skheros.heros import HEROS +from skheros.heros import HEROS #PIP INSTALL RUN def main(argv): #ARGUMENTS:------------------------------------------------------------------------------------ @@ -23,7 +26,13 @@ def main(argv): parser.add_argument('--il', dest='instanceID_label', help='label of instance ID column (if present)', type=str, default = 'InstanceID') parser.add_argument('--el', dest='excluded_column', help='label of another column to drop (if present)', type=str, default = 'Group') #Experiment Parameters - parser.add_argument('--in', dest='model_pop_init', help='model population initialization method (Must be random, probabilistic, bootstrap, or target_acc)', type=str, default='random') + parser.add_argument('--pt', dest='rule_pop_init', help='type of population initialization (load, dt, dt_bstrap, or None)', type=str, default='None') + parser.add_argument('--a', dest='alternate', help='phase alternations', type = int, default = 0) + parser.add_argument('--m', dest='alternate_mode', help='alternation mode (Must be "limit", "converge", "equal", or None)', type = str, default='None') + #Unused Experimental + parser.add_argument('--fb', dest='feedback', action='store_true', help='use alternation weights') + #Critical HEROS Parameters + #Critical HEROS Parameters parser.add_argument('--ot', dest='outcome_type', help='outcome type', type=str, default='class') parser.add_argument('--it', dest='iterations', help='number of rule training cycles', type=int, default=100000) @@ -31,6 +40,7 @@ def main(argv): parser.add_argument('--nu', dest='nu', help='power parameter', type=int, default=1) parser.add_argument('--mi', dest='model_iterations', help='number of model training cycles', type=int, default=500) parser.add_argument('--ms', dest='model_pop_size', help='maximum model population size ', type=int, default=100) + parser.add_argument('--in', dest='model_pop_init', help='model population initialization method (Must be random, probabilistic, bootstrap, or target_acc)', type=str, default='random') #Other HEROS Parameters parser.add_argument('--cp', dest='cross_prob', help='probability of applying crossover in rule discovery', type=float, default=0.8) parser.add_argument('--mp', dest='mut_prob', help='probability of applying mutation in rule discovery', type=float, default=0.04) @@ -42,13 +52,13 @@ def main(argv): parser.add_argument('--ft', dest='feat_track', help='feature tracking mechanism', type=str, default='None') parser.add_argument('--ng', dest='new_gen', help='proportion of max model population size', type=float, default=1.0) parser.add_argument('--mg', dest='merge_prob', help='probability of applying merge in model discovery', type=float, default=0.1) - parser.add_argument('--pt', dest='rule_pop_init', help='type of population initialization (load, dt, or None)', type=str, default=None) parser.add_argument('--c', dest='compaction', help='rule-compaction strategy', type=str, default='sub') parser.add_argument('--tp', dest='track_performance', help='performance tracking', type=int, default=1000) parser.add_argument('--sr', dest='stored_rule_iterations', help='comma-separated string indicating rule pop iterations to run full evaluation', type=str, default=None) parser.add_argument('--sm', dest='stored_model_iterations', help='comma-separated string indicating model pop iterations to run full evaluation', type=str, default=None) parser.add_argument('--rs', dest='random_state', help='random state seed', type=int, default=42) parser.add_argument('--v', dest='verbose', help='boolean flag to run in verbose mode', type=str, default='False') + parser.add_argument('--min', dest='min_output', help='boolean flag to minimize saved HEROS output', action='store_true') #---------------------------------------------------------------------------------------------- options=parser.parse_args(argv[1:]) @@ -61,10 +71,9 @@ def main(argv): instanceID_label = options.instanceID_label excluded_column = options.excluded_column #Experiment Parameters - if options.model_pop_init is None or options.model_pop_init == 'None': - model_pop_init = None - else: - model_pop_init = str(options.model_pop_init) + alternate = options.alternate + alternate_mode = options.alternate_mode + feedback = options.feedback #Critical HEROS Parameters outcome_type = options.outcome_type iterations = options.iterations @@ -72,6 +81,10 @@ def main(argv): nu = options.nu model_iterations = int(options.model_iterations) model_pop_size = options.model_pop_size + if options.model_pop_init is None or options.model_pop_init == 'None': + model_pop_init = None + else: + model_pop_init = str(options.model_pop_init) #Other HEROS Parameters cross_prob = options.cross_prob mut_prob = options.mut_prob @@ -105,6 +118,7 @@ def main(argv): verbose = True else: verbose = False + min_output = options.min_output # Get Dataset Name data_name = os.path.splitext(os.path.basename(full_data_path))[0] @@ -130,39 +144,53 @@ def main(argv): row_id = train_df[instanceID_label].values #instance id values except: row_id = None - #Load expert knowledge scores score_path_name = ekfolder+'/'+str(data_name)+'_MultiSURF_Scores.csv' #No need to change loaded_data = pd.read_csv(score_path_name) ek = loaded_data['Score'].tolist() #Train HEROS -------------------------------------------------------------------------------------------------------------------- - heros = HEROS(outcome_type=outcome_type,iterations=iterations, pop_size=pop_size, cross_prob=cross_prob, mut_prob=mut_prob, nu=nu, beta=beta, theta_sel=theta_sel, - fitness_function=fitness_function,subsumption=subsumption, rsl=rsl, feat_track=feat_track, model_iterations=model_iterations, - model_pop_size=model_pop_size, model_pop_init = model_pop_init, new_gen=new_gen, merge_prob=merge_prob, rule_pop_init=rule_pop_init, compaction=compaction, - track_performance=track_performance,stored_rule_iterations=stored_rule_iterations,stored_model_iterations=stored_model_iterations,random_state=random_state, verbose=verbose) - + heros = HEROS(outcome_type=outcome_type,iterations=iterations,pop_size=pop_size, cross_prob=cross_prob,mut_prob=mut_prob,nu=nu,beta=beta,theta_sel=theta_sel, + fitness_function=fitness_function,subsumption=subsumption,rsl=rsl,feat_track=feat_track, model_iterations=model_iterations, + model_pop_size=model_pop_size,model_pop_init=model_pop_init,new_gen=new_gen,merge_prob=merge_prob,rule_pop_init=rule_pop_init,compaction=compaction, + track_performance=track_performance,model_tracking=True,stored_rule_iterations=stored_rule_iterations,stored_model_iterations=stored_model_iterations, + random_state=random_state,verbose=verbose,alternate=alternate,alternate_mode=alternate_mode,feedback=feedback) + heros = heros.fit(train_X, train_y, row_id, cat_feat_indexes=cat_feat_indexes, ek=ek) - # Save Rule Population pop_df = heros.get_pop() pop_df.to_csv(outputPath+'/rule_pop.csv', index=False) + # Save Tree-Only Initialized Rule Population (if applicable) + if not min_output: + if rule_pop_init == 'dt' or rule_pop_init == 'dt_bstrap': + heros.rule_population.change_rule_pop(0) #Change rule population to tree-initialized rule population (if applicable) for export + tree_init_rule_pop_df = heros.get_pop() + heros.rule_population.restore_rule_pop() #Return to original rule population after export + tree_init_rule_pop_df.to_csv(outputPath+'/rule_pop_tree_init_only.csv', index=False) + #Save Rule Population Performance Tracking Estimates - tracking_df = heros.get_performance_tracking() - tracking_df.to_csv(outputPath+'/rule_pop_tracking.csv', index=False) + if not min_output: + tracking_df = heros.get_performance_tracking() + tracking_df.to_csv(outputPath+'/rule_pop_tracking.csv', index=False) + + # Plot Rule Learning Tracking + if not min_output: + heros.get_rule_tracking_plot(show=False,save=True,output_path=outputPath) #Save Plot Rule Pop Pareto Front - if nu == 1: #updated 3/29/24 - resolution = 500 - plot_rules = True - color_rules = True - heros.get_rule_pareto_landscape(resolution, heros.rule_population, plot_rules, color_rules,show=True,save=True,output_path=outputPath) + if not min_output: + if nu == 1: #updated 3/29/24 + resolution = 500 + plot_rules = True + color_rules = True + heros.get_rule_pareto_landscape(resolution, heros.rule_population, plot_rules, color_rules,show=False,save=True,output_path=outputPath) #Save Feature Tracking Scores - if feat_track != None: - ft_df = heros.get_ft(feature_names) - ft_df.to_csv(outputPath+'/feature_tracking_scores.csv', index=False) + if not min_output: + if feat_track != None: + ft_df = heros.get_ft(feature_names) + ft_df.to_csv(outputPath+'/feature_tracking_scores.csv', index=False) #Load/Process Testing Data test_data_path = full_data_path.replace("Train","Test") @@ -214,22 +242,14 @@ def main(argv): if stored_model_iterations is not None: for iter in stored_model_iterations: row_indexes.append('default_model_'+str(iter)) - row_indexes.append('default_model_'+str(model_iterations)) + #row_indexes.append('default_model_'+str(model_iterations)) if stored_model_iterations is not None: for iter in stored_model_iterations: row_indexes.append('test_selected_model_'+str(iter)) - row_indexes.append('test_selected_model_'+str(model_iterations)) + #row_indexes.append('test_selected_model_'+str(model_iterations)) #Gather Results ---------------------------------------------------------------------- results_list = [] - print('stored rule iterations') - print(stored_rule_iterations) - print(heros.rule_population.pop_set_archive.keys()) - print(heros.stored_rule_iterations) - print('stored model iterations') - print(stored_model_iterations) - print(heros.model_population.pop_set_archive.keys()) - print(heros.stored_model_iterations) #Archived Rule Population Evaluations-------------------------- if stored_rule_iterations is not None: for iter in stored_rule_iterations: @@ -253,7 +273,7 @@ def main(argv): full_list = full_list + [rule_count,run_time] results_list.append(full_list) - # Final (Compacted) Rule Population Evaluation + # Post-Compact Rule Pop Evaluation pred_y = heros.predict(train_X,whole_rule_pop=True,rule_pop_iter=None) tn, fp, fn, tp, balanced_accuracy = evaluate_stats(train_y, pred_y) cov_y = heros.predict_covered(train_X,whole_rule_pop=True,rule_pop_iter=None) @@ -296,30 +316,12 @@ def main(argv): full_list = full_list + [rule_count,run_time] results_list.append(full_list) - # Final Model Population Evaluation (Default Selection) - pred_y = heros.predict(train_X,whole_rule_pop=False, target_model=0,model_pop_iter=None) - tn, fp, fn, tp, balanced_accuracy = evaluate_stats(train_y, pred_y) - cov_y = heros.predict_covered(train_X,whole_rule_pop=False, target_model=0,model_pop_iter=None) - coverage = sum(cov_y)/len(cov_y) - train_list = [balanced_accuracy,tp,fp,tn,fn,coverage] - #Testing Evaluations----- - pred_y = heros.predict(test_X,whole_rule_pop=False, target_model=0,model_pop_iter=None) - tn, fp, fn, tp, balanced_accuracy = evaluate_stats(test_y, pred_y) - cov_y = heros.predict_covered(test_X,whole_rule_pop=False, target_model=0,model_pop_iter=None) - coverage = sum(cov_y)/len(cov_y) - test_list = [balanced_accuracy,tp,fp,tn,fn,coverage] - full_list = train_list + test_list - #Other Data - rule_count = len(heros.model_population.pop_set[0].rule_IDs) - run_time = heros.timer.time_phase1 + heros.timer.time_phase2 #total time from start to end of phase 2 - #Combine into results list - full_list = full_list + [rule_count,run_time] - results_list.append(full_list) #Archived Model Population Evaluations (Testing Data Selection)-------------------------- if stored_model_iterations is not None: for iter in stored_model_iterations: #Identify best model on front (based on testing accuracy and coverage) + ## LOOK AT METHOD BELOW:: best_model_index = get_best_testing_model_on_front(heros,test_X,test_y,iter) #Training Evaluations----- pred_y = heros.predict(train_X,whole_rule_pop=False, target_model=best_model_index,model_pop_iter=iter) @@ -341,66 +343,10 @@ def main(argv): full_list = full_list + [rule_count,run_time] results_list.append(full_list) - # Final Model Population Evaluation (Testing Data Selection)------------------------------- - - #Identify best model on front (based on testing accuracy and coverage)----------- - model_pop_df = heros.get_model_pop() - #Identify model indexes of all models on front - model_on_front_indexes = [] - model_on_front_rule_count = [] - # Loop through each row - for index, row in model_pop_df.iterrows(): - if row['Model on Front'] == 1: - model_on_front_indexes.append(index) - model_on_front_rule_count.append(row['Number of Rules']) - #print(model_on_front_indexes) - #For each one run prediction to get prediction accuracy and instance coverage on testing data - model_accuracies = [] - model_coverages = [] - for index in model_on_front_indexes: - #Handle class prediction and accuracy - pred_y = heros.predict(test_X,whole_rule_pop=False, target_model=index,model_pop_iter=None) - tn, fp, fn, tp, balanced_accuracy = evaluate_stats(test_y, pred_y) - model_accuracies.append(balanced_accuracy) - #Handle model coverage - coverages = heros.predict_covered(test_X,whole_rule_pop=False, target_model=index,model_pop_iter=None) - coverage = sum(coverages)/len(coverages) #proportion of instances covered - model_coverages.append(coverage) - #Identify the model index with the highest prediction accuracy - best_accuracy = 0 - best_coverage = 0 - best_rule_count = np.inf - best_model_index = 0 - for i in range(0,len(model_on_front_indexes)): - if (model_accuracies[i] > best_accuracy and model_coverages[i] >= best_coverage) or (model_accuracies[i] >= best_accuracy and model_coverages[i] >= best_coverage and model_on_front_rule_count[i] < best_rule_count): - #if model_accuracies[i] > best_accuracy and model_coverages[i] >= best_coverage: - best_accuracy = model_accuracies[i] - best_coverage = model_coverages[i] - best_rule_count = model_on_front_rule_count[i] - best_model_index = model_on_front_indexes[i] - - # Run evaluation for target model - pred_y = heros.predict(train_X,whole_rule_pop=False, target_model=best_model_index,model_pop_iter=None) - tn, fp, fn, tp, balanced_accuracy = evaluate_stats(train_y, pred_y) - cov_y = heros.predict_covered(train_X,whole_rule_pop=False, target_model=best_model_index,model_pop_iter=None) - coverage = sum(cov_y)/len(cov_y) - train_list = [balanced_accuracy,tp,fp,tn,fn,coverage] - #Testing Evaluations----- - pred_y = heros.predict(test_X,whole_rule_pop=False, target_model=best_model_index,model_pop_iter=None) - tn, fp, fn, tp, balanced_accuracy = evaluate_stats(test_y, pred_y) - cov_y = heros.predict_covered(test_X,whole_rule_pop=False, target_model=best_model_index,model_pop_iter=None) - coverage = sum(cov_y)/len(cov_y) - test_list = [balanced_accuracy,tp,fp,tn,fn,coverage] - full_list = train_list + test_list - #Other Data - rule_count = len(heros.model_population.pop_set[best_model_index].rule_IDs) - run_time = heros.timer.time_phase1 + heros.timer.time_phase2 #total time from start to end of phase 2 - #Combine into results list - full_list = full_list + [rule_count,run_time] - results_list.append(full_list) - #REPORT EVALUATION RESULTS results_df = pd.DataFrame(results_list, columns=headers) + print(results_df) + print(row_indexes) results_df['Row Indexes'] = row_indexes results_df.to_csv(outputPath+'/evaluation_summary.csv', index=False) @@ -417,32 +363,11 @@ def main(argv): set_df.to_csv(outputPath+'/top_testing_model_rules.csv', index=False) #Save Plot Model Pop Pareto Front - resolution = 500 - plot_models = True - #heros.get_model_pareto_landscape(resolution, heros.model_population, plot_models, show=True,save=True,output_path=outputPath) #original first submission - heros.get_model_pareto_fronts(show=True,save=True,output_path=outputPath) - - #Save Plot Model Tracking - top_models = heros.export_model_growth() - top_models.to_csv(outputPath+'/model_tracking.csv', index=False) - - - # Create the plot - fig, ax1 = plt.subplots() - # Plot the first line on the left y-axis - ax1.plot(top_models.index, top_models["Accuracy"], 'b-', label='Model Balanced Accuracy') # 'b-' specifies a blue solid line - ax1.plot(top_models.index, top_models["Coverage"], 'g-', label='Model Coverage') # 'b-' specifies a blue solid line - - ax1.set_xlabel('Iteration') - ax1.set_ylabel('Balanced Accuracy (Blue) and Coverage (Green)') - ax1.tick_params(axis='y') - # Create a second y-axis sharing the same x-axis - ax2 = ax1.twinx() - ax2.plot(top_models.index, top_models["Number of Rules"], 'r--', label='Rules in Model') # 'r--' specifies a red dashed line - ax2.set_ylabel('Rules in Model', color='r') - ax2.tick_params(axis='y', labelcolor='r') - plt.title(f'{"Top Model Accuracy and # of Rules"} vs Iteration') - plt.savefig(outputPath+'/model_tracking_line_graph.png', bbox_inches="tight") + if not min_output: + model_tracking_df = heros.get_model_performance_tracking() + model_tracking_df.to_csv(outputPath+'/model_tracking.csv', index=False) + # Plot Model Learning Tracking + heros.get_model_tracking_plot(show=False,save=True,output_path=outputPath) # Save Runtime Summary time_df = heros.get_runtimes() @@ -454,7 +379,7 @@ def main(argv): def get_best_testing_model_on_front(heros,test_X,test_y,iter): - model_pop_df = export_model_population(heros.model_population.pop_set_archive[iter]) + model_pop_df = heros.model_population.export_model_population() #Identify model indexes of all models on front model_on_front_indexes = [] model_on_front_rule_count = [] @@ -483,8 +408,7 @@ def get_best_testing_model_on_front(heros,test_X,test_y,iter): best_rule_count = np.inf best_model_index = 0 for i in range(0,len(model_on_front_indexes)): - if (model_accuracies[i] > best_accuracy and model_coverages[i] >= best_coverage) or (model_accuracies[i] == best_accuracy and model_coverages[i] >= best_coverage and model_on_front_rule_count[i] < best_rule_count): - #if model_accuracies[i] > best_accuracy and model_coverages[i] >= best_coverage: + if (model_accuracies[i] > best_accuracy and model_coverages[i] >= best_coverage) or (model_accuracies[i] >= best_accuracy and model_coverages[i] >= best_coverage and model_on_front_rule_count[i] < best_rule_count): best_accuracy = model_accuracies[i] best_coverage = model_coverages[i] best_rule_count = model_on_front_rule_count[i] diff --git a/evaluation/experiments/heros_scripts/job_heros_sum.py b/evaluation/experiments/heros_scripts/job_heros_sum.py new file mode 100644 index 0000000..c1d619c --- /dev/null +++ b/evaluation/experiments/heros_scripts/job_heros_sum.py @@ -0,0 +1,410 @@ +# I2C2-Documentation/job_heros_alt_sum.py +# +# Robust summary/aggregation script for HEROS CV + seed experiments. +# - No HEROS import required +# - Skips missing CV files (prints what’s missing) +# - Derives evaluation points dynamically (no hard-coded row_index) +# - Produces: +# seed_i/mean_CV_evaluation_summary.csv, seed_i/sd_CV_evaluation_summary.csv +# dataset/mean_seed_evaluation_summary.csv, dataset/sd_seed_evaluation_summary.csv +# dataset/all__evaluations.csv (all seed×cv rows) +# dataset/cv_ave__evaluations.csv (seed-level CV means) +# dataset/boxplot_testing_accuracy_all.png, dataset/boxplot_rule_count_all.png +# outputPath/phase1_mux_ideal_success*.csv (if multiplexer outputs) + +import os +import sys +import argparse +import pandas as pd +import numpy as np +import matplotlib +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import seaborn as sns + +def safe_read_csv(path: str) -> pd.DataFrame | None: + try: + return pd.read_csv(path) + except FileNotFoundError: + return None + except Exception as e: + print(f"[WARN] Failed reading {path}: {e}") + return None + +def list_datasets(output_path: str) -> list[str]: + datasets = [] + for entry in sorted(os.listdir(output_path)): + p = os.path.join(output_path, entry) + if os.path.isdir(p): + datasets.append(entry) + return datasets + +def get_row_indexes_from_any_eval(output_path: str, dataset: str, random_seeds: int, cv_partitions: int) -> list[str]: + # Find first existing evaluation_summary.csv and return its Row Indexes + for i in range(random_seeds): + for j in range(1, cv_partitions + 1): + fp = os.path.join(output_path, dataset, f"seed_{i}", f"cv_{j}", "evaluation_summary.csv") + df = safe_read_csv(fp) + if df is not None and "Row Indexes" in df.columns: + rows = df["Row Indexes"].tolist() + return rows + return [] + +def aggregate_seed_level(output_path: str, dataset: str, seed: int, cv_partitions: int) -> tuple[pd.DataFrame | None, pd.DataFrame | None]: + """ + Returns (mean_df, sd_df) for this seed across CVs. + Each df includes 'Row Indexes' column. + """ + seed_path = os.path.join(output_path, dataset, f"seed_{seed}") + dfs = [] + row_names = None + + missing = 0 + for j in range(1, cv_partitions + 1): + fp = os.path.join(seed_path, f"cv_{j}", "evaluation_summary.csv") + df = safe_read_csv(fp) + if df is None: + missing += 1 + print(f"[MISSING] {fp}") + continue + if "Row Indexes" not in df.columns: + print(f"[WARN] No 'Row Indexes' in {fp}; skipping") + missing += 1 + continue + + row_names = df["Row Indexes"] + df_x = df.drop(columns=["Row Indexes"]) + dfs.append(df_x) + + if not dfs: + print(f"[WARN] No CV eval files found for dataset={dataset}, seed={seed}") + return None, None + + # Concatenate vertically and group by row position (level=0) to average CVs + mean_x = pd.concat(dfs).groupby(level=0).mean(numeric_only=True) + sd_x = pd.concat(dfs).groupby(level=0).std(numeric_only=True) + + mean_df = pd.concat([row_names, mean_x], axis=1) + sd_df = pd.concat([row_names, sd_x], axis=1) + + # Save + mean_df.to_csv(os.path.join(seed_path, "mean_CV_evaluation_summary.csv"), index=False) + sd_df.to_csv(os.path.join(seed_path, "sd_CV_evaluation_summary.csv"), index=False) + + if missing > 0: + print(f"[INFO] dataset={dataset} seed={seed}: skipped {missing}/{cv_partitions} missing CV eval files") + + return mean_df, sd_df + +def aggregate_dataset_level(output_path: str, dataset: str, random_seeds: int) -> tuple[pd.DataFrame | None, pd.DataFrame | None]: + """ + Uses seed_i/mean_CV_evaluation_summary.csv to compute mean/sd across seeds. + """ + dataset_path = os.path.join(output_path, dataset) + dfs = [] + row_names = None + + missing = 0 + for i in range(random_seeds): + fp = os.path.join(dataset_path, f"seed_{i}", "mean_CV_evaluation_summary.csv") + df = safe_read_csv(fp) + if df is None: + missing += 1 + print(f"[MISSING] {fp}") + continue + if "Row Indexes" not in df.columns: + missing += 1 + print(f"[WARN] No 'Row Indexes' in {fp}; skipping") + continue + + row_names = df["Row Indexes"] + df_x = df.drop(columns=["Row Indexes"]) + dfs.append(df_x) + + if not dfs: + print(f"[WARN] No seed mean CV files found for dataset={dataset}") + return None, None + + mean_x = pd.concat(dfs).groupby(level=0).mean(numeric_only=True) + sd_x = pd.concat(dfs).groupby(level=0).std(numeric_only=True) + + mean_df = pd.concat([row_names, mean_x], axis=1) + sd_df = pd.concat([row_names, sd_x], axis=1) + + mean_df.to_csv(os.path.join(dataset_path, "mean_seed_evaluation_summary.csv"), index=False) + sd_df.to_csv(os.path.join(dataset_path, "sd_seed_evaluation_summary.csv"), index=False) + + if missing > 0: + print(f"[INFO] dataset={dataset}: skipped {missing}/{random_seeds} missing seed mean CV files") + + return mean_df, sd_df + +def write_global_eval_lists(output_path: str, dataset: str, random_seeds: int, cv_partitions: int) -> None: + """ + Creates dataset-level: + all__evaluations.csv (every seed×cv result row) + cv_ave__evaluations.csv (every seed’s CV-mean result row) + """ + dataset_path = os.path.join(output_path, dataset) + + # Determine row indexes dynamically (from any existing cv eval) + row_indexes = get_row_indexes_from_any_eval(output_path, dataset, random_seeds, cv_partitions) + if not row_indexes: + print(f"[WARN] Could not determine Row Indexes for dataset={dataset}; skipping global lists") + return + + # Build "all runs" dict row_index -> list of rows (without Row Indexes) + header = None + eval_point_all: dict[str, list[list]] = {ri: [] for ri in row_indexes} + + missing = 0 + for i in range(random_seeds): + for j in range(1, cv_partitions + 1): + fp = os.path.join(dataset_path, f"seed_{i}", f"cv_{j}", "evaluation_summary.csv") + df = safe_read_csv(fp) + if df is None or "Row Indexes" not in df.columns: + missing += 1 + continue + + if header is None: + header = [c for c in df.columns if c != "Row Indexes"] + + for _, row in df.iterrows(): + ri = row["Row Indexes"] + if ri not in eval_point_all: + # In case different runs have extra rows, include them too + eval_point_all[ri] = [] + values = [row[c] for c in header] + eval_point_all[ri].append(values) + + if header is None: + print(f"[WARN] No evaluation_summary.csv readable for dataset={dataset}; skipping") + return + + for ri, rows in eval_point_all.items(): + if not rows: + continue + pd.DataFrame(rows, columns=header).to_csv( + os.path.join(dataset_path, f"all_{ri}_evaluations.csv"), index=False + ) + + if missing > 0: + print(f"[INFO] dataset={dataset}: skipped {missing} missing/bad cv eval files while building all_* lists") + + # Now build CV-average lists from each seed's mean_CV_evaluation_summary.csv + eval_point_cv_ave: dict[str, list[list]] = {} + header2 = None + + missing2 = 0 + for i in range(random_seeds): + fp = os.path.join(dataset_path, f"seed_{i}", "mean_CV_evaluation_summary.csv") + df = safe_read_csv(fp) + if df is None or "Row Indexes" not in df.columns: + missing2 += 1 + continue + + if header2 is None: + header2 = [c for c in df.columns if c != "Row Indexes"] + + for _, row in df.iterrows(): + ri = row["Row Indexes"] + if ri not in eval_point_cv_ave: + eval_point_cv_ave[ri] = [] + values = [row[c] for c in header2] + eval_point_cv_ave[ri].append(values) + + if header2 is not None: + for ri, rows in eval_point_cv_ave.items(): + if not rows: + continue + pd.DataFrame(rows, columns=header2).to_csv( + os.path.join(dataset_path, f"cv_ave_{ri}_evaluations.csv"), index=False + ) + + if missing2 > 0: + print(f"[INFO] dataset={dataset}: skipped {missing2} missing seed mean CV files while building cv_ave_* lists") + +def make_boxplots(output_path: str, dataset: str, random_seeds: int, cv_partitions: int) -> None: + """ + Uses the dynamically discovered row indexes and all__evaluations.csv files. + Produces: + boxplot_testing_accuracy_all.png + boxplot_rule_count_all.png + """ + dataset_path = os.path.join(output_path, dataset) + row_indexes = get_row_indexes_from_any_eval(output_path, dataset, random_seeds, cv_partitions) + if not row_indexes: + print(f"[WARN] No row indexes found for dataset={dataset}; skipping plots") + return + + # Accuracy plot + acc_series = [] + acc_labels = [] + for ri in row_indexes: + fp = os.path.join(dataset_path, f"all_{ri}_evaluations.csv") + df = safe_read_csv(fp) + if df is None: + continue + if "test_balanced_accuracy" not in df.columns: + continue + acc_series.append(df["test_balanced_accuracy"]) + acc_labels.append(ri) + + if acc_series: + acc_df = pd.concat(acc_series, axis=1) + acc_df.columns = acc_labels + plt.figure(figsize=(10, 6)) + sns.boxplot(data=acc_df) + plt.xticks(ticks=range(len(acc_labels)), labels=acc_labels, rotation=90) + plt.xlabel("Evaluation Points") + plt.ylabel("Balanced Testing Accuracy") + plt.savefig(os.path.join(dataset_path, "boxplot_testing_accuracy_all.png"), bbox_inches="tight") + plt.close() + + # Rule count plot + cnt_series = [] + cnt_labels = [] + for ri in row_indexes: + fp = os.path.join(dataset_path, f"all_{ri}_evaluations.csv") + df = safe_read_csv(fp) + if df is None: + continue + if "rule_count" not in df.columns: + continue + cnt_series.append(df["rule_count"]) + cnt_labels.append(ri) + + if cnt_series: + cnt_df = pd.concat(cnt_series, axis=1) + cnt_df.columns = cnt_labels + plt.figure(figsize=(10, 6)) + sns.boxplot(data=cnt_df) + plt.xticks(ticks=range(len(cnt_labels)), labels=cnt_labels, rotation=90) + plt.xlabel("Evaluation Points") + plt.ylabel("Rule Count") + plt.savefig(os.path.join(dataset_path, "boxplot_rule_count_all.png"), bbox_inches="tight") + plt.close() + +# ---- Multiplexer ideal-rule utilities (unchanged logic, but robust file checks) ---- + +def int_to_binary_list(num: int, n: int) -> list[int]: + return [int(bit) for bit in format(num, f"0{n}b")] + +def gen_ideal_rules(mux: int) -> list[list]: + address_bits = {6:2, 11:3, 20:4, 37:5, 70:6, 135:7} + ideal_list = [] + reg_bits = mux - address_bits[mux] + for i in range(reg_bits): + idx = list(range(address_bits[mux])) + [i + address_bits[mux]] + + vals0 = int_to_binary_list(i, address_bits[mux]) + [0] + ideal_list.append([str(idx), str(vals0), 0]) + + vals1 = int_to_binary_list(i, address_bits[mux]) + [1] + ideal_list.append([str(idx), str(vals1), 1]) + + return ideal_list + +def mux_ideal_rule_scan(output_path: str, cv_partitions: int, random_seeds: int) -> None: + # Only do if "multiplexer" experiment folder name suggests mux + if "multiplexer" not in output_path.lower() and "mux" not in output_path.lower(): + return + + # You can extend this mapping as needed + mux_output_folders = { + "A_multiplexer_6_bit_500_inst": 6, + "B_multiplexer_11_bit_5000_inst": 11, + "C_multiplexer_20_bit_10000_inst": 20, + "D_multiplexer_37_bit_10000_inst": 37, + "E_multiplexer_70_bit_20000_inst": 70, + } + + header = ["Dataset", "Seed", "CV", "Ideal Count", "Ideal Proportion"] + results = [] + + for dataset in list_datasets(output_path): + if dataset not in mux_output_folders: + continue + + ideal_rules = gen_ideal_rules(mux_output_folders[dataset]) + ideal_count = len(ideal_rules) + dataset_path = os.path.join(output_path, dataset) + + for i in range(random_seeds): + for j in range(1, cv_partitions + 1): + rule_fp = os.path.join(dataset_path, f"seed_{i}", f"cv_{j}", "rule_pop.csv") + df = safe_read_csv(rule_fp) + if df is None: + print(f"[MISSING] {rule_fp}") + continue + + if not {"Condition Indexes", "Condition Values", "Action"}.issubset(df.columns): + print(f"[WARN] rule_pop.csv missing expected columns in {rule_fp}") + continue + + found = 0 + for _, row in df.iterrows(): + combined = [row["Condition Indexes"], row["Condition Values"], int(row["Action"])] + if combined in ideal_rules: + found += 1 + + results.append([dataset, i, j, found, (found / float(ideal_count)) if ideal_count else 0.0]) + + if not results: + return + + out_csv = os.path.join(output_path, "phase1_mux_ideal_success.csv") + df_res = pd.DataFrame(results, columns=header) + df_res.to_csv(out_csv, index=False) + + # Average summary per dataset + avg_rows = [] + for dataset in df_res["Dataset"].unique(): + avg_count = df_res.loc[df_res["Dataset"] == dataset, "Ideal Count"].mean() + avg_prop = df_res.loc[df_res["Dataset"] == dataset, "Ideal Proportion"].mean() + avg_rows.append([dataset, avg_count, avg_prop]) + + df_avg = pd.DataFrame(avg_rows, columns=["Dataset", "Ideal Count", "Ideal Proportion"]) + df_avg.to_csv(os.path.join(output_path, "phase1_mux_ideal_success_average.csv"), index=False) + +# ---- main ---- + +def main(argv): + parser = argparse.ArgumentParser(description="Aggregate HEROS CV/seed results.") + parser.add_argument("--o", dest="outputPath", type=str, required=True, help="Path to HEROS output folder (algorithm_output root).") + parser.add_argument("--ol", dest="outcome_label", type=str, default="Class") + parser.add_argument("--il", dest="instanceID_label", type=str, default="InstanceID") + parser.add_argument("--el", dest="excluded_column", type=str, default="Group") + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + args = parser.parse_args(argv[1:]) + + output_path = args.outputPath + cv_partitions = args.cv_partitions + random_seeds = args.random_seeds + + print(f"[INFO] Summarizing: {output_path}") + datasets = list_datasets(output_path) + print(f"[INFO] Found datasets: {datasets}") + + # 1) seed-level mean/sd across CVs + for dataset in datasets: + for seed in range(random_seeds): + aggregate_seed_level(output_path, dataset, seed, cv_partitions) + + # 2) dataset-level mean/sd across seeds + for dataset in datasets: + aggregate_dataset_level(output_path, dataset, random_seeds) + + # 3) global lists + plots + for dataset in datasets: + write_global_eval_lists(output_path, dataset, random_seeds, cv_partitions) + make_boxplots(output_path, dataset, random_seeds, cv_partitions) + + # 4) mux ideal rule scan (optional) + mux_ideal_rule_scan(output_path, cv_partitions, random_seeds) + + print("[INFO] Done.") + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/heros_scripts/job_heros_table.py b/evaluation/experiments/heros_scripts/job_heros_table.py new file mode 100644 index 0000000..5347827 --- /dev/null +++ b/evaluation/experiments/heros_scripts/job_heros_table.py @@ -0,0 +1,826 @@ +#!/usr/bin/env python3 +# job_heros_alt_table2.0.py +# +# Builds a combined HEROS table from dataset-level summary outputs: +# /HEROS_//{mean_seed_evaluation_summary.csv, sd_seed_evaluation_summary.csv} +# +# Adds significance markers (*+/*-) by comparing each non-baseline config against a +# per-dataset-family baseline (multiplexer vs gametes), using raw eval CSVs: +# all__evaluations.csv (preferred) or cv_ave__evaluations.csv (fallback) +# +# Usage (direct): +# python job_heros_alt_table2.0.py --o /path/to/output --groups mux_cv_default,... \ +# --baseline-map multiplexer:mux_cv_default,gametes:gametes_cv_default --alpha 0.05 \ +# --outcsv HEROS_Combined_Table.csv + +import argparse +from pathlib import Path +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.patches import Patch +from scipy.stats import wilcoxon, mannwhitneyu +from statsmodels.stats.multitest import multipletests + + + +# ---------------------------- +# Table content configuration +# ---------------------------- + +TARGET_ROWS = [ + "default_model_200", + "test_selected_model_200", +] + +METRICS = { + "Testing Accuracy": ("test_balanced_accuracy", 3), + "Testing Coverage": ("test_coverage", 3), + "Rule Count": ("rule_count", 1), + "Run Time (Minutes)": ("run_time", 1), # seconds -> minutes +} + +PHASE1_CONDITIONS = [ + "rule_500", "rule_1000", "rule_10000", "rule_100000", "rule_200000", "rule_post_compact" +] +PHASE2_DEFAULT_CONDITIONS = [ + "default_model_5", "default_model_10", "default_model_50", "default_model_100", "default_model_200" +] +PHASE2_TESTSEL_CONDITIONS = [ + "test_selected_model_5", "test_selected_model_10", "test_selected_model_50", + "test_selected_model_100", "test_selected_model_200" +] + +GAMETES_DATASETS = [ + "A_uni_4add", + "B_univariate", + "C_2way_epistasis", + "D_2way_epi_2het", + "E_uni_4het", + "F_3way_epistasis", +] + +MUX_DATASETS = [ + "A_multiplexer_6_bit_500_inst", + "B_multiplexer_11_bit_5000_inst", + "C_multiplexer_20_bit_10000_inst", + "D_multiplexer_37_bit_10000_inst", + "E_multiplexer_70_bit_20000_inst", +] + +IDEAL_MUX_RULE_COUNT = { + "A_multiplexer_6_bit_500_inst": 8, + "B_multiplexer_11_bit_5000_inst": 16, + "C_multiplexer_20_bit_10000_inst": 32, + "D_multiplexer_37_bit_10000_inst": 64, + "E_multiplexer_70_bit_20000_inst": 128, +} + + +BASELINE_CONDITION = "default_model_200" + +# ---------------------------- +# Formatting / I/O helpers +# ---------------------------- + +def fmt_mean_sd(mean, sd, decimals=3): + if mean is None or sd is None: + return "NaN" + try: + if np.isnan(mean) or np.isnan(sd): + return "NaN" + except Exception: + pass + return f"{float(mean):.{decimals}f}({float(sd):.{decimals}f})" + + +def read_mean_sd(mean_path: Path, sd_path: Path) -> pd.DataFrame: + """ + Reads: + mean_seed_evaluation_summary.csv + sd_seed_evaluation_summary.csv + + Expected format: + Row Indexes, test_balanced_accuracy, ..., run_time + rule_500, ... + ... + """ + if (not mean_path.exists()) or (not sd_path.exists()): + return pd.DataFrame() + + mean_df = pd.read_csv(mean_path) + sd_df = pd.read_csv(sd_path) + + if "Row Indexes" in mean_df.columns: + mean_df = mean_df.rename(columns={"Row Indexes": "Condition"}) + if "Row Indexes" in sd_df.columns: + sd_df = sd_df.rename(columns={"Row Indexes": "Condition"}) + + if "Condition" not in mean_df.columns or "Condition" not in sd_df.columns: + return pd.DataFrame() + + merged = pd.merge(mean_df, sd_df, on="Condition", how="outer", suffixes=("_mean", "_sd")) + return merged + + +def raw_eval_path(group_dir: Path, dataset: str, condition: str) -> Path | None: + """ + Prefer all_*_evaluations.csv; fallback to cv_ave_*_evaluations.csv. + """ + p_all = group_dir / dataset / f"all_{condition}_evaluations.csv" + if p_all.exists(): + return p_all + + p_cv = group_dir / dataset / f"cv_ave_{condition}_evaluations.csv" + if p_cv.exists(): + return p_cv + + return None + + +def _metric_series_from_raw(df: pd.DataFrame, metric_col: str) -> pd.Series: + if metric_col not in df.columns: + return pd.Series(dtype=float) + s = pd.to_numeric(df[metric_col], errors="coerce").dropna() + return s.astype(float) + + +def load_raw_metric_values( + output_root: Path, + group_name: str, # WITHOUT "HEROS_" prefix + dataset: str, + condition: str, + metric_col: str, +) -> pd.Series: + group_dir = output_root / f"HEROS_{group_name}" + if not group_dir.exists(): + return pd.Series(dtype=float) + + p = raw_eval_path(group_dir, dataset, condition) + if p is None: + return pd.Series(dtype=float) + + try: + df = pd.read_csv(p) + except Exception: + return pd.Series(dtype=float) + + s = _metric_series_from_raw(df, metric_col) + + # match table display: runtime seconds -> minutes + if metric_col == "run_time" and not s.empty: + s = s / 60.0 + + return s + + +def wilcoxon_p_or_fallback(base: pd.Series, other: pd.Series) -> tuple[float | None, str]: + """ + Returns (p_value, test_name) + - Wilcoxon (paired) if lengths match + - else Mann-Whitney U (unpaired) fallback + """ + base = pd.to_numeric(base, errors="coerce").dropna() + other = pd.to_numeric(other, errors="coerce").dropna() + + if base.empty or other.empty: + return (None, "none") + + if len(base) == len(other): + try: + _stat, p = wilcoxon(base.to_numpy(), other.to_numpy()) + return (float(p), "wilcoxon") + except Exception: + pass + + try: + _stat, p = mannwhitneyu(base.to_numpy(), other.to_numpy(), alternative="two-sided") + return (float(p), "mannwhitneyu") + except Exception: + return (None, "none") + +def collect_significance_tests( + output_root: Path, + allowed_groups: set[str], + *, + baseline_map: dict[str, str], +) -> pd.DataFrame: + rows = [] + + if not output_root.exists(): + raise FileNotFoundError(f"Output root does not exist: {output_root}") + + group_dirs = [] + for g in sorted(allowed_groups): + gp = output_root / f"HEROS_{g}" + if gp.exists() and gp.is_dir(): + group_dirs.append(gp) + + for group_dir in group_dirs: + group_name = group_dir.name.replace("HEROS_", "", 1) + + for dataset_dir in sorted([p for p in group_dir.iterdir() if p.is_dir()], key=lambda p: p.name): + dataset = dataset_dir.name + fam = dataset_family(dataset) + baseline_group = baseline_map.get(fam, None) + + if baseline_group is None: + continue + + for condition in TARGET_ROWS: + # skip the actual baseline row itself + if group_name == baseline_group and condition == BASELINE_CONDITION: + continue + + for nice_name, (base_col, _decimals) in METRICS.items(): + base_vec = load_raw_metric_values( + output_root, baseline_group, dataset, BASELINE_CONDITION, base_col + ) + this_vec = load_raw_metric_values( + output_root, group_name, dataset, condition, base_col + ) + + if base_vec.empty or this_vec.empty: + continue + + p_val, test_name = wilcoxon_p_or_fallback(base_vec, this_vec) + if p_val is None: + continue + + base_mean = float(base_vec.mean()) if not base_vec.empty else None + this_mean = float(this_vec.mean()) if not this_vec.empty else None + + rows.append({ + "Dataset": dataset, + "DatasetFamily": fam, + "GroupName": group_name, + "Condition": condition, + "MetricLabel": nice_name, # e.g. "Testing Accuracy" + "MetricCol": base_col, # e.g. "test_balanced_accuracy" + "BaselineGroup": baseline_group, + "p_value": p_val, + "test_name": test_name, + "base_mean": base_mean, + "this_mean": this_mean, + }) + + return pd.DataFrame(rows) + +def apply_fdr_bh_by_metric(tests_df: pd.DataFrame, alpha: float) -> pd.DataFrame: + tests_df = tests_df.copy() + tests_df["p_value_fdr_bh"] = np.nan + tests_df["significant"] = False + + if tests_df.empty: + return tests_df + + for metric in tests_df["MetricLabel"].unique(): + metric_mask = tests_df["MetricLabel"] == metric + metric_pvals = tests_df.loc[metric_mask, "p_value"].to_numpy() + + rej, p_adj, _, _ = multipletests(metric_pvals, alpha=alpha, method="fdr_bh") + tests_df.loc[metric_mask, "p_value_fdr_bh"] = p_adj + tests_df.loc[metric_mask, "significant"] = rej + + return tests_df + +def build_sig_lookup(tests_df: pd.DataFrame) -> dict[tuple[str, str, str, str], dict]: + lookup = {} + + for _, row in tests_df.iterrows(): + key = ( + row["Dataset"], + row["GroupName"], + row["Condition"], + row["MetricLabel"], + ) + lookup[key] = { + "p_value": row["p_value"], + "p_value_fdr_bh": row["p_value_fdr_bh"], + "significant": bool(row["significant"]), + "base_mean": row["base_mean"], + "this_mean": row["this_mean"], + "test_name": row["test_name"], + } + + return lookup + +def append_sig_marker( + formatted_mean_sd: str, + base_mean: float | None, + this_mean: float | None, + is_sig: bool, + p_value_adj: float | None, +) -> str: + if p_value_adj is None: + return formatted_mean_sd + + p_str = f"{p_value_adj:.4g}" + + if not is_sig: + return f"{formatted_mean_sd} ({p_str})" + + if base_mean is None or this_mean is None: + return f"{formatted_mean_sd}* ({p_str})" + + return f"{formatted_mean_sd}{'*+' if this_mean > base_mean else '*-'} ({p_str})" + + +def parse_baseline_map(s: str) -> dict[str, str]: + """ + "multiplexer:mux_cv_default,gametes:gametes_cv_default" -> {"multiplexer": "...", "gametes": "..."} + """ + out: dict[str, str] = {} + for chunk in (s or "").split(","): + chunk = chunk.strip() + if not chunk: + continue + if ":" not in chunk: + continue + k, v = chunk.split(":", 1) + out[k.strip().lower()] = v.strip() + return out + + +def dataset_family(dataset: str) -> str: + if dataset in MUX_DATASETS or "multiplexer" in dataset: + return "multiplexer" + if dataset in GAMETES_DATASETS: + return "gametes" + return "other" + + +def extract_one_condition( + merged: pd.DataFrame, + condition: str, + *, + output_root: Path, + dataset: str, + group_name: str, # WITHOUT "HEROS_" + baseline_map: dict[str, str], + alpha: float, + sig_lookup: dict | None = None, +) -> dict: + out = {"Condition": condition} + out["Ideal Solution Count"] = "" + + if merged.empty: + for nice_name in METRICS: + out[nice_name] = "NaN" + return out + + row = merged[merged["Condition"] == condition] + if row.empty: + for nice_name in METRICS: + out[nice_name] = "NaN" + return out + + row0 = row.iloc[0] + # Only for MUX configs + Phase II model rows + out["Ideal Solution Count"] = ideal_solution_count_cell( + output_root=output_root, + group_name=group_name, + dataset=dataset, + condition=condition, + ) + + + fam = dataset_family(dataset) + baseline_group = baseline_map.get(fam, None) + do_sig = ( + baseline_group is not None and + not (group_name == baseline_group and condition == BASELINE_CONDITION) + ) + + for nice_name, (base_col, decimals) in METRICS.items(): + mean_col = f"{base_col}_mean" + sd_col = f"{base_col}_sd" + mean_val = row0.get(mean_col, None) + sd_val = row0.get(sd_col, None) + + # runtime seconds -> minutes (for display) + if base_col == "run_time": + mean_val = (float(mean_val) / 60.0) if mean_val is not None else None + sd_val = (float(sd_val) / 60.0) if sd_val is not None else None + + cell = fmt_mean_sd(mean_val, sd_val, decimals=decimals) + + if do_sig and sig_lookup is not None: + key = (dataset, group_name, condition, nice_name) + sig_info = sig_lookup.get(key) + + if sig_info is not None: + cell = append_sig_marker( + cell, + sig_info.get("base_mean"), + sig_info.get("this_mean"), + bool(sig_info.get("significant")), + sig_info.get("p_value_fdr_bh"), + ) + + out[nice_name] = cell + + return out + +IDEAL_DENOM = 200 # fixed per your design (not inferred from file length) + +def is_mux_phase2_model_condition(condition: str) -> bool: + return condition in PHASE2_DEFAULT_CONDITIONS or condition in PHASE2_TESTSEL_CONDITIONS + + +def ideal_solution_count_cell( + output_root: Path, + group_name: str, # WITHOUT "HEROS_" + dataset: str, + condition: str, +) -> str: + """ + Returns 'X/200' for MUX Phase II model rows, else ''. + Uses raw eval CSV (all_* preferred; cv_ave_* fallback). + """ + if dataset not in IDEAL_MUX_RULE_COUNT: + return "" + if not is_mux_phase2_model_condition(condition): + return "" + + group_dir = output_root / f"HEROS_{group_name}" + p = raw_eval_path(group_dir, dataset, condition) + if p is None or not p.exists(): + return "" + + try: + df = pd.read_csv(p) + except Exception: + return "" + + # Required columns in raw eval files + if "test_balanced_accuracy" not in df.columns or "rule_count" not in df.columns: + return "" + + acc = pd.to_numeric(df["test_balanced_accuracy"], errors="coerce") + rc = pd.to_numeric(df["rule_count"], errors="coerce") + + ideal_rc = IDEAL_MUX_RULE_COUNT[dataset] + + # acc == 1.0 with tolerance; rule_count matches ideal after rounding + hits = ((acc >= 1.0 - 1e-12) & (rc.round() == ideal_rc)).sum() + + return f"{int(hits)}/{IDEAL_DENOM}" + + + +# ---------------------------- +# Table builder +# ---------------------------- + +def build_table(output_root: Path, allowed_groups: set[str], *, baseline_map: dict[str, str], alpha: float, sig_lookup: dict | None = None) -> pd.DataFrame: + rows = [] + + if not output_root.exists(): + raise FileNotFoundError(f"Output root does not exist: {output_root}") + + # Only iterate over the selected groups (and only if they exist) + group_dirs = [] + for g in sorted(allowed_groups): + gp = output_root / f"HEROS_{g}" + if gp.exists() and gp.is_dir(): + group_dirs.append(gp) + + if not group_dirs: + return pd.DataFrame() + + for group_dir in group_dirs: + group_name = group_dir.name.replace("HEROS_", "", 1) + + for dataset_dir in sorted([p for p in group_dir.iterdir() if p.is_dir()], key=lambda p: p.name): + mean_path = dataset_dir / "mean_seed_evaluation_summary.csv" + sd_path = dataset_dir / "sd_seed_evaluation_summary.csv" + merged = read_mean_sd(mean_path, sd_path) + if merged.empty: + continue + + for cond in TARGET_ROWS: + record = { + "Dataset": dataset_dir.name, + "Algorithm Config.": group_dir.name, + } + record.update(extract_one_condition( + merged, + cond, + output_root=output_root, + dataset=dataset_dir.name, + group_name=group_name, + baseline_map=baseline_map, + alpha=alpha, + sig_lookup=sig_lookup, + )) + rows.append(record) + + if not rows: + return pd.DataFrame() + + df = pd.DataFrame(rows) + + col_order = ["Dataset", "Algorithm Config.", "Condition", "Ideal Solution Count"] + list(METRICS.keys()) + df = df[col_order] + + cond_order = {c: i for i, c in enumerate(TARGET_ROWS)} + df["__cond_order"] = df["Condition"].map(cond_order).fillna(10_000).astype(int) + + df = df.sort_values( + by=["Dataset", "Algorithm Config.", "__cond_order"], + ascending=[True, True, True], + kind="mergesort" + ).drop(columns="__cond_order").reset_index(drop=True) + + return df + + +# ---------------------------- +# Plot helpers (unchanged) +# ---------------------------- + +def collect_boxplot_data(output_root: Path, allowed_groups: set[str], conditions: list[str], metric_col: str) -> pd.DataFrame: + rows = [] + for g in sorted(allowed_groups): + group_dir = output_root / f"HEROS_{g}" + if not group_dir.exists(): + continue + + for dataset_dir in sorted([p for p in group_dir.iterdir() if p.is_dir()], key=lambda p: p.name): + dataset = dataset_dir.name + for cond in conditions: + pth = raw_eval_path(group_dir, dataset, cond) + if pth is None: + continue + try: + df = pd.read_csv(pth) + except Exception: + continue + if metric_col not in df.columns: + continue + for v in pd.to_numeric(df[metric_col], errors="coerce").dropna().tolist(): + rows.append({ + "Dataset": dataset, + "Algorithm Config.": group_dir.name, + "Condition": cond, + "Value": float(v), + }) + return pd.DataFrame(rows) + + +def format_dataset_label(ds: str) -> str: + if "multiplexer" in ds: + try: + return ds.split("_multiplexer_")[1].split("_bit")[0] + except Exception: + return ds + return ds.split("_")[0] + + +def pretty_config_label(cfg: str) -> str: + if cfg.endswith("default"): + return "HEROS" + if cfg.endswith("default_tree_bstrap"): + return "HEROS-Tree" + if cfg.endswith("equal_tree_bstrap"): + return "HEROS-Tree-Alt" + return cfg + + +def make_grouped_boxplot_by_dataset( + long_df: pd.DataFrame, + out_png: Path, + ylabel: str, + conditions_in_order: list[str], + figsize=(15, 7), +): + if long_df.empty: + print(f"[WARN] No data for plot: {out_png.name}") + return + + DISTINCT_COLORS = [ + "#1f77b4", "#d62728", "#2ca02c", "#ff7f0e", "#9467bd", + "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf", + ] + + datasets = sorted(long_df["Dataset"].unique()) + configs = sorted(long_df["Algorithm Config."].unique()) + present_conditions = set(long_df["Condition"].unique()) + conditions = [c for c in conditions_in_order if c in present_conditions] + + box_width = 0.05 + group_spacing = 0.05 + dataset_gap = 0.10 + + hatch_cycle = ["", "///", "..."] + hatch_by_config = {cfg: hatch_cycle[i % len(hatch_cycle)] for i, cfg in enumerate(configs)} + + if len(conditions) > len(DISTINCT_COLORS): + raise ValueError(f"Not enough distinct colors for {len(conditions)} conditions") + color_by_condition = {cond: DISTINCT_COLORS[i] for i, cond in enumerate(conditions)} + + fig, ax = plt.subplots(figsize=figsize) + + base_x = 0.0 + xticks, xtick_labels = [], [] + x_positions_used = [] + last_block_top_anchor_x = None + + for ds_i, ds in enumerate(datasets): + n_groups = len(conditions) * len(configs) + block_width = (n_groups - 1) * group_spacing + block_right = base_x + block_width + block_center = base_x + block_width / 2.0 + + xticks.append(block_center) + xtick_labels.append(format_dataset_label(ds)) + + g_i = 0 + for cond in conditions: + for cfg in configs: + sub = long_df[ + (long_df["Dataset"] == ds) & + (long_df["Condition"] == cond) & + (long_df["Algorithm Config."] == cfg) + ]["Value"].to_numpy() + + if sub.size > 0: + x = base_x + g_i * group_spacing + x_positions_used.append(x) + bp = ax.boxplot( + [sub], + positions=[x], + widths=box_width, + patch_artist=True, + showmeans=True, + meanprops=dict(marker="o", markerfacecolor="black", markeredgecolor="white", markersize=4), + medianprops=dict(color="yellow", linewidth=1.5), + ) + + for box in bp["boxes"]: + box.set_facecolor(color_by_condition[cond]) + box.set_hatch(hatch_by_config[cfg]) + box.set_edgecolor("black") + box.set_linewidth(1.0) + + for w in bp["whiskers"]: + w.set_color("black") + w.set_linewidth(1.0) + for c in bp["caps"]: + c.set_color("black") + c.set_linewidth(1.0) + + g_i += 1 + + if ds_i == len(datasets) - 1: + last_block_top_anchor_x = block_right - 0.5 * group_spacing + + base_x += block_width + dataset_gap + + ax.set_ylabel(ylabel, fontsize=14) + ax.set_xticks(xticks) + list = enumerate(datasets) + check = next(list)[1] + if "multiplexer" in check: + ax.set_xlabel("MUX Dataset", fontsize=14) + else: + ax.set_xlabel("GAMETES Dataset", fontsize=14) + ax.set_xticklabels(xtick_labels, rotation=0, ha="center", fontsize=14) + ax.tick_params(axis="y", labelsize=14) + + if x_positions_used: + xmin = min(x_positions_used) - box_width / 2.0 + xmax = max(x_positions_used) + box_width / 2.0 + ax.set_xlim(xmin, xmax) + ax.margins(x=0) + + legend_handles = [] + for cfg in configs: + legend_handles.append(Patch(facecolor="white", edgecolor="black", hatch=hatch_by_config[cfg], + label=pretty_config_label(cfg))) + for cond in conditions: + lab = cond.replace("default_model_", "").replace("test_selected_model_", "") + lab = lab + " Iterations" + legend_handles.append(Patch(facecolor=color_by_condition[cond], edgecolor="black", label=lab)) + + if last_block_top_anchor_x is None: + ax.legend(handles=legend_handles, loc="upper left", fontsize=14, frameon=True) + else: + ax.legend( + handles=legend_handles, + loc="upper left", + #bbox_to_anchor=(last_block_top_anchor_x, 1.0), + #bbox_transform=ax.transData, + fontsize=13, + frameon=True, + borderaxespad=0.2, + labelspacing=0.35, + handlelength=1.8, + handletextpad=0.6, + ) + + fig.tight_layout() + out_png.parent.mkdir(parents=True, exist_ok=True) + fig.savefig(out_png, dpi=200) + plt.close(fig) + print(f"✅ Saved plot: {out_png}") + + +# ---------------------------- +# Main +# ---------------------------- + +def main(): + p = argparse.ArgumentParser(description="Generate HEROS combined summary table from summary CSV outputs (with significance).") + p.add_argument("--o", dest="outputPath", required=True, + help="Path to output directory (the folder containing HEROS_/ folders).") + p.add_argument("--groups", dest="groups", required=True, + help="Comma-separated group names to include (WITHOUT 'HEROS_' prefix).") + p.add_argument("--outcsv", dest="outcsv", default="HEROS_Combined_Table.csv", + help="Output CSV file name (written inside --o).") + p.add_argument("--baseline-map", dest="baseline_map", + default="multiplexer:mux_cv_default,gametes:gametes_cv_default", + help="Per-family baselines for significance. Format: 'multiplexer:,gametes:'.") + p.add_argument("--alpha", dest="alpha", type=float, default=0.05, + help="Significance threshold p-value / FDR target (default 0.05).") + + args = p.parse_args() + + output_root = Path(args.outputPath).resolve() + allowed_groups = {g.strip() for g in args.groups.split(",") if g.strip()} + + baseline_map = parse_baseline_map(args.baseline_map) + alpha = args.alpha + + print(f"Using baseline map: {baseline_map} (alpha={alpha})") + + tests_df = collect_significance_tests( + output_root, + allowed_groups, + baseline_map=baseline_map, + ) + tests_df = apply_fdr_bh_by_metric(tests_df, alpha=alpha) + sig_lookup = build_sig_lookup(tests_df) + + combined = build_table( + output_root, + allowed_groups, + baseline_map=baseline_map, + alpha=alpha, + sig_lookup=sig_lookup, + ) + + if combined.empty: + print(f"[WARN] No valid mean/sd summary CSVs found under: {output_root} for groups: {sorted(allowed_groups)}") + return + + out_path = output_root / args.outcsv + combined.to_csv(out_path, index=False) + print(f"✅ Combined table saved to: {out_path}") + + tests_out_path = output_root / args.outcsv.replace(".csv", "_significance_tests_long.csv") + tests_df.to_csv(tests_out_path, index=False) + print(f"✅ Significance test details saved to: {tests_out_path}") + + # ---- ALWAYS generate boxplots ---- + base_plot_dir = output_root / "heros_boxplots" + (base_plot_dir / "multiplexer").mkdir(parents=True, exist_ok=True) + (base_plot_dir / "gametes").mkdir(parents=True, exist_ok=True) + + plot_specs = [ + ("Phase1", PHASE1_CONDITIONS, "Phase I Tracking"), + ("Phase2_default", PHASE2_DEFAULT_CONDITIONS, "Phase II Default Model Tracking"), + ("Phase2_testsel", PHASE2_TESTSEL_CONDITIONS, "Phase II Test-Selected Tracking"), + ] + + splits = [ + ("multiplexer", MUX_DATASETS), + ("gametes", GAMETES_DATASETS), + ] + + for tag, conds, _pretty in plot_specs: + for metric_name, (metric_col, _dec) in METRICS.items(): + df_long = collect_boxplot_data(output_root, allowed_groups, conds, metric_col) + + ylabel = metric_name + if metric_col == "run_time" and not df_long.empty: + df_long = df_long.copy() + df_long["Value"] = df_long["Value"] / 60.0 + ylabel = "Run Time (Minutes)" + + for split_name, dataset_set in splits: + df_split = df_long[df_long["Dataset"].isin(dataset_set)] + out_png = base_plot_dir / split_name / f"{tag}_{metric_col}_boxplot.png" + + make_grouped_boxplot_by_dataset( + df_split, + out_png, + ylabel=ylabel, + conditions_in_order=conds, + figsize=(15, 7), + ) + + +if __name__ == "__main__": + main() diff --git a/evaluation/experiments/heros_scripts/run_commands.txt b/evaluation/experiments/heros_scripts/run_commands.txt new file mode 100644 index 0000000..71739fb --- /dev/null +++ b/evaluation/experiments/heros_scripts/run_commands.txt @@ -0,0 +1,126 @@ +### Run Commands for HEROS Alternation Scheme analyses +## General Useful Commands +#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +# module load git +# git clone --single-branch --branch dev_gabe_to_merge https://github.com/UrbsLab/heros.git +# pip install -r heros/requirements.txt + +##Cluster Space check: +du -sh folder/ #reports human readable summary of space used in folder +##Delete all files of a given type +find /path/to/folder -type f -name "*.pickle" -delete + +#deleting files/folders +rm -r folder + +#copy directory recursively +cp -r /project/kamoun_shared/output_shared/heros_gecco/output/ExSTraCS_gametes_cv /project/kamoun_shared/output_shared/heros_gecco2/output/ +cp -r /project/kamoun_shared/output_shared/heros_gecco/output/ExSTraCS_multiplexer_cv /project/kamoun_shared/output_shared/heros_gecco2/output/ +cp -r /project/kamoun_shared/output_shared/heros_gecco/output/ExSTraCS_multiplexer_cv_nu10 /project/kamoun_shared/output_shared/heros_gecco2/output/ +#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + +## Cross Validation Partitioning --------------------------------------------------------------------------------------------- +python run_CV_Partitioner.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data --w /project/kamoun_shared/data_shared/heros_sim_data --o gametes_data_cv --cv 10 --l Class +python run_CV_Partitioner.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data --w /project/kamoun_shared/data_shared/heros_sim_data --o multiplexer_data_cv --cv 10 --l Class +#----------------------------------------------------------------------------------------------------------------------------- + +## MultiSURF Training --------------------------------------------------------------------------------------------- +python run_multisurf_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv --cv 10 --m 2000 --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal +python run_multisurf_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv --cv 10 --m 2000 --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal +#------------------------------------------------------------------------------------------------------------------ + +SHORT ClUSTER TEST: ------------------------------------------------------------------------------------------------ + +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/test_multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o quicktest --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 1 --r 1 --m limit --in target_acc --it 10000 --ps 500 --nu 1 --mi 50 --ms 100 --c sub --tp 1000 --sr 500,1000,10000 --sm 5,10,50 --m equal --a 5 --pt dt_bstrap + + +## HEROS 2026 Paper Evaluations + +### GAMETES DATA +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o gametes_cv_default --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100,200 --m None --a 0 --check --resub + +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o gametes_cv_default_tree_bstrap --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100,200 --m None --a 0 --pt dt_bstrap --check --resub + +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o gametes_cv_equal_tree_bstrap --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100,200 --m equal --a 5 --pt dt_bstrap --check --resub + + +### MUX DATA +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o mux_cv_default --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100,200 --m None --a 0 --check --resub + +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o mux_cv_default_tree_bstrap --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100,200 --m None --a 0 --pt dt_bstrap --check --resub + +python run_heros.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_v0.3_dev --o mux_cv_equal_tree_bstrap --ekf /project/kamoun_shared/output_shared/heros_gecco_2025/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100,200 --m equal --a 5 --pt dt_bstrap --check --resub + + + +## SUMMARY SCRIPTS +### GAMETES DATA +python run_heros_sum.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o gametes_cv_default \ + --cv 10 \ + --r 20 \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal + +python run_heros_sum.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o gametes_cv_default_tree_bstrap \ + --cv 10 \ + --r 20 \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal + +python run_heros_sum.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o gametes_cv_equal_tree_bstrap \ + --cv 10 \ + --r 20 \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal + +### MUX DATA +python run_heros_sum.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o mux_cv_default \ + --cv 10 \ + --r 20 \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal + +python run_heros_sum.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o mux_cv_default_tree_bstrap \ + --cv 10 \ + --r 20 \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal + +python run_heros_sum.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o mux_cv_equal_tree_bstrap \ + --cv 10 \ + --r 20 \ + --rc LSF \ + --rm 4 \ + --q i2c2_normal + + + + +## TABLE SUMMARY SCRIPT +python run_heros_table.py \ + --w /project/kamoun_shared/output_shared/heros_v0.3_dev \ + --o output \ + --groups mux_cv_default,mux_cv_default_tree_bstrap,gametes_cv_default,gametes_cv_default_tree_bstrap,mux_cv_equal_tree_bstrap,gametes_cv_equal_tree_bstrap \ + --baseline-map multiplexer:mux_cv_default,gametes:gametes_cv_default \ + --alpha 0.05 \ + --rc LSF \ + --rm 8 \ + --q i2c2_normal \ + --outcsv HEROS_Combined_Table.csv \ No newline at end of file diff --git a/evaluation/experiments/run_heros_hpc.py b/evaluation/experiments/heros_scripts/run_heros.py similarity index 79% rename from evaluation/experiments/run_heros_hpc.py rename to evaluation/experiments/heros_scripts/run_heros.py index 81bb9ca..92fd6a4 100644 --- a/evaluation/experiments/run_heros_hpc.py +++ b/evaluation/experiments/heros_scripts/run_heros.py @@ -1,15 +1,15 @@ import sys import os -import pandas as pd -import matplotlib.pyplot as plt -import numpy as np -import seaborn as sns -import scipy.stats as scs -import random -from sklearn.preprocessing import StandardScaler -from sklearn.experimental import enable_iterative_imputer -from sklearn.impute import IterativeImputer -import csv +#import pandas as pd +#import matplotlib.pyplot as plt +#import numpy as np +#import seaborn as sns +#import scipy.stats as scs +#import random +#from sklearn.preprocessing import StandardScaler +#from sklearn.experimental import enable_iterative_imputer +#from sklearn.impute import IterativeImputer +#import csv import time import argparse @@ -30,7 +30,11 @@ def main(argv): #Experiment Parameters parser.add_argument('--cv', dest='cv_partitions', help='number of cv partitions', type=int, default = 10) parser.add_argument('--r', dest='random_seeds', help='number of random seeds to run', type=int, default= 30) - parser.add_argument('--in', dest='model_pop_init', help='model population initialization method (Must be random, probabilistic, bootstrap, or target_acc)', type=str, default='random') + parser.add_argument('--pt', dest='rule_pop_init', help='type of population initialization (load, dt, dt_bstrap, or None)', type=str, default='None') + parser.add_argument('--a', dest='alternate', help='phase alternations', type = int, default = 0) + parser.add_argument('--m', dest='alternate_mode', help='alternation mode (Must be "limit", "converge", "equal", or None)', type = str, default='None') + #Unused Experimental + parser.add_argument('--fb', dest='feedback', action='store_true', help='use alternation weights') #Critical HEROS Parameters parser.add_argument('--ot', dest='outcome_type', help='outcome type', type=str, default='class') parser.add_argument('--it', dest='iterations', help='number of rule training cycles', type=int, default=100000) @@ -38,6 +42,7 @@ def main(argv): parser.add_argument('--nu', dest='nu', help='power parameter', type=int, default=1) parser.add_argument('--mi', dest='model_iterations', help='number of model training cycles', type=int, default=500) parser.add_argument('--ms', dest='model_pop_size', help='maximum model population size ', type=int, default=100) + parser.add_argument('--in', dest='model_pop_init', help='model population initialization method (Must be random, probabilistic, bootstrap, or target_acc)', type=str, default='random') #Other HEROS Parameters parser.add_argument('--cp', dest='cross_prob', help='probability of applying crossover in rule discovery', type=float, default=0.8) parser.add_argument('--mp', dest='mut_prob', help='probability of applying mutation in rule discovery', type=float, default=0.04) @@ -49,7 +54,6 @@ def main(argv): parser.add_argument('--ft', dest='feat_track', help='feature tracking mechanism', type=str, default='None') parser.add_argument('--ng', dest='new_gen', help='proportion of max model population size', type=float, default=1.0) parser.add_argument('--mg', dest='merge_prob', help='probability of applying merge in model discovery', type=float, default=0.1) - parser.add_argument('--pt', dest='rule_pop_init', help='type of population initialization (load, dt, or None)', type=str, default='None') parser.add_argument('--c', dest='compaction', help='rule-compaction strategy', type=str, default='sub') parser.add_argument('--tp', dest='track_performance', help='performance tracking', type=int, default=1000) parser.add_argument('--sr', dest='stored_rule_iterations', help='comma-separated string indicating rule pop iterations to run full evaluation', type=str, default='None') @@ -57,19 +61,23 @@ def main(argv): parser.add_argument('--rs', dest='random_state', help='random state seed', type=int, default=42) #parser.add_argument('--v', dest='verbose', help='boolean flag to run in verbose mode', type=bool, default=False) parser.add_argument('--v', dest='verbose', help='boolean flag to run in verbose mode', action='store_true') + parser.add_argument('--min', dest='min_output', help='boolean flag to minimize saved HEROS output', action='store_true') + #HPC parameters parser.add_argument('--rc', dest='run_cluster', help='cluster type', type=str, default='LSF') parser.add_argument('--rm', dest='reserved_memory', help='reserved memory for job', type=int, default= 4) parser.add_argument('--q', dest='queue', help='cluster queue name', type=str, default= 'i2c2_normal') - #parser.add_argument('--check', dest='check', help='boolean flag to check and report on what jobs have not yet completed', type=bool, default= False) + #parser.add_argument('--check', dest='check', help='boolean flag to check and report on what jobs have not yet completed', type=bool, action= False) parser.add_argument('--check', dest='check', help='boolean flag to check and report on what jobs have not yet completed', action='store_true') #parser.add_argument('--resub', dest='resubmit', help='boolean flag to resubmit incomplete jobs', type=bool, default= False) parser.add_argument('--resub', dest='resubmit', help='boolean flag to resubmit incomplete jobs', action='store_true') #---------------------------------------------------------------------------------------------- options=parser.parse_args(argv[1:]) + print(options) #Script Parameters datafolder = options.datafolder #full path to target dataset writepath = options.writepath + print(writepath) outputfolder = options.outputfolder ekfolder = options.ekfolder #Dataset Parameters @@ -79,10 +87,9 @@ def main(argv): #Experiment Parameters cv_partitions = options.cv_partitions random_seeds = options.random_seeds - if options.model_pop_init is None or options.model_pop_init == 'None': - model_pop_init = None - else: - model_pop_init = str(options.model_pop_init) + alternate = options.alternate + alternate_mode = options.alternate_mode + feedback = options.feedback #Critical HEROS Parameters outcome_type = options.outcome_type @@ -121,6 +128,11 @@ def main(argv): else: random_state = int(options.random_state) verbose = options.verbose + if options.model_pop_init is None or options.model_pop_init == 'None': + model_pop_init = None + else: + model_pop_init = str(options.model_pop_init) + min_output = options.min_output #HPC parameters run_cluster = options.run_cluster reserved_memory = options.reserved_memory @@ -128,7 +140,6 @@ def main(argv): check = options.check resubmit = options.resubmit algorithm = 'HEROS' - #Folder Management------------------------------ #Main Write Path----------------- if not os.path.exists(writepath): @@ -152,7 +163,7 @@ def main(argv): # Experiment loop to submit jobs (datasets, random seeds, cv partitions) jobCount = 0 missing_count = 0 - for entry in os.listdir(datafolder): #for each subfolder within target dataset folder + for entry in os.listdir(datafolder): #for each subfolder within target dataset folder if os.path.isdir(os.path.join(datafolder,entry)): datapath = os.path.join(datafolder,entry) #Specify output folder path @@ -182,24 +193,25 @@ def main(argv): if not check: #Regular Job submission run if run_cluster == 'LSF': - submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose) + submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose,min_output,alternate,alternate_mode,feedback) jobCount +=1 elif run_cluster == 'SLURM': - submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose) + submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose,min_output,alternate,alternate_mode,feedback) jobCount +=1 else: print('ERROR: Cluster type not found') else: #check what runs have completed (based on last file generated by jobs) target_file_path = outputPath+'/runtimes.csv' + print(target_file_path) if not os.path.exists(target_file_path): print('Missing: '+str(outputPath)) missing_count += 1 if resubmit: if run_cluster == 'LSF': - submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose) + submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose,min_output,alternate,alternate_mode,feedback) jobCount +=1 elif run_cluster == 'SLURM': - submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose) + submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose,min_output,alternate,alternate_mode,feedback) jobCount +=1 else: print('ERROR: Cluster type not found') @@ -208,7 +220,7 @@ def main(argv): print(str(missing_count)+' jobs incomplete') #UPenn Cluster -def submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose): +def submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose,min_output,alternate,alternate_mode,feedback): job_ref = str(time.time()) job_name = 'HEROS_'+full_data_name+'_seed_'+str(target_random_seed)+'_'+job_ref job_path = scratchPath+'/'+job_name+ '_run.sh' @@ -220,12 +232,15 @@ def submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_n sh_file.write('#BSUB -M ' + str(reserved_memory) + 'GB' + '\n') sh_file.write('#BSUB -o ' + logPath+'/'+job_name + '.o\n') sh_file.write('#BSUB -e ' + logPath+'/'+job_name + '.e\n') - sh_file.write('python job_heros_hpc.py'+' --d '+str(full_data_path)+' --o '+str(outputPath)+' --ekf '+str(ekfolder)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --in '+str(model_pop_init)+' --ot '+str(outcome_type)+' --it '+str(iterations)+' --ps '+str(pop_size)+' --nu '+str(nu)+' --mi '+str(model_iterations)+' --ms '+str(model_pop_size)+' --cp '+str(cross_prob)+' --mp '+str(mut_prob)+' --b '+str(beta)+' --ts '+str(theta_sel)+' --ff '+str(fitness_function)+' --s '+str(subsumption)+' --rsl '+str(rsl)+' --ft '+str(feat_track)+' --ng '+str(new_gen)+' --mg '+str(merge_prob)+' --pt '+str(rule_pop_init)+' --c '+str(compaction)+' --tp '+str(track_performance)+' --sr '+str(stored_rule_iterations)+' --sm '+str(stored_model_iterations)+' --rs '+str(target_random_seed)+' --v '+str(verbose)+'\n') + fb_arg = ' --fb' if feedback else '' + verbose_arg = ' --v' if verbose else '' + min_arg = ' --min' if min_output else '' + sh_file.write('python job_heros.py'+' --d '+str(full_data_path)+' --o '+str(outputPath)+' --ekf '+str(ekfolder)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column) + ' --in '+str(model_pop_init)+' --ot '+str(outcome_type)+' --it '+str(iterations)+' --ps '+str(pop_size)+' --nu '+str(nu)+' --mi '+str(model_iterations)+' --ms '+str(model_pop_size)+' --cp '+str(cross_prob)+' --mp '+str(mut_prob)+' --b '+str(beta)+' --ts '+str(theta_sel)+' --ff '+str(fitness_function)+' --s '+str(subsumption)+' --rsl '+str(rsl)+' --ft '+str(feat_track)+' --ng '+str(new_gen)+' --mg '+str(merge_prob)+' --pt '+str(rule_pop_init)+' --c '+str(compaction)+' --tp '+str(track_performance)+' --sr '+str(stored_rule_iterations)+' --sm '+str(stored_model_iterations)+' --rs '+str(target_random_seed)+ verbose_arg + min_arg+ ' --a ' + str(alternate)+ ' --m ' + str(alternate_mode) + fb_arg +'\n') sh_file.close() os.system('bsub < ' + job_path) - + #Cedars Cluster -def submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose): +def submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data_name,outputPath,full_data_path,ekfolder,outcome_label,instanceID_label,excluded_column,model_pop_init,outcome_type,iterations,pop_size,nu,model_iterations,model_pop_size,cross_prob,mut_prob,beta,theta_sel,fitness_function,subsumption,rsl,feat_track,new_gen,merge_prob,rule_pop_init,compaction,track_performance,stored_rule_iterations,stored_model_iterations,target_random_seed,verbose,min_output,alternate,alternate_mode,feedback): job_ref = str(time.time()) job_name = 'HEROS_'+full_data_name+'_seed_'+str(target_random_seed)+'_'+job_ref job_path = scratchPath+'/'+job_name+ '_run.sh' @@ -237,7 +252,10 @@ def submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,full_data # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') sh_file.write('#SBATCH -o ' + logPath+'/'+job_name + '.o\n') sh_file.write('#SBATCH -e ' + logPath+'/'+job_name + '.e\n') - sh_file.write('srun python job_heros_hpc.py'+' --d '+str(full_data_path)+' --o '+str(outputPath)+' --ekf '+str(ekfolder)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --in '+str(model_pop_init)+' --ot '+str(outcome_type)+' --it '+str(iterations)+' --ps '+str(pop_size)+' --nu '+str(nu)+' --mi '+str(model_iterations)+' --ms '+str(model_pop_size)+' --cp '+str(cross_prob)+' --mp '+str(mut_prob)+' --b '+str(beta)+' --ts '+str(theta_sel)+' --ff '+str(fitness_function)+' --s '+str(subsumption)+' --rsl '+str(rsl)+' --ft '+str(feat_track)+' --ng '+str(new_gen)+' --mg '+str(merge_prob)+' --pt '+str(rule_pop_init)+' --c '+str(compaction)+' --tp '+str(track_performance)+' --sr '+str(stored_rule_iterations)+' --sm '+str(stored_model_iterations)+' --rs '+str(target_random_seed)+' --v '+str(verbose)+'\n') + fb_arg = ' --fb' if feedback else '' + verbose_arg = ' --v' if verbose else '' + min_arg = ' --min' if min_output else '' + sh_file.write('srun python job_heros.py'+' --d '+str(full_data_path)+' --o '+str(outputPath)+' --ekf '+str(ekfolder)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --in '+str(model_pop_init)+' --ot '+str(outcome_type)+' --it '+str(iterations)+' --ps '+str(pop_size)+' --nu '+str(nu)+' --mi '+str(model_iterations)+' --ms '+str(model_pop_size)+' --cp '+str(cross_prob)+' --mp '+str(mut_prob)+' --b '+str(beta)+' --ts '+str(theta_sel)+' --ff '+str(fitness_function)+' --s '+str(subsumption)+' --rsl '+str(rsl)+' --ft '+str(feat_track)+' --ng '+str(new_gen)+' --mg '+str(merge_prob)+' --pt '+str(rule_pop_init)+' --c '+str(compaction)+' --tp '+str(track_performance)+' --sr '+str(stored_rule_iterations)+' --sm '+str(stored_model_iterations)+' --rs '+str(target_random_seed)+ verbose_arg + min_arg + ' --a ' + str(alternate)+ ' --m ' + str(alternate_mode) + fb_arg +'\n') sh_file.close() os.system('sbatch ' + job_path) diff --git a/evaluation/experiments/heros_scripts/run_heros_sum.py b/evaluation/experiments/heros_scripts/run_heros_sum.py new file mode 100644 index 0000000..7252cc5 --- /dev/null +++ b/evaluation/experiments/heros_scripts/run_heros_sum.py @@ -0,0 +1,124 @@ +# I2C2-Documentation/run_heros_alt_sum.py +# +# Submits the summary aggregation as a single cluster job (LSF or SLURM). +# - Minimal args: --w (writepath), --o (outputfolder), --cv, --r +# - Writes logs into writepath/logs +# - Calls: python I2C2-Documentation/job_heros_alt_sum.py --o --cv ... --r ... + +import os +import sys +import time +import argparse + +def ensure_dir(path: str) -> None: + if not os.path.exists(path): + os.makedirs(path, exist_ok=True) + +def submit_lsf(scratch_path, log_path, reserved_memory, queue, output_root, cv_partitions, random_seeds, outputfolder, + outcome_label, instanceID_label, excluded_column): + job_ref = str(time.time()) + job_name = f"HEROS_summary_{outputfolder}_{job_ref}" + job_script = os.path.join(scratch_path, f"{job_name}_run.sh") + + with open(job_script, "w") as sh: + sh.write("#!/bin/bash\n") + sh.write(f"#BSUB -q {queue}\n") + sh.write(f"#BSUB -J {job_name}\n") + sh.write(f"#BSUB -R \"rusage[mem={reserved_memory}G]\"\n") + sh.write(f"#BSUB -M {reserved_memory}GB\n") + sh.write(f"#BSUB -o {os.path.join(log_path, job_name)}.o\n") + sh.write(f"#BSUB -e {os.path.join(log_path, job_name)}.e\n") + sh.write( + "python -u job_heros_sum.py" + f" --o {output_root}" + f" --ol {outcome_label} --il {instanceID_label} --el {excluded_column}" + f" --cv {cv_partitions} --r {random_seeds}\n" + ) + + os.system(f"bsub < {job_script}") + +def submit_slurm(scratch_path, log_path, reserved_memory, queue, output_root, cv_partitions, random_seeds, outputfolder, + outcome_label, instanceID_label, excluded_column): + job_ref = str(time.time()) + job_name = f"HEROS_summary_{outputfolder}_{job_ref}" + job_script = os.path.join(scratch_path, f"{job_name}_run.sh") + + with open(job_script, "w") as sh: + sh.write("#!/bin/bash\n") + sh.write(f"#SBATCH -p {queue}\n") + sh.write(f"#SBATCH --job-name={job_name}\n") + sh.write(f"#SBATCH --mem={reserved_memory}G\n") + sh.write(f"#SBATCH -o {os.path.join(log_path, job_name)}.o\n") + sh.write(f"#SBATCH -e {os.path.join(log_path, job_name)}.e\n") + sh.write( + "srun python -u job_heros_sum.py" + f" --o {output_root}" + f" --ol {outcome_label} --il {instanceID_label} --el {excluded_column}" + f" --cv {cv_partitions} --r {random_seeds}\n" + ) + + os.system(f"sbatch {job_script}") + +def main(argv): + parser = argparse.ArgumentParser(description="Submit HEROS summary aggregation job.") + parser.add_argument("--w", dest="writepath", type=str, required=True, help="Base write path (contains output/, logs/, scratch/).") + parser.add_argument("--o", dest="outputfolder", type=str, required=True, help="Experiment output folder name (suffix after HEROS_).") + parser.add_argument("--ol", dest="outcome_label", type=str, default="Class") + parser.add_argument("--il", dest="instanceID_label", type=str, default="InstanceID") + parser.add_argument("--el", dest="excluded_column", type=str, default="Group") + parser.add_argument("--cv", dest="cv_partitions", type=int, default=10) + parser.add_argument("--r", dest="random_seeds", type=int, default=30) + parser.add_argument("--rc", dest="run_cluster", type=str, default="LSF", choices=["LSF", "SLURM"]) + parser.add_argument("--rm", dest="reserved_memory", type=int, default=4) + parser.add_argument("--q", dest="queue", type=str, default="i2c2_normal") + + args = parser.parse_args(argv[1:]) + + writepath = args.writepath + outputfolder = args.outputfolder + cv_partitions = args.cv_partitions + random_seeds = args.random_seeds + + algorithm = "HEROS" + output_root = os.path.join(writepath, "output", f"{algorithm}_{outputfolder}") + + # Ensure dirs exist + ensure_dir(writepath) + ensure_dir(os.path.join(writepath, "output")) + ensure_dir(os.path.join(writepath, "scratch")) + ensure_dir(os.path.join(writepath, "logs")) + ensure_dir(output_root) + + if args.run_cluster == "LSF": + submit_lsf( + scratch_path=os.path.join(writepath, "scratch"), + log_path=os.path.join(writepath, "logs"), + reserved_memory=args.reserved_memory, + queue=args.queue, + output_root=output_root, + cv_partitions=cv_partitions, + random_seeds=random_seeds, + outputfolder=outputfolder, + outcome_label=args.outcome_label, + instanceID_label=args.instanceID_label, + excluded_column=args.excluded_column, + ) + else: + submit_slurm( + scratch_path=os.path.join(writepath, "scratch"), + log_path=os.path.join(writepath, "logs"), + reserved_memory=args.reserved_memory, + queue=args.queue, + output_root=output_root, + cv_partitions=cv_partitions, + random_seeds=random_seeds, + outputfolder=outputfolder, + outcome_label=args.outcome_label, + instanceID_label=args.instanceID_label, + excluded_column=args.excluded_column, + ) + + print("1 summary job submitted successfully") + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/heros_scripts/run_heros_table.py b/evaluation/experiments/heros_scripts/run_heros_table.py new file mode 100644 index 0000000..88562b7 --- /dev/null +++ b/evaluation/experiments/heros_scripts/run_heros_table.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python3 +# run_heros_alt_table2.0.py +# +# Submits a single cluster job that generates a combined HEROS table +# (with per-family significance) restricted to specific experiment groups. +# +# Example: +# python run_heros_alt_table2.0.py \ +# --w /project/kamoun_shared/gabe/I2C2-Documentation \ +# --o output \ +# --groups mux_cv_default,mux_cv_default_tree_init,gametes_cv_default,gametes_cv_default_tree_init \ +# --baseline-map multiplexer:mux_cv_default,gametes:gametes_cv_default \ +# --alpha 0.05 \ +# --rc LSF --rm 8 --q i2c2_normal \ +# --outcsv HEROS_Combined_Table.csv + +import sys +import os +import time +import argparse +from pathlib import Path + + +def parse_args(argv): + p = argparse.ArgumentParser(description="Submit HEROS combined-table job to cluster (with significance).") + + # Paths + p.add_argument("--w", dest="writepath", type=str, required=True, + help="Path containing this script AND the job file (e.g., /project/.../I2C2-Documentation).") + p.add_argument("--o", dest="outputfolder", type=str, required=True, + help="Folder under --w that holds experiment outputs. Usually: output") + + # Which experiment groups to include (WITHOUT 'HEROS_' prefix) + p.add_argument("--groups", dest="groups", type=str, required=True, + help="Comma-separated group names under output/ (e.g., mux_cv_default,gametes_cv_default_tree_init)") + + # Output CSV name (written into output root) + p.add_argument("--outcsv", dest="outcsv", type=str, default="HEROS_Combined_Table.csv", + help="Name of the combined output CSV file.") + + # Significance controls + p.add_argument("--baseline-map", dest="baseline_map", type=str, + default="multiplexer:mux_cv_default,gametes:gametes_cv_default", + help="Per-family baselines for significance. Format: 'multiplexer:,gametes:'.") + p.add_argument("--alpha", dest="alpha", type=float, default=0.05, + help="Significance threshold p-value (default 0.05).") + + # HPC params + p.add_argument("--rc", dest="run_cluster", type=str, default="LSF", choices=["LSF", "SLURM"]) + p.add_argument("--rm", dest="reserved_memory", type=int, default=8, help="GB") + p.add_argument("--q", dest="queue", type=str, default="i2c2_normal") + + return p.parse_args(argv[1:]) + + +def main(argv): + args = parse_args(argv) + + writepath = Path(args.writepath).resolve() + output_root = (writepath / args.outputfolder).resolve() + scratchPath = (writepath / "scratch").resolve() + logPath = (writepath / "logs").resolve() + + scratchPath.mkdir(parents=True, exist_ok=True) + logPath.mkdir(parents=True, exist_ok=True) + + # Job python file (must exist in writepath) + job_py = "job_heros_table.py" + #if not job_py.exists(): + # print(f"[ERR] job file not found: {job_py}") + # return 2 + + groups_csv = ",".join([g.strip() for g in args.groups.split(",") if g.strip()]) + if not groups_csv: + print("[ERR] --groups must contain at least one group name.") + return 2 + + job_cmd = ( + f"python {job_py} " + f"--o {output_root} " + f"--groups {groups_csv} " + f"--outcsv {args.outcsv} " + f"--baseline-map {args.baseline_map} " + f"--alpha {args.alpha} " + ) + + job_ref = str(int(time.time())) + job_name = f"HEROS_table_{output_root.name}_{job_ref}" + job_sh = scratchPath / f"{job_name}_run.sh" + + with open(job_sh, "w") as f: + f.write("#!/bin/bash\n") + if args.run_cluster.upper() == "LSF": + f.write(f"#BSUB -q {args.queue}\n") + f.write(f"#BSUB -J {job_name}\n") + f.write(f"#BSUB -R \"rusage[mem={args.reserved_memory}G]\"\n") + f.write(f"#BSUB -M {args.reserved_memory}GB\n") + f.write(f"#BSUB -o {logPath}/{job_name}.o\n") + f.write(f"#BSUB -e {logPath}/{job_name}.e\n") + f.write(job_cmd + "\n") + else: + f.write(f"#SBATCH -p {args.queue}\n") + f.write(f"#SBATCH --job-name={job_name}\n") + f.write(f"#SBATCH --mem={args.reserved_memory}G\n") + f.write(f"#SBATCH -o {logPath}/{job_name}.o\n") + f.write(f"#SBATCH -e {logPath}/{job_name}.e\n") + f.write(f"srun {job_cmd}\n") + + os.chmod(job_sh, 0o755) + + if args.run_cluster.upper() == "LSF": + os.system(f"bsub < {job_sh}") + print(f"[SUBMITTED][LSF] {job_sh}") + else: + os.system(f"sbatch {job_sh}") + print(f"[SUBMITTED][SLURM] {job_sh}") + + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/evaluation/experiments/job_heros_sum_hpc.py b/evaluation/experiments/job_heros_sum_hpc.py deleted file mode 100644 index 80f5ede..0000000 --- a/evaluation/experiments/job_heros_sum_hpc.py +++ /dev/null @@ -1,269 +0,0 @@ -import os -import sys -import argparse -import pickle -import pandas as pd -import numpy as np -import matplotlib.pyplot as plt -import seaborn as sns -from sklearn.metrics import confusion_matrix -sys.path.append('/project/kamoun_shared/code_shared/scikit-heros/') -from src.skheros.heros import HEROS -#from skheros.heros import HEROS #PIP INSTALL RUN - -def main(argv): - #ARGUMENTS:------------------------------------------------------------------------------------ - parser = argparse.ArgumentParser(description='') - #Script Parameters - parser.add_argument('--o', dest='outputPath', help='path to target output folder', type=str, default = 'mypath/myOutputFolder') - #Dataset Parameters - parser.add_argument('--ol', dest='outcome_label', help='outcome label (i.e. class label)', type=str, default = 'Class') - parser.add_argument('--il', dest='instanceID_label', help='label of instance ID column (if present)', type=str, default = 'InstanceID') - parser.add_argument('--el', dest='excluded_column', help='label of another column to drop (if present)', type=str, default = 'Group') - #Experiment Parameters - parser.add_argument('--cv', dest='cv_partitions', help='number of cv partitions', type=int, default = 10) - parser.add_argument('--r', dest='random_seeds', help='number of random seeds to run', type=int, default= 30) - - #---------------------------------------------------------------------------------------------- - options=parser.parse_args(argv[1:]) - #Script Parameters - outputPath = options.outputPath - #Dataset Parameters - outcome_label = options.outcome_label - instanceID_label = options.instanceID_label - excluded_column = options.excluded_column - #Experiment Parameters - cv_partitions = options.cv_partitions - random_seeds = options.random_seeds - - # Get Data Output Folder Name - folder_name = outputPath.rstrip('/').split('/')[-1] - - # Create CV level summary files - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - for i in range(0,random_seeds): - seed_level_path = os.path.join(data_level_path,'seed_'+str(i)) - dataframes = [] - for j in range(1,cv_partitions+1): - cv_level_path = os.path.join(seed_level_path,'cv_'+str(j)) - file_path = cv_level_path+'/evaluation_summary.csv' - #Load Eval File - df = pd.read_csv(file_path) - df_X = df.drop('Row Indexes', axis=1) - row_names = df['Row Indexes'] - dataframes.append(df_X) - #Make averages file - averaged_df_X = pd.concat(dataframes).groupby(level=0).mean() - combined_df = pd.concat([row_names, averaged_df_X], axis=1) - combined_df.to_csv(seed_level_path+'/mean_CV_evaluation_summary.csv', index=False) - #Make standard deviation file - sd_df_X = pd.concat(dataframes).groupby(level=0).std() - combined_df = pd.concat([row_names, sd_df_X], axis=1) - combined_df.to_csv(seed_level_path+'/sd_CV_evaluation_summary.csv', index=False) - - # Create seed level summary files - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - dataframes = [] - for i in range(0,random_seeds): - seed_level_path = os.path.join(data_level_path,'seed_'+str(i)) - file_path = seed_level_path+'/mean_CV_evaluation_summary.csv' - #Load Eval File - df = pd.read_csv(file_path) - df_X = df.drop('Row Indexes', axis=1) - row_names = df['Row Indexes'] - dataframes.append(df_X) - #Make averages file - averaged_df_X = pd.concat(dataframes).groupby(level=0).mean() - combined_df = pd.concat([row_names, averaged_df_X], axis=1) - combined_df.to_csv(data_level_path+'/mean_seed_evaluation_summary.csv', index=False) - #Make standard deviation file - sd_df_X = pd.concat(dataframes).groupby(level=0).std() - combined_df = pd.concat([row_names, sd_df_X], axis=1) - combined_df.to_csv(data_level_path+'/sd_seed_evaluation_summary.csv', index=False) - - # Create Global results list for each evaluation point - header = None - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - eval_point_list = {} #row index dictionary each with list of lists storing results list for every seed and cv combo - for i in range(0,random_seeds): - seed_level_path = os.path.join(data_level_path,'seed_'+str(i)) - for j in range(1,cv_partitions+1): - cv_level_path = os.path.join(seed_level_path,'cv_'+str(j)) - file_path = cv_level_path+'/evaluation_summary.csv' - #Load Eval File - df = pd.read_csv(file_path) - header = list(df.columns) - header.remove('Row Indexes') - for index, row in df.iterrows(): - #initialize dictionary entry - row_index = row['Row Indexes'] - if row_index not in eval_point_list: - eval_point_list[row_index] = [] - temp_list = list(row) - temp_list.remove(row_index) - eval_point_list[row_index].append(temp_list) - #print(eval_point_list) - #Create global evaluation summary for given dataset - for each in eval_point_list: - results = eval_point_list[each] - df_results = pd.DataFrame(results, columns=header) - df_results.to_csv(data_level_path+'/all_'+str(each)+'_evaluations.csv', index=False) - - - # Create Global (CV average) results list for each evaluation point - header = None - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - eval_point_list = {} #row index dictionary each with list of lists storing results list for every seed and cv combo - for i in range(0,random_seeds): - seed_level_path = os.path.join(data_level_path,'seed_'+str(i)) - file_path = seed_level_path+'/mean_CV_evaluation_summary.csv' - #Load Eval File - df = pd.read_csv(file_path) - header = list(df.columns) - header.remove('Row Indexes') - for index, row in df.iterrows(): - #initialize dictionary entry - row_index = row['Row Indexes'] - if row_index not in eval_point_list: - eval_point_list[row_index] = [] - temp_list = list(row) - temp_list.remove(row_index) - eval_point_list[row_index].append(temp_list) - #Create global evaluation summary for given dataset - for each in eval_point_list: - results = eval_point_list[each] - df_results = pd.DataFrame(results, columns=header) - df_results.to_csv(data_level_path+'/cv_ave_'+str(each)+'_evaluations.csv', index=False) - - #Make testing accuracy boxplots (all runs) - row_index = ['rule_500','rule_1000','rule_10000','rule_100000','rule_200000','rule_post_compact','test_selected_model_5','test_selected_model_10','test_selected_model_50','test_selected_model_100','test_selected_model_200'] - #for each in eval_point_list: - # row_index.append(each) - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - accuracy_values = [] - for each in row_index: #each eval iteration - #Load Eval File - file_path = data_level_path+'/all_'+str(each)+'_evaluations.csv' - df = pd.read_csv(file_path) - accuracy_values.append(df['test_balanced_accuracy']) - # Create a boxplot for all 10 accuracy columns - plt.figure(figsize=(10, 6)) - sns.boxplot(data=accuracy_values) - # Set the labels for the x-axis to represent each file - plt.xticks(ticks=range(len(row_index)), labels=row_index,rotation=90) - # Title and labels - plt.xlabel("Evaluation Points") - plt.ylabel("Balanced Testing Accuracy") - plt.savefig(data_level_path+'/boxplot_testing_accuracy_all.png', bbox_inches="tight") - - - #Make rule count boxplots (all runs) - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - count_values = [] - for each in row_index: #each eval iteration - #Load Eval File - file_path = data_level_path+'/all_'+str(each)+'_evaluations.csv' - df = pd.read_csv(file_path) - count_values.append(df['rule_count']) - # Create a boxplot for all 10 accuracy columns - plt.figure(figsize=(10, 6)) - sns.boxplot(data=count_values) - # Set the labels for the x-axis to represent each file - plt.xticks(ticks=range(len(row_index)), labels=row_index,rotation=90) - # Title and labels - plt.xlabel("Evaluation Points") - plt.ylabel("Rule Count") - plt.savefig(data_level_path+'/boxplot_rule_count_all.png', bbox_inches="tight") - - # Identify how many ideal MUX rules were identified at end of phase 1 population (pre and post compaction) - if 'multiplexer' in outputPath: #only do if we are evaluating MUX problem - mux_output_folders = {'A_multiplexer_6_bit_500_inst':6,'B_multiplexer_11_bit_5000_inst':11,'C_multiplexer_20_bit_10000_inst':20,'D_multiplexer_37_bit_10000_inst':37,'E_multiplexer_70_bit_20000_inst':70} - header = ['Dataset','Seed','CV','Ideal Count','Ideal Proportion'] - resultsList = [] - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if os.path.isdir(os.path.join(outputPath,entry)): - data_level_path = os.path.join(outputPath,entry) - for i in range(0,random_seeds): - seed_level_path = os.path.join(data_level_path,'seed_'+str(i)) - dataframes = [] - for j in range(1,cv_partitions+1): - cv_level_path = os.path.join(seed_level_path,'cv_'+str(j)) - file_path = cv_level_path+'/rule_pop.csv' #load rule population file - #Load Eval File - df = pd.read_csv(file_path) - # Get ideal rule set list - ideal_rules = gen_ideal_rules(mux_output_folders[entry]) - ideal_rule_count = len(ideal_rules) - found_ideal_rules = 0 - #Check Rule Pop for number and proportion of ideal rules - for index, row in df.iterrows(): - c_index = row['Condition Indexes'] - c_values = row['Condition Values'] - outcome = row['Action'] - combined_rule = [c_index,c_values,int(outcome)] - if combined_rule in ideal_rules: - found_ideal_rules += 1 - found_ideal_proportion = found_ideal_rules / float(ideal_rule_count) - tempList = [entry, i, j, found_ideal_rules,found_ideal_proportion] - resultsList.append(tempList) - df_results = pd.DataFrame(resultsList,columns=header) - df_results.to_csv(outputPath+'/phase1_mux_ideal_success.csv', index=False) - #Make quick average summary file - header = ['Dataset','Ideal Count','Ideal Proportion'] - resultsList = [] - for entry in os.listdir(outputPath): #for each subfolder within target dataset folder - if entry != 'phase1_mux_ideal_success.csv' and entry != 'phase1_mux_ideal_success_average.csv': - average_count = df_results.loc[df_results['Dataset'] == entry, 'Ideal Count'].mean() - average_proportion = df_results.loc[df_results['Dataset'] == entry, 'Ideal Proportion'].mean() - resultsList.append([entry,average_count,average_proportion]) - df_results = pd.DataFrame(resultsList,columns=header) - df_results.to_csv(outputPath+'/phase1_mux_ideal_success_average.csv', index=False) - - -def gen_ideal_rules(mux): - address_bits = {6:2, 11:3, 20:4, 37:5, 70:6, 135:7} - ideal_list = [] - register_bits = mux - address_bits[mux] - print(register_bits) - for i in range(0,register_bits): #each unique index list - #ZERO OUTCOME - index_list = [] - value_list = [] - #Build index list - for j in range(0,address_bits[mux]): - index_list.append(j) - index_list.append(i+address_bits[mux]) - #Build value list - value_list = (int_to_binary_list(i,address_bits[mux])) - value_list.append(0) - ideal_list.append([str(index_list),str(value_list),0]) - #ONE OUTCOME - value_list = [] - #Build value list - value_list = (int_to_binary_list(i,address_bits[mux])) - value_list.append(1) - ideal_list.append([str(index_list),str(value_list),1]) - - return ideal_list - - -def int_to_binary_list(num, n): - """Convert an integer to an n-digit binary list of 0s and 1s.""" - return [int(bit) for bit in format(num, f'0{n}b')] - - -if __name__=="__main__": - sys.exit(main(sys.argv)) - diff --git a/evaluation/experiments/job_heros_table_hpc.py b/evaluation/experiments/job_heros_table_hpc.py deleted file mode 100644 index ff02f8b..0000000 --- a/evaluation/experiments/job_heros_table_hpc.py +++ /dev/null @@ -1,653 +0,0 @@ -import os -import sys -import argparse -import pickle -import pandas as pd -import numpy as np -import matplotlib.pyplot as plt -import seaborn as sns -from sklearn.metrics import confusion_matrix -sys.path.append('/project/kamoun_shared/code_shared/scikit-heros/') -from scipy.stats import wilcoxon -#from skheros.heros import HEROS #PIP INSTALL RUN - -def main(argv): - #ARGUMENTS:------------------------------------------------------------------------------------ - parser = argparse.ArgumentParser(description='') - #Script Parameters - parser.add_argument('--o', dest='outputPath', help='path to target output folder', type=str, default = 'mypath/myOutputFolder') - #Dataset Parameters - parser.add_argument('--ol', dest='outcome_label', help='outcome label (i.e. class label)', type=str, default = 'Class') - parser.add_argument('--il', dest='instanceID_label', help='label of instance ID column (if present)', type=str, default = 'InstanceID') - parser.add_argument('--el', dest='excluded_column', help='label of another column to drop (if present)', type=str, default = 'Group') - #Experiment Parameters - parser.add_argument('--cv', dest='cv_partitions', help='number of cv partitions', type=int, default = 10) - parser.add_argument('--r', dest='random_seeds', help='number of random seeds to run', type=int, default= 30) - - #---------------------------------------------------------------------------------------------- - options=parser.parse_args(argv[1:]) - #Script Parameters - outputPath = options.outputPath #goes to the main output folder (not individual experiments) - #Dataset Parameters - outcome_label = options.outcome_label - instanceID_label = options.instanceID_label - excluded_column = options.excluded_column - #Experiment Parameters - cv_partitions = options.cv_partitions - random_seeds = options.random_seeds - p_val = 0.05 - - #Make folder to save output tables. - table_out_path = outputPath+'/heros_paper_tables' - if not os.path.exists(table_out_path): - os.mkdir(table_out_path) - - #Lay out experiment identifiers - file_precuror = 'all' #'cv_ave' #use all individual runs, or averages across cvs to run stats. - phase1_checkpoints = ['500', '1000','10000','100000','200000','post_compact'] - phase2_checkpoints = ['5', '10', '50', '100','200'] - gametes_datasets = ['A_uni_4add', 'B_univariate','C_2way_epistasis','D_2way_epi_2het','E_uni_4het','F_3way_epistasis'] - mux_datasets = ['A_multiplexer_6_bit_500_inst','B_multiplexer_11_bit_5000_inst','C_multiplexer_20_bit_10000_inst','D_multiplexer_37_bit_10000_inst','E_multiplexer_70_bit_20000_inst'] - #mux_datasets = ['A_multiplexer_6_bit_500_inst','B_multiplexer_11_bit_5000_inst','C_multiplexer_20_bit_10000_inst','D_multiplexer_37_bit_10000_inst','E_multiplexer_70_bit_20000_inst','F_multiplexer_135_bit_20000_inst'] - algorithms = ['ExSTraCS','HEROS'] - #'HEROS_multiplexer_cv', 'HEROS_multiplexer_cv_acc_init', 'HEROS_multiplexer_cv_acc_init_nu10', 'HEROS_gametes_cv', 'HEROS_gametes_cv_acc_init' - #'ExSTraCS_multiplexer_cv', 'ExSTraCS_multiplexer_cv_nu10', 'ExSTraCS_gametes_cv' - - significance_metrics = ['test_balanced_accuracy','test_coverage','rule_count','run_time'] - sig_digits = [3,3,None,None] - sig_digits_dict = {} - i = 0 - for metric in significance_metrics: - sig_digits_dict[metric] = sig_digits[i] - i+=1 - - #Make Global Tables ------------------------------------------------------------------------------------------ - - #All Gametes nu=1 Table --------------------- - dataname = 'gametes_cv' - nu_use = 1 - table_name = 'Global_'+str(dataname)+'_nu_'+str(nu_use) - global_lists = [] - expname = 'acc_init' - exp_names = ['HEROS(I)-Pre','HEROS(I)-Post','HEROS(II)-RI-D','HEROS(II)-RI-F','HEROS(II)-TI-D','HEROS(II)-TI-F'] - header = ['Dataset','Scenario','Test Acc.', 'Test Cover', 'Rule Count', 'Run Time'] - basename = 'ExSTraCS' - #Automated below - for specdataname in gametes_datasets: - base_path = outputPath+'/ExSTraCS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_post_compact_evaluations' - paths = [outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_200000_evaluations', - outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_post_compact_evaluations', - outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_default_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_test_selected_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_'+str(expname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_default_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_'+str(expname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_test_selected_model_200_evaluations'] - table_list = run_analysis(basename, exp_names,base_path,significance_metrics,paths,p_val,sig_digits_dict,specdataname) - global_lists = global_lists + table_list - - table_df = pd.DataFrame(global_lists, columns=header) - table_df.to_csv(table_out_path+'/'+str(table_name)+'_Table.csv', index=False) - #table_df_T = table_df.T - #table_df_T.to_csv(table_out_path+'/'+str(table_name)+'_Table.csv', index=True, header=False) - - #All Multiplexer nu=1 Table --------------------- - dataname = 'multiplexer_cv' - nu_use = 1 - table_name = 'Global_'+str(dataname)+'_nu_'+str(nu_use) - global_lists = [] - expname = 'acc_init' - exp_names = ['HEROS(I)-Pre','HEROS(I)-Post','HEROS(II)-RI-D','HEROS(II)-RI-F','HEROS(II)-TI-D','HEROS(II)-TI-F'] - header = ['Dataset','Scenario','Test Acc.', 'Test Cover', 'Rule Count', 'Run Time','Ideal Solution'] - basename = 'ExSTraCS' - #Automated below - for specdataname in mux_datasets: - base_path = outputPath+'/ExSTraCS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_post_compact_evaluations' - paths = [outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_200000_evaluations', - outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_post_compact_evaluations', - outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_default_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_test_selected_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_'+str(expname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_default_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_'+str(expname)+'/'+str(specdataname)+'/'+str(file_precuror)+'_test_selected_model_200_evaluations'] - table_list = run_analysis_mux(basename, exp_names,base_path,significance_metrics,paths,p_val,sig_digits_dict,specdataname) - global_lists = global_lists + table_list - - table_df = pd.DataFrame(global_lists, columns=header) - table_df.to_csv(table_out_path+'/'+str(table_name)+'_Table.csv', index=False) - - #All Multiplexer nu=10 Table --------------------- - dataname = 'multiplexer_cv' #+'_nu'+str(nu_use) - nu_use = 10 - table_name = 'Global_'+str(dataname)+'_nu_'+str(nu_use) - global_lists = [] - expname = 'acc_init' - exp_names = ['HEROS(I)-Pre','HEROS(I)-Post','HEROS(II)-RI-D','HEROS(II)-RI-F','HEROS(II)-TI-D','HEROS(II)-TI-F'] - header = ['Dataset','Scenario','Test Acc.', 'Test Cover', 'Rule Count', 'Run Time','Ideal Solution'] - basename = 'ExSTraCS' - #Automated below - for specdataname in mux_datasets: - base_path = outputPath+'/ExSTraCS_'+str(dataname)+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_post_compact_evaluations' - paths = [outputPath+'/HEROS_'+str(dataname)+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_200000_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_rule_post_compact_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_default_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_test_selected_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_'+expname+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_default_model_200_evaluations', - outputPath+'/HEROS_'+str(dataname)+'_'+expname+'_nu'+str(nu_use)+'/'+str(specdataname)+'/'+str(file_precuror)+'_test_selected_model_200_evaluations'] - table_list = run_analysis_mux(basename, exp_names,base_path,significance_metrics,paths,p_val,sig_digits_dict,specdataname) - global_lists = global_lists + table_list - - table_df = pd.DataFrame(global_lists, columns=header) - table_df.to_csv(table_out_path+'/'+str(table_name)+'_Table.csv', index=False) - - #RULE POP Performance Tracking boxplots ------------------------------------------------------------------------------------------ - - custom_palette = [ - "#f0f0f0", # very light grey - "#FFCC99", # light orange - - "#d3d3d3", # light grey - "#FFFF99", # light yellow - - "#b0b0b0", # light medium grey - "#99FF99", # light green - - "#808080", # medium grey - "#99CCFF", # light blue - - "#707070", # slightly dark grey - "#9999FF", # light indego - - "#585858", # medium dark grey - "#CC99FF" # light violet - ] - - #All Gametes nu=1 Table --------------------- - print('generating Gametes Plot') - dataname = 'gametes_cv' - nu_use = 1 - target_metric = "Balanced Testing Accuracy" - imageName = 'Phase1_Testing_Accuracy_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase1_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in gametes_datasets: - for timepoint in phase1_checkpoints: - for algorithm in algorithms: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+'/'+specdataname+'/'+str(file_precuror)+'_rule_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['test_balanced_accuracy'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": algorithm, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,algorithms,target_metric,custom_palette) - - #All Multiplexer nu=1 Table --------------------- - print('generating MUX Plot') - dataname = 'multiplexer_cv' - nu_use = 1 - target_metric = "Balanced Testing Accuracy" - imageName = 'Phase1_Testing_Accuracy_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase1_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in mux_datasets: - for timepoint in phase1_checkpoints: - for algorithm in algorithms: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+'/'+specdataname+'/'+str(file_precuror)+'_rule_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['test_balanced_accuracy'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": algorithm, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,algorithms,target_metric,custom_palette) - - - #All Multiplexer nu=10 Table --------------------- - dataname = 'multiplexer_cv' - nu_use = 10 - target_metric = "Balanced Testing Accuracy" - imageName = 'Phase1_Testing_Accuracy_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase1_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in mux_datasets: - for timepoint in phase1_checkpoints: - for algorithm in algorithms: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+'_nu'+str(nu_use)+'/'+specdataname+'/'+str(file_precuror)+'_rule_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['test_balanced_accuracy'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": algorithm, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,algorithms,target_metric,custom_palette) - - - #Phase 2 Accuracy Performance Tracking boxplots ------------------------------------------------------------------------------------------ - - custom_palette = [ - "#00ffff", # - "#faebe6", # - - "#00bfff", # - "#fcd4cd", # - - "#009fff", # - "#febdb3", # - - "#0080ff", # - "#fcb0a4", # - - "#0060ff", # - "#ffa598", # - - "#0040ff", # - "#ff9486" # - ] - #All Gametes nu=1 Table --------------------- - dataname = 'gametes_cv' - nu_use = 1 - target_metric = "Balanced Testing Accuracy" - algorithm = 'HEROS' - scenarios = ['HEROS(II)-RI-D','HEROS(II)-TI-D'] - my_dict = { - "HEROS(II)-RI-D": '', - "HEROS(II)-TI-D": '_acc_init' - } - imageName = 'Phase2_Testing_Accuracy_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase2_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in gametes_datasets: - for timepoint in phase2_checkpoints: - for scenario in scenarios: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+my_dict[scenario]+'/'+specdataname+'/'+str(file_precuror)+'_default_model_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['test_balanced_accuracy'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": scenario, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,scenarios,target_metric,custom_palette) - - #All MUX nu=1 Table --------------------- - dataname = 'multiplexer_cv' - nu_use = 1 - target_metric = "Balanced Testing Accuracy" - algorithm = 'HEROS' - scenarios = ['HEROS(II)-RI-D','HEROS(II)-TI-D'] - my_dict = { - "HEROS(II)-RI-D": '', - "HEROS(II)-TI-D": '_acc_init' - } - imageName = 'Phase2_Testing_Accuracy_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase2_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in mux_datasets: - for timepoint in phase2_checkpoints: - for scenario in scenarios: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+my_dict[scenario]+'/'+specdataname+'/'+str(file_precuror)+'_default_model_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['test_balanced_accuracy'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": scenario, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,scenarios,target_metric,custom_palette) - - #All MUX nu=10 Table --------------------- - dataname = 'multiplexer_cv' - nu_use = 10 - target_metric = "Balanced Testing Accuracy" - algorithm = 'HEROS' - scenarios = ['HEROS(II)-RI-D','HEROS(II)-TI-D'] - my_dict = { - "HEROS(II)-RI-D": '', - "HEROS(II)-TI-D": '_acc_init' - } - imageName = 'Phase2_Testing_Accuracy_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase2_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in mux_datasets: - for timepoint in phase2_checkpoints: - for scenario in scenarios: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+my_dict[scenario]+'_nu'+str(nu_use)+'/'+specdataname+'/'+str(file_precuror)+'_default_model_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['test_balanced_accuracy'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": scenario, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,scenarios,target_metric,custom_palette) - - #Phase 2 Rule Count Performance Tracking boxplots ------------------------------------------------------------------------------------------ - - #All Gametes nu=1 Table --------------------- - dataname = 'gametes_cv' - nu_use = 1 - target_metric = "Rule Count" - algorithm = 'HEROS' - scenarios = ['HEROS(II)-RI-D','HEROS(II)-TI-D'] - my_dict = { - "HEROS(II)-RI-D": '', - "HEROS(II)-TI-D": '_acc_init' - } - imageName = 'Phase2_Rule_Count_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase2_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in gametes_datasets: - for timepoint in phase2_checkpoints: - for scenario in scenarios: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+my_dict[scenario]+'/'+specdataname+'/'+str(file_precuror)+'_default_model_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['rule_count'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": scenario, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,scenarios,target_metric,custom_palette) - - #All MUX nu=1 Table --------------------- - dataname = 'multiplexer_cv' - nu_use = 1 - target_metric = "Rule Count" - algorithm = 'HEROS' - scenarios = ['HEROS(II)-RI-D','HEROS(II)-TI-D'] - my_dict = { - "HEROS(II)-RI-D": '', - "HEROS(II)-TI-D": '_acc_init' - } - imageName = 'Phase2_Rule_Count_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase2_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in mux_datasets: - for timepoint in phase2_checkpoints: - for scenario in scenarios: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+my_dict[scenario]+'/'+specdataname+'/'+str(file_precuror)+'_default_model_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['rule_count'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": scenario, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,scenarios,target_metric,custom_palette) - - #All MUX nu=10 Table --------------------- - dataname = 'multiplexer_cv' - nu_use = 10 - target_metric = "Rule Count" - algorithm = 'HEROS' - scenarios = ['HEROS(II)-RI-D','HEROS(II)-TI-D'] - my_dict = { - "HEROS(II)-RI-D": '', - "HEROS(II)-TI-D": '_acc_init' - } - imageName = 'Phase2_Rule_Count_Tracking_'+str(dataname)+'_nu_'+str(nu_use) - subplot_count = len(phase2_checkpoints)*len(algorithms) - # Gathering data - data = [] - for specdataname in mux_datasets: - for timepoint in phase2_checkpoints: - for scenario in scenarios: - #Load specific data file - file_path = outputPath+'/'+algorithm+'_'+dataname+my_dict[scenario]+'_nu'+str(nu_use)+'/'+specdataname+'/'+str(file_precuror)+'_default_model_'+timepoint+'_evaluations.csv' - tmp_df = pd.read_csv(file_path) #load results dataset - column_list = tmp_df['rule_count'].tolist() - for val in column_list: - data.append({ - "Dataset": specdataname, - "Time Point": timepoint, - "Algorithm": scenario, - "Metric": val - }) - # Convert to DataFrame - df = pd.DataFrame(data) - # Create a combined column for grouping within each dataset - df['Group'] = df['Time Point'] + " | " + df['Algorithm'] - make_boxplot(df,table_out_path,imageName,mux_datasets,phase1_checkpoints,p_val,subplot_count,scenarios,target_metric,custom_palette) - - -def make_boxplot(df,table_out_path,imageName,datasets,timepoints,p_val,subplot_count,algorithms,target_metric,custom_palette): - - # Create the boxplot - plt.figure(figsize=(15, 8)) - ax = sns.boxplot( - x="Dataset", - y="Metric", - hue="Group", - data=df, - dodge=True, - palette=sns.color_palette(custom_palette), - showmeans=True, - meanprops={'marker':'o', - 'markerfacecolor':'black', - 'markeredgecolor':'white', - 'markersize':'4'} - ) - - # Add a horizontal dashed line at y = 0 - ax.axhline(y=0.5, color='red', linestyle='--', linewidth=1) - - # Perform Wilcoxon rank-sum test and annotate significant differences - i = 0 - for dataset in datasets: - j= 0 - for timepoint in timepoints: - # Get the data for Algorithm 1 and Algorithm 2 - alg1_data = df[(df['Dataset'] == dataset) & (df['Time Point'] == timepoint) & (df['Algorithm'] == algorithms[0])]['Metric'] - alg2_data = df[(df['Dataset'] == dataset) & (df['Time Point'] == timepoint) & (df['Algorithm'] == algorithms[1])]['Metric'] - - # Perform the Wilcoxon rank-sum test - success = False - try: - statistic, p_value = wilcoxon(alg1_data, alg2_data) - #print('Comparison: '+str(statistic)+ ' '+ str(p_value)) - success = True - except: - success = False - if success and p_value < p_val: - print('Sig Found: '+str(p_value)) - mean_alg2 = alg2_data.mean() - ymin, ymax = ax.get_ylim() - y_coordinate = ymin + (mean_alg2 - ymin) * (ymax - ymin) / (ymax - ymin) - - # Define the minimum and maximum values - min_value = i - 0.4 - max_value = i + 0.4 - width = max_value - min_value - boxwidth = width / subplot_count - - # Generate n equally spaced values between min_value and max_value - values = np.linspace(min_value+(boxwidth*1.5), max_value-(boxwidth/2), 6) - x_coordinate = values[j] - plt.text(x_coordinate, y_coordinate, "*", ha='center', va='bottom', fontsize=10, color='red') - j+= 1 - i += 1 - - # Customize the plot - plt.xlabel("Dataset", fontsize=12) - plt.ylabel(target_metric, fontsize=12) - plt.xticks(rotation=45, fontsize=10) - plt.legend(title="Time Point | Algorithm", loc='upper left', bbox_to_anchor=(1, 1)) - plt.tight_layout() - # Save plot - plt.savefig(table_out_path+'/'+str(imageName)+'.png', bbox_inches="tight") - - -def run_analysis(basename, exp_names,base_path,significance_metrics,paths,p_val,sig_digits_dict,specdataname): - #Initialize results list - table_list = [] - #initialize base list - base_list = [specdataname,basename] - #calculate Base stats (exstracs) - base_df = pd.read_csv(base_path+'.csv') #load results dataset - base_mean_dict = {} - for metric in significance_metrics: - if metric == 'run_time': - b_mean = base_df[metric].mean()/60 - b_std = base_df[metric].std()/60 - else: - b_mean = base_df[metric].mean() - b_std = base_df[metric].std() - base_list.append(str(round(b_mean,sig_digits_dict[metric]))+ ' ('+str(round(b_std,sig_digits_dict[metric]))+')') - base_mean_dict[metric] = b_mean - table_list.append(base_list) - - #Calculate all other experiment stats - for i in range(len(paths)): - df = pd.read_csv(paths[i]+'.csv') #load results dataset - exp_list = [specdataname,exp_names[i]] - for metric in significance_metrics: - if metric == 'run_time': - t_mean = df[metric].mean()/60 - t_std = df[metric].std()/60 - else: - t_mean = df[metric].mean() - t_std = df[metric].std() - #check for significant difference from baseline - is_sig = wilcoxon_sig(base_df[metric],df[metric],p_val) - if is_sig: # indicate significance within dataframe stat_list - if t_mean > base_mean_dict[metric]: - exp_list.append(str(round(t_mean,sig_digits_dict[metric]))+ ' ('+str(round(t_std,sig_digits_dict[metric]))+')*+') - else: - exp_list.append(str(round(t_mean,sig_digits_dict[metric]))+ ' ('+str(round(t_std,sig_digits_dict[metric]))+')*-') - else: #not significant - exp_list.append(str(round(t_mean,sig_digits_dict[metric]))+ ' ('+str(round(t_std,sig_digits_dict[metric]))+')') - table_list.append(exp_list) - return table_list - -def run_analysis_mux(basename, exp_names,base_path,significance_metrics,paths,p_val,sig_digits_dict,specdataname): - #header = ['Dataset','Scenario','Test Acc.', 'Test Cover', 'Rule Count', 'Run Time','Ideal Solution'] - ideal_counts = {'A_multiplexer_6_bit_500_inst': 8,'B_multiplexer_11_bit_5000_inst': 16,'C_multiplexer_20_bit_10000_inst':32,'D_multiplexer_37_bit_10000_inst':64,'E_multiplexer_70_bit_20000_inst':128} #ideal number of rules for each MUX solution - #ideal_counts = {'A_multiplexer_6_bit_500_inst': 8,'B_multiplexer_11_bit_5000_inst': 16,'C_multiplexer_20_bit_10000_inst':32,'D_multiplexer_37_bit_10000_inst':64,'E_multiplexer_70_bit_20000_inst':128,'F_multiplexer_135_bit_20000_inst':256} #ideal number of rules for each MUX solution - #Initialize results list - table_list = [] - #initialize base list - base_list = [specdataname,basename] - #calculate Base stats (exstracs) - base_df = pd.read_csv(base_path+'.csv') #load results dataset - base_mean_dict = {} - for metric in significance_metrics: - if metric == 'run_time': - b_mean = base_df[metric].mean()/60 - b_std = base_df[metric].std()/60 - else: - b_mean = base_df[metric].mean() - b_std = base_df[metric].std() - base_list.append(str(round(b_mean,sig_digits_dict[metric]))+ ' ('+str(round(b_std,sig_digits_dict[metric]))+')') - base_mean_dict[metric] = b_mean - #Identify frequency of ideal solution discovery - ideal_count = base_df[(base_df['test_balanced_accuracy'] == 1.0) & (base_df['rule_count'] == ideal_counts[specdataname])].shape[0] - base_list.append(str(ideal_count)+'/'+str(base_df.shape[0])) - table_list.append(base_list) - - #Calculate all other experiment stats - for i in range(len(paths)): - df = pd.read_csv(paths[i]+'.csv') #load results dataset - exp_list = [specdataname,exp_names[i]] - for metric in significance_metrics: - if metric == 'run_time': - t_mean = df[metric].mean()/60 - t_std = df[metric].std()/60 - else: - t_mean = df[metric].mean() - t_std = df[metric].std() - #check for significant difference from baseline - is_sig = wilcoxon_sig(base_df[metric],df[metric],p_val) - if is_sig: # indicate significance within dataframe stat_list - if t_mean > base_mean_dict[metric]: - exp_list.append(str(round(t_mean,sig_digits_dict[metric]))+ ' ('+str(round(t_std,sig_digits_dict[metric]))+')*+') - else: - exp_list.append(str(round(t_mean,sig_digits_dict[metric]))+ ' ('+str(round(t_std,sig_digits_dict[metric]))+')*-') - else: #not significant - exp_list.append(str(round(t_mean,sig_digits_dict[metric]))+ ' ('+str(round(t_std,sig_digits_dict[metric]))+')') - #Identify frequency of ideal solution discovery - ideal_count = df[(df['test_balanced_accuracy'] == 1.0) & (df['rule_count'] == ideal_counts[specdataname])].shape[0] - exp_list.append(str(ideal_count)+'/'+str(df.shape[0])) - table_list.append(exp_list) - return table_list - -def wilcoxon_sig(col1,col2,p_val): - success = False - try: - statistic, p_value = wilcoxon(col1, col2) - print('Comparison: '+str(statistic)+ ' '+ str(p_value)) - success = True - except: - success = False - - if success and p_value <= p_val: - return True - else: - return False - -if __name__=="__main__": - sys.exit(main(sys.argv)) \ No newline at end of file diff --git a/evaluation/experiments/run_commands.txt b/evaluation/experiments/run_commands.txt deleted file mode 100644 index 859fa8a..0000000 --- a/evaluation/experiments/run_commands.txt +++ /dev/null @@ -1,211 +0,0 @@ -### Run Commands for HEROS 1.0 analyses - -# module load git -# git clone --single-branch --branch dev https://github.com/UrbsLab/scikit-FIBERS -# pip install -r requirements.txt - -##Cluster Space check: -du -sh folder/ #reports human readable summary of space used in folder -##Delete all files of a given type -find /path/to/folder -type f -name "*.pickle" -delete - -#deleting files/folders -rm -r folder - -#copy directory recursively - -cp -r /project/kamoun_shared/output_shared/heros_gecco/output/ExSTraCS_gametes_cv /project/kamoun_shared/output_shared/heros_gecco2/output/ -cp -r /project/kamoun_shared/output_shared/heros_gecco/output/ExSTraCS_multiplexer_cv /project/kamoun_shared/output_shared/heros_gecco2/output/ -cp -r /project/kamoun_shared/output_shared/heros_gecco/output/ExSTraCS_multiplexer_cv_nu10 /project/kamoun_shared/output_shared/heros_gecco2/output/ - -# Cross Validation Partitioning --------------------------------------------------------------------------------------------- - -python run_CV_Partitioner.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data --w /project/kamoun_shared/data_shared/heros_sim_data --o gametes_data_cv --cv 10 --l Class - -python run_CV_Partitioner.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data --w /project/kamoun_shared/data_shared/heros_sim_data --o multiplexer_data_cv --cv 10 --l Class - - - -# MultiSURF Training --------------------------------------------------------------------------------------------- - -python run_multisurf_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv --cv 10 --m 2000 --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal - -python run_multisurf_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv --cv 10 --m 2000 --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal - - - -QUICK TEST::: - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/test_multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 50000 --ps 500 --nu 1 --mi 100 --ms 100 --c sub --tp 1000 --sr 500,1000,50000 --sm 5,10,50,100 - - -#HEROS Training and Evaluation --------------------------------------------------------------------------------------------- --check --resub - -#MULTIPLEXER DATA------------(1200 jobs each) - run these first for cluster use efficiency (as they include some longer running jobs) -#submitted -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -#submitted -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv_acc_init --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -#submitted -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 200000 --ps 2000 --nu 10 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -#submitted -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv_acc_init_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 10 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - - -#GAMETES DATA------------(1200 jobs each) -#submitted -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o gametes_cv --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -#submitted -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco2 --o gametes_cv_acc_init --ekf /project/kamoun_shared/output_shared/heros_gecco2/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -#HEROS SUMMARY AND FIGURES --------------------------------------------------------------------------------------------- - -#GAMETES DATA------------ -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o gametes_cv --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o gametes_cv_acc_init --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - - -#MULTIPLEXER DATA------------ -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv_acc_init --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv_acc_init_nu10 --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o multiplexer_cv_nu10 --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -## TABLE MAKING -python run_heros_table_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco2 --o output --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - - - -#HEROS Training and Evaluation --------------------------------------------------------------------------------------------- --check --resub - -#MULTIPLEXER DATA------------(1200 jobs each) - run these first for cluster use efficiency (as they include some longer running jobs) -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_acc_init --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 200000 --ps 2000 --nu 10 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_acc_init_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 10 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - - -#GAMETES DATA------------(1200 jobs each) -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv_acc_init --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 200000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000 --sm 5,10,50,100 --check - - - -#HEROS SUMMARY AND FIGURES --------------------------------------------------------------------------------------------- - -#GAMETES DATA------------ -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv_acc_init --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - - -#MULTIPLEXER DATA------------ -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_acc_init --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_acc_init_nu10 --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_nu10 --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - - - - -#ExSTraCS Training and Evaluation (Code Testing) --------------------------------------------------------------------------------------------- -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/test_multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o test_multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 2 --it 50000 --ps 2000 --nu 1 --ft --ff --c QRF --ta --sr 500,1000,10000,50000 - - -#ExSTraCS Training and Evaluation --------------------------------------------------------------------------------------------- - -#GAMETES DATA------------ -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --it 200000 --ps 2000 --nu 1 --ft --ff --c QRF --ta --sr 500,1000,10000,100000,200000 --check - -#MULTIPLEXER DATA------------ -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --it 200000 --ps 2000 --nu 1 --ft --ff --c QRF --ta --sr 500,1000,10000,100000,200000 --check - -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --it 200000 --ps 2000 --nu 10 --ft --ff --c QRF --ta --sr 500,1000,10000,100000,200000 --check - - - -#ExSTraCS SUMMARY AND FIGURES --------------------------------------------------------------------------------------------- -#MULTIPLEXER DATA------------ -python run_exstracs_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_exstracs_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o multiplexer_cv_nu10 --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -#GAMETES DATA------------ -python run_exstracs_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o gametes_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - - -## TABLE MAKING -python run_heros_table_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco --o output --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - - - -#LONG RUNS ********************************************************************************************************** -#MULTIPLEXER DATA------------(1200 jobs each) -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 500000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000,500000 --sm 5,10,50,100 --check True - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv_acc_init --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 500000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000,500000 --sm 5,10,50,100 --check True - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv_acc_init_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 500000 --ps 2000 --nu 10 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000,500000 --sm 5,10,50,100 --check True - -#GAMETES DATA------------(1200 jobs each) -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o gametes_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in random --it 500000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000,500000 --sm 5,10,50,100 --check True - -python run_heros_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o gametes_cv_acc_init --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --in target_acc --it 500000 --ps 2000 --nu 1 --mi 200 --ms 100 --c sub --tp 1000 --sr 500,1000,10000,100000,200000,500000 --sm 5,10,50,100 --check True --resub True -#REDO ABOVE - -#HEROS SUMMARY AND FIGURES --------------------------------------------------------------------------------------------- -#MULTIPLEXER DATA------------ -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv_acc_init --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv_acc_init_nu10 --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -#GAMETES DATA------------ -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o gametes_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 - -python run_heros_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o gametes_cv_acc_init --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 -#REDO ABOVE - -#ExSTraCS Training and Evaluation --------------------------------------------------------------------------------------------- -#MULTIPLEXER DATA------------ -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --it 500000 --ps 2000 --nu 1 --ft True --ff True --c QRF --ta True --sr 500,1000,10000,100000,200000,500000 --check True --resub True -#REDO ABOVE - -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/multiplexer_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv_nu10 --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --it 500000 --ps 2000 --nu 10 --ft True --ff True --c QRF --ta True --sr 500,1000,10000,100000,200000,500000 --check True --resub True -#REDO ABOVE - -#GAMETES DATA------------ -python run_exstracs_hpc.py --d /project/kamoun_shared/data_shared/heros_sim_data/gametes_data_cv --w /project/kamoun_shared/output_shared/heros_gecco_long --o gametes_cv --ekf /project/kamoun_shared/output_shared/heros_gecco/output/MultiSURF_gametes_cv --ol Class --il InstanceID --el Model --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 --it 500000 --ps 2000 --nu 1 --ft True --ff True --c QRF --ta True --sr 500,1000,10000,100000,200000,500000 --check True --resub True -#REDO ABOVE - - -#ExSTraCS SUMMARY AND FIGURES --------------------------------------------------------------------------------------------- -#MULTIPLEXER DATA------------ -python run_exstracs_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 -#REDO ABOVE - -python run_exstracs_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o multiplexer_cv_nu10 --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 -#REDO ABOVE - -#GAMETES DATA------------ -python run_exstracs_sum_hpc.py --w /project/kamoun_shared/output_shared/heros_gecco_long --o gametes_cv --ol Class --il InstanceID --el Group --rc LSF --rm 4 --q i2c2_normal --cv 10 --r 20 -#REDO ABOVE - - diff --git a/evaluation/experiments/run_heros_sum_hpc.py b/evaluation/experiments/run_heros_sum_hpc.py deleted file mode 100644 index b3f8ae9..0000000 --- a/evaluation/experiments/run_heros_sum_hpc.py +++ /dev/null @@ -1,118 +0,0 @@ -import sys -import os -import pandas as pd -import matplotlib.pyplot as plt -import numpy as np -import seaborn as sns -import scipy.stats as scs -import random -from sklearn.preprocessing import StandardScaler -from sklearn.experimental import enable_iterative_imputer -from sklearn.impute import IterativeImputer -import csv -import time -import argparse - -" HEROS Run " - -def main(argv): - #ARGUMENTS:------------------------------------------------------------------------------------ - parser = argparse.ArgumentParser(description='') - #Script Parameters - parser.add_argument('--w', dest='writepath', help='path to folder where all outputs from jobs/scripts will be saved', type=str, default = 'mypath/myWritePath') - parser.add_argument('--o', dest='outputfolder', help='unique folder name for this analysis', type=str, default = 'myAnalysis') - #Dataset Parameters - parser.add_argument('--ol', dest='outcome_label', help='outcome label (i.e. class label)', type=str, default = 'Class') - parser.add_argument('--il', dest='instanceID_label', help='label of instance ID column (if present)', type=str, default = 'InstanceID') - parser.add_argument('--el', dest='excluded_column', help='label of another column to drop (if present)', type=str, default = 'Group') - #Experiment Parameters - parser.add_argument('--cv', dest='cv_partitions', help='number of cv partitions', type=int, default = 10) - parser.add_argument('--r', dest='random_seeds', help='number of random seeds to run', type=int, default= 30) - #HPC parameters - parser.add_argument('--rc', dest='run_cluster', help='cluster type', type=str, default='LSF') - parser.add_argument('--rm', dest='reserved_memory', help='reserved memory for job', type=int, default= 4) - parser.add_argument('--q', dest='queue', help='cluster queue name', type=str, default= 'i2c2_normal') - #---------------------------------------------------------------------------------------------- - options=parser.parse_args(argv[1:]) - #Script Parameters - writepath = options.writepath - outputfolder = options.outputfolder - #Dataset Parameters - outcome_label = options.outcome_label - instanceID_label = options.instanceID_label - excluded_column = options.excluded_column - #Experiment Parameters - cv_partitions = options.cv_partitions - random_seeds = options.random_seeds - #HPC parameters - run_cluster = options.run_cluster - reserved_memory = options.reserved_memory - queue = options.queue - - algorithm = 'HEROS' - - #Folder Management------------------------------ - #Main Write Path----------------- - if not os.path.exists(writepath): - os.mkdir(writepath) - #Output Path-------------------- - base_output_path_0 = writepath+'/output/' - if not os.path.exists(base_output_path_0): - os.mkdir(base_output_path_0) - #Scratch Path-------------------- - scratchPath = writepath+'/scratch' - if not os.path.exists(scratchPath): - os.mkdir(scratchPath) - #LogFile Path-------------------- - logPath = writepath+'/logs' - if not os.path.exists(logPath): - os.mkdir(logPath) - base_output_path_0 = base_output_path_0+algorithm+'_'+outputfolder - if not os.path.exists(base_output_path_0): - os.mkdir(base_output_path_0) - - # Experiment loop to submit jobs (datasets, random seeds, cv partitions) - if run_cluster == 'LSF': - submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder) - elif run_cluster == 'SLURM': - submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder) - else: - print('ERROR: Cluster type not found') - print(str(1)+' jobs submitted successfully') - -#UPenn Cluster -def submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder): - job_ref = str(time.time()) - job_name = 'HEROS_summary_'+outputfolder+'_'+job_ref - job_path = scratchPath+'/'+job_name+ '_run.sh' - sh_file = open(job_path, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + queue + '\n') - sh_file.write('#BSUB -J ' + job_name + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(reserved_memory) + 'GB' + '\n') - sh_file.write('#BSUB -o ' + logPath+'/'+job_name + '.o\n') - sh_file.write('#BSUB -e ' + logPath+'/'+job_name + '.e\n') - sh_file.write('python job_heros_sum_hpc.py'+' --o '+str(base_output_path_0)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --cv '+str(cv_partitions)+' --r '+str(random_seeds)+'\n') - sh_file.close() - os.system('bsub < ' + job_path) - -#Cedars Cluster -def submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder): - job_ref = str(time.time()) - job_name = 'HEROS_summary_'+outputfolder+'_'+job_ref - job_path = scratchPath+'/'+job_name+ '_run.sh' - sh_file = open(job_path, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_name + '\n') - sh_file.write('#SBATCH --mem=' + str(reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write('#SBATCH -o ' + logPath+'/'+job_name + '.o\n') - sh_file.write('#SBATCH -e ' + logPath+'/'+job_name + '.e\n') - sh_file.write('srun python job_heros_sum_hpc.py'+' --o '+str(base_output_path_0)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --cv '+str(cv_partitions)+' --r '+str(random_seeds)+'\n') - sh_file.close() - os.system('sbatch ' + job_path) - -if __name__=="__main__": - sys.exit(main(sys.argv)) \ No newline at end of file diff --git a/evaluation/experiments/run_heros_table_hpc.py b/evaluation/experiments/run_heros_table_hpc.py deleted file mode 100644 index 0c39d0c..0000000 --- a/evaluation/experiments/run_heros_table_hpc.py +++ /dev/null @@ -1,115 +0,0 @@ -import sys -import os -import pandas as pd -import matplotlib.pyplot as plt -import numpy as np -import seaborn as sns -import scipy.stats as scs -import random -from sklearn.preprocessing import StandardScaler -from sklearn.experimental import enable_iterative_imputer -from sklearn.impute import IterativeImputer -import csv -import time -import argparse - -" HEROS Run " - -def main(argv): - #ARGUMENTS:------------------------------------------------------------------------------------ - parser = argparse.ArgumentParser(description='') - #Script Parameters - parser.add_argument('--w', dest='writepath', help='path to folder where all outputs from jobs/scripts will be saved', type=str, default = 'mypath/myWritePath') - parser.add_argument('--o', dest='outputfolder', help='unique folder name for this analysis', type=str, default = 'myAnalysis') - #Dataset Parameters - parser.add_argument('--ol', dest='outcome_label', help='outcome label (i.e. class label)', type=str, default = 'Class') - parser.add_argument('--il', dest='instanceID_label', help='label of instance ID column (if present)', type=str, default = 'InstanceID') - parser.add_argument('--el', dest='excluded_column', help='label of another column to drop (if present)', type=str, default = 'Group') - #Experiment Parameters - parser.add_argument('--cv', dest='cv_partitions', help='number of cv partitions', type=int, default = 10) - parser.add_argument('--r', dest='random_seeds', help='number of random seeds to run', type=int, default= 30) - #HPC parameters - parser.add_argument('--rc', dest='run_cluster', help='cluster type', type=str, default='LSF') - parser.add_argument('--rm', dest='reserved_memory', help='reserved memory for job', type=int, default= 4) - parser.add_argument('--q', dest='queue', help='cluster queue name', type=str, default= 'i2c2_normal') - #---------------------------------------------------------------------------------------------- - options=parser.parse_args(argv[1:]) - #Script Parameters - writepath = options.writepath - outputfolder = options.outputfolder - #Dataset Parameters - outcome_label = options.outcome_label - instanceID_label = options.instanceID_label - excluded_column = options.excluded_column - #Experiment Parameters - cv_partitions = options.cv_partitions - random_seeds = options.random_seeds - #HPC parameters - run_cluster = options.run_cluster - reserved_memory = options.reserved_memory - queue = options.queue - - algorithm = 'HEROS' - - #Folder Management------------------------------ - #Main Write Path----------------- - if not os.path.exists(writepath): - os.mkdir(writepath) - #Output Path-------------------- - base_output_path_0 = writepath+'/'+outputfolder - if not os.path.exists(base_output_path_0): - os.mkdir(base_output_path_0) - #Scratch Path-------------------- - scratchPath = writepath+'/scratch' - if not os.path.exists(scratchPath): - os.mkdir(scratchPath) - #LogFile Path-------------------- - logPath = writepath+'/logs' - if not os.path.exists(logPath): - os.mkdir(logPath) - - # Experiment loop to submit jobs (datasets, random seeds, cv partitions) - if run_cluster == 'LSF': - submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder) - elif run_cluster == 'SLURM': - submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder) - else: - print('ERROR: Cluster type not found') - print(str(1)+' jobs submitted successfully') - -#UPenn Cluster -def submit_lsf_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder): - job_ref = str(time.time()) - job_name = 'HEROS_table_'+outputfolder+'_'+job_ref - job_path = scratchPath+'/'+job_name+ '_run.sh' - sh_file = open(job_path, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#BSUB -q ' + queue + '\n') - sh_file.write('#BSUB -J ' + job_name + '\n') - sh_file.write('#BSUB -R "rusage[mem=' + str(reserved_memory) + 'G]"' + '\n') - sh_file.write('#BSUB -M ' + str(reserved_memory) + 'GB' + '\n') - sh_file.write('#BSUB -o ' + logPath+'/'+job_name + '.o\n') - sh_file.write('#BSUB -e ' + logPath+'/'+job_name + '.e\n') - sh_file.write('python job_heros_table_hpc.py'+' --o '+str(base_output_path_0)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --cv '+str(cv_partitions)+' --r '+str(random_seeds)+'\n') - sh_file.close() - os.system('bsub < ' + job_path) - -#Cedars Cluster -def submit_slurm_cluster_job(scratchPath,logPath,reserved_memory,queue,base_output_path_0,outcome_label,instanceID_label,excluded_column,cv_partitions,random_seeds,outputfolder): - job_ref = str(time.time()) - job_name = 'HEROS_table_'+outputfolder+'_'+job_ref - job_path = scratchPath+'/'+job_name+ '_run.sh' - sh_file = open(job_path, 'w') - sh_file.write('#!/bin/bash\n') - sh_file.write('#SBATCH -p ' + queue + '\n') - sh_file.write('#SBATCH --job-name=' + job_name + '\n') - sh_file.write('#SBATCH --mem=' + str(reserved_memory) + 'G' + '\n') - # sh_file.write('#BSUB -M '+str(maximum_memory)+'GB'+'\n') - sh_file.write('#SBATCH -o ' + logPath+'/'+job_name + '.o\n') - sh_file.write('#SBATCH -e ' + logPath+'/'+job_name + '.e\n') - sh_file.write('srun python job_heros_table_hpc.py'+' --o '+str(base_output_path_0)+' --ol '+str(outcome_label) +' --il '+str(instanceID_label) +' --el '+str(excluded_column)+' --cv '+str(cv_partitions)+' --r '+str(random_seeds)+'\n') - sh_file.close() - os.system('sbatch ' + job_path) - -if __name__=="__main__": - sys.exit(main(sys.argv)) \ No newline at end of file diff --git a/evaluation/exstracs_comparison_version/scikit-ExSTraCS.zip b/evaluation/exstracs_comparison_version/scikit-ExSTraCS.zip deleted file mode 100644 index 1f7d2c7..0000000 Binary files a/evaluation/exstracs_comparison_version/scikit-ExSTraCS.zip and /dev/null differ diff --git a/images/HEROS_1.1_Paper_Schematic_New4.png b/images/HEROS_1.1_Paper_Schematic_New4.png new file mode 100644 index 0000000..839fcea Binary files /dev/null and b/images/HEROS_1.1_Paper_Schematic_New4.png differ diff --git a/requirements.txt b/requirements.txt index 6dba59f..aec12bf 100644 Binary files a/requirements.txt and b/requirements.txt differ diff --git a/src/skheros/heros.py b/src/skheros/heros.py index 0dfe948..5b0612e 100644 --- a/src/skheros/heros.py +++ b/src/skheros/heros.py @@ -19,8 +19,10 @@ #import inspect #temporary testing class HEROS(BaseEstimator, TransformerMixin): - def __init__(self, outcome_type='class',iterations=100000,pop_size=1000,cross_prob=0.8,mut_prob=0.04,nu=1,beta=0.2,theta_sel=0.5,fitness_function='pareto', - subsumption='both',rsl=0,feat_track=None,model_iterations=500,model_pop_size=100, model_pop_init = 'target_acc', new_gen=1.0,merge_prob=0.1,rule_pop_init=None,compaction='sub',track_performance=0,model_tracking=False,stored_rule_iterations=None,stored_model_iterations=None,random_state=None,verbose=False): + def __init__(self,outcome_type='class',iterations=100000,pop_size=1000,cross_prob=0.8,mut_prob=0.04,nu=1,beta=0.2,theta_sel=0.5,fitness_function='pareto', + subsumption='both',rsl=0,feat_track=None,model_iterations=500,model_pop_size=100, model_pop_init = 'target_acc', new_gen=1.0,merge_prob=0.1, + rule_pop_init=None,compaction='sub',track_performance=0,model_tracking=False,stored_rule_iterations=None,stored_model_iterations=None,random_state=None, + verbose=False,alternate=5,alternate_mode='equal',feedback=False): """ A Scikit-Learn compatible implementation of the 'Heuristic Evolutionary Rule Optimization System' (HEROS) Algorithm. .. @@ -50,7 +52,10 @@ def __init__(self, outcome_type='class',iterations=100000,pop_size=1000,cross_pr :param stored_model_iterations: specifies iterations where a copy of the model population is stored (Must be positive integers separated by commas or None) :param random_state: the seed value needed to generate a random number :param verbose: Boolean flag to run in 'verbose' mode - display run details - :param init: model population initialization method + :param alternate: Number of phase alternations between Phase I and Phase II (must be int >= 0) + :param alternate_mode: Experimental parameter to specify the method for determining when to alternate between Phase I and Phase II (must be 'limit', 'converge', 'equal', or None) + :param feedback: TBD + """ # Basic run parameter checks if not outcome_type == 'class' and not outcome_type == 'quant': @@ -103,7 +108,7 @@ def __init__(self, outcome_type='class',iterations=100000,pop_size=1000,cross_pr if not self.check_is_float(merge_prob) or merge_prob < 0 or merge_prob > 1: raise Exception("'merge_prob' param must be float from 0 - 1") - if not rule_pop_init == 'load' and not rule_pop_init == 'dt' and not rule_pop_init is None and not rule_pop_init == 'None': + if not rule_pop_init == 'load' and not rule_pop_init == 'dt' and not rule_pop_init == 'dt_verbose' and not rule_pop_init == 'dt_bstrap' and not rule_pop_init is None and not rule_pop_init == 'None': raise Exception("'rule_pop_init' param must be 'load', 'dt', or None") if not compaction == 'sub' and not compaction is None and not compaction == 'None': @@ -128,6 +133,12 @@ def __init__(self, outcome_type='class',iterations=100000,pop_size=1000,cross_pr verbose = False if not self.check_is_bool(verbose): raise Exception("'verbose' param must be a boolean, i.e. True or False") + + if not self.check_is_int(alternate) or alternate < 0: + raise Exception("'alternate' param must be a non-negative integer") + + if not alternate_mode == 'limit' and not alternate_mode == 'converge' and not alternate_mode == 'equal' and not alternate_mode is None and not alternate_mode == 'None': + raise Exception("'alternate_mode' param must be 'limit', 'converge', 'equal', or None") #Initialize global variables self.outcome_type = str(outcome_type) @@ -172,7 +183,21 @@ def __init__(self, outcome_type='class',iterations=100000,pop_size=1000,cross_pr self.verbose = verbose self.use_ek = False #internal parameter - set to False by default, but switched to true of ek scores passed to fit() self.y_encoding = None + + #New Parameters + self.alternate = int(alternate) + self.alternate = alternate + self.alternate_mode = alternate_mode + self.curr_alt = 0 #internal parameter to track current number of alternations between Phase I and Phase II + + #Experimental Parameters #self.top_models = [] #for tracking model performance increase over iterations !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + self.feedback = feedback + self.training_weights = [] + self.phase_one_limit = 5000 + self.phase_one_ratio = 0 + self.phase_two_convergence = 5 + self.phase_two_limit = 100 @staticmethod def check_is_int(num): @@ -308,9 +333,7 @@ def fit(self, X, y, row_id=None, cat_feat_indexes=None, pop_df=None, ek=None): # Data Preparation X, y, row_id, cat_feat_indexes, pop_df, ek = self.check_inputs(X, y, row_id, cat_feat_indexes, pop_df, ek) #check loaded data self.env = DATA_MANAGE(X, y, row_id, cat_feat_indexes, ek, self) #initialize the data environment; data formatting, summary statistics, and expert knowledge preparation - # Memory Cleanup - X = None - y = None + # Initialize Objects self.iteration = 0 self.rule_population = RULE_POP() # Initialize rule sets @@ -328,65 +351,179 @@ def fit(self, X, y, row_id=None, cat_feat_indexes=None, pop_df=None, ek=None): self.tracking = RULE_TRACK(self) # Initialize Rule Population (if specified) + verbose_debug_tree_init = False #DEBUG FLAG if self.rule_pop_init == 'load': # Initialize rule population based on loaded rule population self.rule_population.load_rule_population(pop_df,self,random,np) - elif self.rule_pop_init == 'dt': # Train and utilize decision tree models to initialize rule population (based on individual tree 'branches') - print("Not yet implemented.") - pass + elif self.rule_pop_init == 'dt': + self.rule_population.tree_init_population(X,y,self,random,np,verbose_debug_tree_init) + print('PopSize After Tree Initialization ' +str(len(self.rule_population.pop_set))) #DEBUG + print('Micro PopSize After Tree Initialization ' +str(self.rule_population.micro_pop_count)) #DEBUG + elif self.rule_pop_init == 'dt_bstrap': + self.rule_population.tree_init_population(X,y,self,random,np,verbose_debug_tree_init, bstrap=True) + print('PopSize After Tree Initialization ' +str(len(self.rule_population.pop_set))) #DEBUG + print('Micro PopSize After Tree Initialization ' +str(self.rule_population.micro_pop_count)) #DEBUG else: # No rule population initialization other than standard LCS-algorithm-style 'covering' mechanism. pass + + # Clean/Compact Initialized Population + if len(self.rule_population.pop_set) > 1: + self.timer.compaction_time_start() + compact = COMPACT(self) + self.sufficient_rule_pop_remain = True + self.sufficient_rule_pop_remain = compact.basic_rule_cleaning(self) + if self.compaction == 'sub' and self.sufficient_rule_pop_remain: + self.sufficient_rule_pop_remain = compact.subsumption_compation(self) + compact.clear_pop_copy() + self.timer.compaction_time_stop() + + # Archive tree-intialized rule population for external examination + if self.rule_pop_init == 'dt' or self.rule_pop_init == 'dt_bstrap': + self.rule_population.archive_rule_pop(0) + + # Memory Cleanup + X = None + y = None self.timer.init_time_stop() #initialization time tracking - # RUN RULE-LEARNING TRAINING ITERATIONS ************************************************************** - while self.iteration < self.iterations: + print("HEROS Evolution Beginning!") + + #CODE TO RUN PHASE I ONLY ---------------------------------------------------- + if self.model_iterations > 1: #Apply Phase II + # Initialize model population and + self.model_population = MODEL_POP() # Initialize rule sets + self.model_iteration = 0 + else: + print("Running HEROS with Phase I only (no model iterations).") + while self.iterations - self.iteration > 0: + self.phase_one() + print("HEROS (Phase 1) run complete!") + print("Random Seed Check - End: "+ str(random.random())) + return self + #----------------------------------------------------------------------------- + + while (self.iterations - self.iteration > 0) and (self.model_iterations - self.model_iteration > 1): + self.phase_one() + self.tracking.alternations.append(self.iteration) + + if self.model_iteration == 0: + self.model_population.initialize_model_population( + self, random, self.model_pop_init + ) + + self.phase_two() + self.model_population.model_alterations.append(self.model_iteration) + self.curr_alt += 1 + + while self.iterations - self.iteration > 0: + self.phase_one() + + # 3) Drain *all but one* of the remaining Phase II calls + while (self.model_iterations - self.model_iteration > 0): + self.phase_two() + + + #self.env.clear_data_from_memory() + return self + + + + def phase_one(self): + + # CONVERGENCE ON NON-NEW DISCOVERY?? CHECKING WITH ARCHIVE + phase_one_stop = True + i = 0 + improvement = 0 + """ (HEROS PHASE 1) RUN RULE-LEARNING TRAINING ITERATIONS""" + while phase_one_stop: # Get current training instance - instance = self.env.get_instance() + if i % 2 == 0 or self.model_iteration == 0 or self.feedback == False: + instance = self.env.get_instance() + else: + instance = self.env.get_weighted_instance(self) #print('Iteration: '+str(self.iteration)+' RulePopSize: '+str(len(self.rule_population.pop_set))) # Run a single training iteration focused on the current training instance #print(instance) - self.run_iteration(instance) + + if self.run_iteration(instance) == 1: + improvement += 1 + else: + improvement = 0 + + + #if self.iteration == 5: + # x = 5/0 + + # Increment iteration and training instance + self.iteration += 1 + self.env.next_instance() + i += 1 + + ## SWITCH EVALUATION AND STOP CRITERIA AND ADD COMPACTION IN BETWEEN + + ### STOP CRITERIA CHECK + if self.alternate_mode == "limit": #EXPERIMENTAL + if i >= self.phase_one_limit or self.iteration >= self.iterations: + phase_one_stop = False + elif self.alternate_mode == "converge": #EXPERIMENTAL: PHASE I CONVERGENCE + # IMPLEMENT + + # IDEAS: + # CHECK AT EACH ITERATION IF OFFSPRING RULE IMPROVES MATCH SET PARETO FRONT + if improvement >= 250 or self.iteration >= self.iterations: + phase_one_stop = False + elif self.alternate_mode == "equal": #EQUAL DISTRIBUTION OF RESOURCES ACROSS AMOUNT OF ALTERNATION + if i >= self.iterations / self.alternate: + phase_one_stop = False + else: #DEFAULT SEQUENTIAL HEROS + if i >= self.iterations: + phase_one_stop = False + + if phase_one_stop == False: + # RULE COMPACTION ********************************************* + self.timer.compaction_time_start() + compact = COMPACT(self) + self.sufficient_rule_pop_remain = True + self.sufficient_rule_pop_remain = compact.basic_rule_cleaning(self) + if self.compaction == 'sub' and self.sufficient_rule_pop_remain: + self.sufficient_rule_pop_remain = compact.subsumption_compation(self) + compact.clear_pop_copy() + self.timer.compaction_time_stop() + + # Evaluation tracking *************************************************** if self.track_performance > 0: - if (self.iteration + 1) % self.track_performance == 0: - self.tracking.update_performance_tracking(self.iteration,self) + if (self.iteration) % self.track_performance == 0: + self.tracking.update_performance_tracking(self.iteration - 1,self) if self.verbose: self.tracking.print_tracking_entry() #Pause learning to conduct a complete evaluation of the current rule population - if self.stored_rule_iterations != None and (self.iteration + 1) in self.stored_rule_iterations: + if self.stored_rule_iterations != None and (self.iteration) in self.stored_rule_iterations: #Archive current rule population if self.verbose: - print('Archiving: '+str(self.iteration+1)) - self.rule_population.archive_rule_pop(self.iteration+1) - self.timer.archive_rule_pop(self.iteration+1) - # Increment iteration and training instance - self.iteration += 1 - self.env.next_instance() + print('Archiving: '+str(self.iteration)) + self.rule_population.archive_rule_pop(self.iteration) + self.timer.archive_rule_pop(self.iteration) + + - # RULE COMPACTION ********************************************* - self.timer.compaction_time_start() - compact = COMPACT(self) - sufficient_rule_pop_remain = True - sufficient_rule_pop_remain = compact.basic_rule_cleaning(self) - if self.compaction == 'sub' and sufficient_rule_pop_remain: - sufficient_rule_pop_remain = compact.subsumption_compation(self) - compact.clear_pop_copy() - self.timer.compaction_time_stop() - - # BATCH FEATURE TRACKING ************************************** + ### THIS SHOULD HAPPEN AT THE VERY END OF LAST PHASE I RUN # BATCH FEATURE TRACKING ************************************** if self.feat_track == 'end': self.FT.batch_calculate_ft_scores(self) self.timer.phase1_time_stop() if self.verbose: print("HEROS (Phase 1) run complete!") print("Number of Unique Rules Identified: "+str(len(self.rule_population.explored_rules))) + print("Number of Iterations Used:" + str(i)) #print(self.rule_population.explored_rules) + self.phase_one_ratio = float(i/self.iterations) + - # (HEROS PHASE 2) RUN RULE-SET-LEARNING TRAINING ITERATIONS ******************************************************************** + def phase_two(self): + """(HEROS PHASE 2) RUN RULE-SET-LEARNING TRAINING ITERATIONS """ self.timer.phase2_time_start() + phase_two_stop = True + if self.model_iterations > 1: #Apply Phase II - # Initialize model population and - self.model_population = MODEL_POP() # Initialize rule sets - self.model_iteration = 0 - if not sufficient_rule_pop_remain: #abort Phase II and use Phase I rule population as final phase II model. + if not self.sufficient_rule_pop_remain: #abort Phase II and use Phase I rule population as final phase II model. self.model_population.skip_phase2(self) self.model_population.get_target_model(0) #the 'model' object with the best accuracy, then coverage, then lowest rule count (assumes prior sorting) self.timer.phase2_time_stop() @@ -396,9 +533,12 @@ def fit(self, X, y, row_id=None, cat_feat_indexes=None, pop_df=None, ek=None): print("Random Seed Check - End: "+ str(random.random())) else: #Run Phase 2 normally - self.model_population.initialize_model_population(self,random,self.model_pop_init) + models_prev = [] + models = [] + iter = 0 + count = 0 # RUN MODEL-LEARNING TRAINING ITERATIONS ************************************************************** - while self.model_iteration < self.model_iterations: + while phase_two_stop: #Apply NSGAII-like fast non dominated sorting of models into ranked fronts of models fronts = self.model_population.fast_non_dominated_sort(self) #Calculate crowding distances @@ -437,7 +577,35 @@ def fit(self, X, y, row_id=None, cat_feat_indexes=None, pop_df=None, ek=None): self.timer.archive_model_pop(self.model_iteration+1) #Next Iteration self.model_iteration += 1 - #Sort the model population first by accuracy and then by number of rules in model. + #Sort the model population first by accuracy and then by number of rules in model. + self.model_population.sort_model_pop() + self.model_population.identify_models_on_front() #For evaluating all models on the front. + models = set(filter(lambda m: m.model_on_front == 1,self.model_population.pop_set)) + if models == models_prev: + iter += 1 + else: + iter = 0 + #print(iter) + count += 1 + models_prev = models + + + # STOP CRITERIA CHECK + if self.alternate_mode == "limit": #EXPERIMENTAL + if not (iter < self.phase_two_convergence and count < self.phase_two_limit and self.model_iteration < self.model_iterations - 1): + phase_two_stop = False + elif self.alternate_mode == "converge": #EXPERIMENTAL: PHASE I CONVERGENCE + ## IMPLEMENT BASED ON PHASE I CONVERGENCE + if count >= int(self.model_iterations * self.phase_one_ratio) or self.model_iteration >= self.model_iterations - 1: + phase_two_stop = False + elif self.alternate_mode == "equal": #EQUAL DISTRIBUTION OF RESOURCES ACROSS AMOUNT OF ALTERNATION (New as of 2026 GECCO Paper) + if count >= self.model_iterations / self.alternate: + phase_two_stop = False + else: #DEFAULT SEQUENTIAL HEROS (2025 GECCO Paper) + if self.model_iteration >= self.model_iterations: + phase_two_stop = False + + self.model_population.sort_model_pop() self.model_population.identify_models_on_front() #For evaluating all models on the front. self.model_population.get_target_model(0) #the 'model' object with the best accuracy, then coverage, then lowest rule count (assumes prior sorting) @@ -447,9 +615,24 @@ def fit(self, X, y, row_id=None, cat_feat_indexes=None, pop_df=None, ek=None): print("HEROS (Phase 2) run complete!") #print("Number of Unique Models Identified: "+str(len(self.model_population.explored_models))) print("Random Seed Check - End: "+ str(random.random())) - - #self.env.clear_data_from_memory() - return self + instance_weights = [0 for instance in self.env.train_data[0]] + + for i in range(len(self.env.train_data)): + for model in models: + instance = self.env.train_data[0][i] + self.model_population.get_target_model(self.model_population.pop_set.index(model)) + self.model_population.make_eval_match_set(instance,self) + prediction = MODEL_PREDICTION(self, self.model_population,random) + outcome_prediction = prediction.get_prediction() + if prediction.covered == False: + instance_weights[i] += 1 + else: + if outcome_prediction == self.env.train_data[1][i]: + instance_weights[i] -= 1 + else: + instance_weights[i] += 1 + normalized_weights = [((weight + len(models))/(2 * len(models))) for weight in instance_weights] + self.training_weights = normalized_weights def run_iteration(self,instance): # Make 'Match Set', {M} @@ -492,7 +675,16 @@ def run_iteration(self,instance): self.timer.feature_track_time_stop() # Apply Genetic Algorithm To Generate Offspring Rules - self.rule_population.genetic_algorithm(instance,self,random,np) + new_rules = self.rule_population.genetic_algorithm(instance,self,random,np) + + result = None + + #if self.alternate_mode == "converge": + # if self.offspring_improves(new_rules): + # result = 0 + # else: + # result = 1 + # Apply Rule Deletion self.rule_population.deletion(self,random) @@ -500,8 +692,20 @@ def run_iteration(self,instance): #Clear Match and Correct Sets self.rule_population.clear_sets() + return result + + def offspring_improves(self, offspring_list): + best_idx = max(self.rule_population.match_set, key=lambda r: self.rule_population.pop_set[r].fitness) + best_fitness = self.rule_population.pop_set[best_idx].fitness + for offspring in offspring_list: + if offspring.fitness > best_fitness: + return True + return False + + + - def predict_explanation(self, x, feature_names, whole_rule_pop=False, target_model=0): + def predict_explanation(self, x, feature_names, whole_rule_pop=False, target_model=0, verbose=True): """ Applies model to predict a single instance outcome with full explanation of prediction. """ # Data point checks ************************ for value in x: @@ -518,6 +722,7 @@ def predict_explanation(self, x, feature_names, whole_rule_pop=False, target_mod outcome_proba = prediction.get_prediction_proba_dictionary() outcome_coverage = prediction.get_if_covered() match_set = self.rule_population.match_set + rule_source = self.rule_population.pop_set self.rule_population.clear_sets() else: self.model_population.get_target_model(target_model) @@ -528,47 +733,139 @@ def predict_explanation(self, x, feature_names, whole_rule_pop=False, target_mod outcome_proba = prediction.get_prediction_proba_dictionary() outcome_coverage = prediction.get_if_covered() match_set = self.model_population.match_set + rule_source = self.model_population.target_rule_set self.model_population.clear_sets() # Technical Report of Matching Rules ------------------------------------------ - print("PREDICTION REPORT ------------------------------------------------------------------") - print("Outcome Prediction: "+str(outcome_prediction)) - print("Model Prediction Probabilities: "+ str(outcome_proba)) - if outcome_coverage == 0: - print("Instance Covered by Model: No") - else: - print("Instance Covered by Model: Yes") - print("Number of Matching Rules: "+str(len(match_set))) - # TECHNICAL RULE REPORT - #for rule_index in match_set: - # self.model_population.target_rule_set[rule_index].display_key_rule_info() - print("PREDICTION EXPLANATION -------------------------------------------------------------") - if prediction.majority_class_selection_made: - print("Majority class selected since there is probability tie among matching rules, but there is a training majority class") - if prediction.random_selection_made: - print("Random class selected since there is probability tie among matching rules, but no training majority class") + if verbose: + print("PREDICTION REPORT ------------------------------------------------------------------") + print("Outcome Prediction: "+str(outcome_prediction)) + print("Model Prediction Probabilities: "+ str(outcome_proba)) + if outcome_coverage == 0: + print("Instance Covered by Model: No") + else: + print("Instance Covered by Model: Yes") + print("Number of Matching Rules: "+str(len(match_set))) + # TECHNICAL RULE REPORT + #for rule_index in match_set: + # self.model_population.target_rule_set[rule_index].display_key_rule_info() + print("PREDICTION EXPLANATION -------------------------------------------------------------") + if prediction.majority_class_selection_made: + print("Majority class selected since there is probability tie among matching rules, but there is a training majority class") + if prediction.random_selection_made: + print("Random class selected since there is probability tie among matching rules, but no training majority class") if len(match_set) > 0: # Sort match set for intuitive ordering - match_set = sorted(match_set, key=lambda i: (self.model_population.target_rule_set[i].numerosity, self.model_population.target_rule_set[i].correct_cover), reverse=True) + match_set = sorted(match_set, key=lambda i: (rule_source[i].numerosity, rule_source[i].correct_cover), reverse=True) # Give explanations for matching rules - print("Supporting Rules: --------------------") + if verbose: + print("Supporting Rules: --------------------") for rule_index in match_set: - if str(self.model_population.target_rule_set[rule_index].action) == str(prediction.prediction): - self.model_population.target_rule_set[rule_index].translate_rule(feature_names,self) - print("Contradictory Rules: -----------------") + if str(rule_source[rule_index].action) == str(prediction.prediction): + if verbose: + rule_source[rule_index].translate_rule(feature_names,self) + if verbose: + print("Contradictory Rules: -----------------") counter = 0 for rule_index in match_set: - if str(self.model_population.target_rule_set[rule_index].action) != str(prediction.prediction): - self.model_population.target_rule_set[rule_index].translate_rule(feature_names,self) + if str(rule_source[rule_index].action) != str(prediction.prediction): + if verbose: + rule_source[rule_index].translate_rule(feature_names,self) counter += 1 - if counter == 0: + if counter == 0 and verbose: print("No contradictory rules matched.") else: # No matching rules - if prediction.random_selection_made: - print("Random class selected since there are no matching rules and no training majority class") + if verbose: + if prediction.random_selection_made: + print("Random class selected since there are no matching rules and no training majority class") + else: + print("Majority class selected since there are no matching rules, but there is a training majority class") + + # Build and return structured explanation for programmatic use + features_view = [ + { + "feature_index": idx, + "feature_name": feature_names[idx], + "value": x[idx] + } + for idx in range(len(x)) + ] + + supporting_rules = [] + contradictory_rules = [] + per_rule_contributions = [] + for rule_index in match_set: + rule_obj = rule_source[rule_index] + rule_dict = rule_obj.to_explanation_dict(feature_names, self) + # compute this rule's weighted vote contribution (classification only) + vote_contrib = {} + if hasattr(rule_obj, 'instance_outcome_prop') and isinstance(outcome_proba, dict): + for cls, prob in rule_obj.instance_outcome_prop.items(): + vote_contrib[cls] = prob * rule_obj.numerosity + rule_dict["vote_contribution"] = vote_contrib + rule_dict["selected_action_matches_prediction"] = (str(rule_obj.action) == str(outcome_prediction)) + if str(rule_obj.action) == str(outcome_prediction): + supporting_rules.append(rule_dict) else: - print("Majority class selected since there are no matching rules, but there is a training majority class") - + contradictory_rules.append(rule_dict) + per_rule_contributions.append({ + "rule_id": getattr(rule_obj, "ID", None), + "numerosity": rule_obj.numerosity, + "action": rule_obj.action, + "vote_contribution": vote_contrib + }) + + selection_reason = None + if prediction.majority_class_selection_made and len(match_set) > 0: + selection_reason = "tie_break_by_training_majority" + elif prediction.random_selection_made and len(match_set) > 0: + selection_reason = "tie_break_random" + elif prediction.random_selection_made and len(match_set) == 0: + selection_reason = "no_matching_rules_random" + elif not prediction.random_selection_made and not prediction.majority_class_selection_made and len(match_set) == 0: + selection_reason = "no_matching_rules_training_majority" + + structured = { + "outcome_prediction": outcome_prediction, + "prediction_probabilities": outcome_proba, + "covered": bool(outcome_coverage), + "num_matching_rules": len(match_set), + "whole_rule_population": bool(whole_rule_pop), + "target_model_index": int(target_model) if not whole_rule_pop else None, + "selection_reason": selection_reason, + "algorithm": { + "outcome_type": self.outcome_type, + "classes": list(self.env.classes) if hasattr(self.env, 'classes') else None, + "voting_scheme": "whole_population" if whole_rule_pop else "top_model_rule_set", + "numerosity_sum": getattr(prediction, 'numerosity_sum', None), + "tie_breaking": { + "majority_class": bool(getattr(prediction, 'majority_class_selection_made', False)), + "random": bool(getattr(prediction, 'random_selection_made', False)) + } + }, + "features": features_view, + "supporting_rules": supporting_rules, + "contradictory_rules": contradictory_rules, + "per_rule_contributions": per_rule_contributions, + "match_set_rule_ids": [getattr(rule_source[i], 'ID', None) for i in match_set] + } + + # A short narrative for user-facing explanation layers + try: + num_support = len(supporting_rules) + num_contra = len(contradictory_rules) + coverage_text = "covered" if structured["covered"] else "not covered" + tie_text = " with tie broken by training majority" if structured["algorithm"]["tie_breaking"]["majority_class"] else (" with random tie-break" if structured["algorithm"]["tie_breaking"]["random"] else "") + narrative = ( + "Instance is "+coverage_text+" by "+str(structured["num_matching_rules"]) + + " rule(s); " + str(num_support) + " support the predicted class '"+str(outcome_prediction)+"' and " + + str(num_contra) + " contradict. Prediction made via " + structured["algorithm"]["voting_scheme"] + tie_text + "." + ) + structured["narrative"] = narrative + except Exception: + structured["narrative"] = None + + return structured def predict(self, X, whole_rule_pop=False, target_model=0, rule_pop_iter=None, model_pop_iter=None): """Scikit-learn required: Apply trained model to predict outcomes of instances. @@ -786,7 +1083,7 @@ def predict_covered(self, X, whole_rule_pop=False, target_model=0, rule_pop_iter def get_pop(self): """ Return a dataframe of the rule population. """ self.rule_population.order_all_rule_conditions() - pop_df = self.rule_population.export_rule_population() + pop_df = self.rule_population.export_rule_population(self.rsl) return pop_df def get_ft(self,feature_names): diff --git a/src/skheros/methods/data_mange.py b/src/skheros/methods/data_mange.py index 14fe4d5..0de8a0d 100644 --- a/src/skheros/methods/data_mange.py +++ b/src/skheros/methods/data_mange.py @@ -1,5 +1,6 @@ import math import numpy as np +import random class DATA_MANAGE: def __init__(self, X, y, row_id, cat_feat_indexes, ek, heros): @@ -208,6 +209,11 @@ def reset_instance(self): self.instance_state = self.train_data[0][self.instance_index] self.outcome_state = self.train_data[1][self.instance_index] + def get_weighted_instance(self,heros): + instance_index = random.choices(list(range(self.num_instances)), weights = heros.training_weights)[0] + instance_state = self.train_data[0][instance_index] + outcome_state = self.train_data[1][instance_index] + return (instance_state, outcome_state) def report_data(self, heros): print("Data Manage Summary: ------------------------------------------------") diff --git a/src/skheros/methods/model_population.py b/src/skheros/methods/model_population.py index 1de97c6..9f193f5 100644 --- a/src/skheros/methods/model_population.py +++ b/src/skheros/methods/model_population.py @@ -26,6 +26,7 @@ def __init__(self): "Coverage", "Rules in Model", "Total Time"] + self.model_alterations = [] # Archiving ---------------------------- self.pop_set_archive = {} self.pop_set_hold = None @@ -51,7 +52,8 @@ def print_tracking_entry(self): """ Prints the tracking information for the current training iteration. """ self.tracking_entry = [round(num,3) for num in self.tracking_entry] report_df = pd.DataFrame([self.tracking_entry], columns=self.tracking_header,index=None) - print(report_df) + print(report_df.to_string(index=False)) + #print(report_df) def get_performance_tracking_df(self): """ Returns performance tracking over all training iterations as a dataframe. """ @@ -85,6 +87,7 @@ def restore_model_pop(self): def make_eval_match_set(self,instance_state,heros): """ Makes a match set {M} given an instance state. Used by predict function.""" + self.match_set = [] for i in range(len(self.target_rule_set)): rule = self.target_rule_set[i] if rule.match(instance_state,heros): @@ -96,6 +99,7 @@ def sort_match_set(self): def make_eval_correct_set(self,outcome_state,heros): """ Makes a correct set {C} given an instance outcome and {M}. Used by model feature tracking.""" + self.correct_set = [] for i in range(len(self.match_set)): rule_index = self.match_set[i] if heros.outcome_type == 'class': @@ -510,25 +514,40 @@ def model_deletion(self,heros,fronts,crowding_distances): self.pop_set = new_pop_set - def export_model_population(self): - """ Prepares and exports a dataframe capturing the rule population. """ - pop_list = [] - column_names = ['Rule IDs', - 'Number of Rules', - 'Accuracy', - 'Coverage', - 'Birth Iteration', - 'Model on Front'] - for model in self.pop_set: - model_list = [str(model.rule_IDs), - len(model.rule_set), - model.accuracy, - model.coverage, - model.birth_iteration, - model.model_on_front] - pop_list.append(model_list) - pop_df = pd.DataFrame(pop_list, columns = column_names) - return pop_df + def export_model_population(self, model_pop_iter=None): + """ Prepares and exports a dataframe capturing the rule population at a given iteration (defualt live population). """ + switched = False + if model_pop_iter is not None: + self.change_model_pop(model_pop_iter) + switched = True + try: + + self.sort_model_pop() + self.identify_models_on_front() + + pop_list = [] + column_names = ['Rule IDs', + 'Number of Rules', + 'Accuracy', + 'Coverage', + 'Birth Iteration', + 'Model on Front'] + for model in self.pop_set: + model_list = [str(model.rule_IDs), + len(model.rule_set), + model.accuracy, + model.coverage, + model.birth_iteration, + model.model_on_front] + pop_list.append(model_list) + pop_df = pd.DataFrame(pop_list, columns = column_names) + return pop_df + + finally: + if switched: + self.restore_model_pop() + + def custom_sort_key(self, obj): @@ -711,6 +730,22 @@ def plot_model_tracking(self,show, save, output_path): ax2.plot(tracking_df['Iteration'], tracking_df['Rules in Model'], 'r--', label='Rules in Model') # 'r--' specifies a red dashed line ax2.set_ylabel('Rules in Model', color='r') ax2.tick_params(axis='y', labelcolor='r') + + y_min, y_max = ax1.get_ylim() + label_y = y_max - 0.02 * (y_max - y_min) + + for x in self.model_alterations: + ax1.axvline(x=x, color='black', linestyle=':', linewidth=1) + ax1.text( + x + 0.5, + label_y, + f"alt {self.model_alterations.index(x)}", + rotation=0, + va='top', + ha='right', + fontsize=8, + color='black' + ) if save: plt.savefig(output_path+'/model_tracking_line_graph.png', bbox_inches="tight") if show: diff --git a/src/skheros/methods/rule.py b/src/skheros/methods/rule.py index 96fa570..c48b5f4 100644 --- a/src/skheros/methods/rule.py +++ b/src/skheros/methods/rule.py @@ -1,4 +1,5 @@ import copy +import struct class RULE: def __init__(self,heros): @@ -38,6 +39,7 @@ def __init__(self,heros): self.ave_match_set_size = 1 #average size of the match sets in which this rule was included across all training instances - used in deletion to promote niching self.deletion_prob = None #probability of rule being selected for deletion self.prediction = None + self.encoding = None def __eq__(self, other): return isinstance(other, RULE) and self.ID == other.ID @@ -69,6 +71,7 @@ def initialize_by_covering(self,set_numerosity_sum,instance_state,outcome_state, self.quantitative_range_check_fix(self.action,outcome_state,random,np) else: print("Error: Outcome type undefined.") + #self.encoding = self.encode_rule_binary(heros.env.num_feat) def initialize_by_parent(self,parent_rule,heros): @@ -86,6 +89,7 @@ def initialize_by_parent(self,parent_rule,heros): self.numerosity = 1 self.ave_match_set_size = copy.deepcopy(parent_rule.ave_match_set_size) self.deletion_prob = None + #self.encoding = self.encode_rule_binary(heros.env.num_feat) def match(self, instance_state, heros): @@ -139,6 +143,7 @@ def uniform_crossover(self,other_rule,heros,random,np): if feat in o2_condition_indexes: feature_occurence += 2 # Perform exchange + """ if feature_occurence == 1: #feature only in o1 (was self) rule_position = self.condition_indexes.index(feat) other_rule.condition_values.append(self.condition_values.pop(rule_position)) @@ -149,6 +154,24 @@ def uniform_crossover(self,other_rule,heros,random,np): self.condition_values.append(other_rule.condition_values.pop(rule_position)) self.condition_indexes.append(feat) other_rule.condition_indexes.remove(feat) + """ + #Reproducibility FIX Reccommended by Google Gemini + if feature_occurence == 1: # feature only in self, move to other + idx = self.condition_indexes.index(feat) + val = self.condition_values.pop(idx) + self.condition_indexes.pop(idx) # Use pop(idx) here too! + + other_rule.condition_indexes.append(feat) + other_rule.condition_values.append(val) + + elif feature_occurence == 2: # feature only in other, move to self + idx = other_rule.condition_indexes.index(feat) + val = other_rule.condition_values.pop(idx) + other_rule.condition_indexes.pop(idx) # Keep them in sync! + + self.condition_indexes.append(feat) + self.condition_values.append(val) + else: #feature in both o1 and o2 if not is_categorical: #if quantiative feature feat_index_1 = self.condition_indexes.index(feat) @@ -514,7 +537,7 @@ def generalize_condition(self,num_to_generalize,instance_state,changed_features, def reestablish_rule(self,rule_summary,heros): #[rule.condition_indexes, rule.condition_values, rule.action, rule.instance_outcome_count,rule.ID, rule.birth_iteration] - self.ID = rule_summary[4] #unique identifier for this rule (used in model evolution and does not guarantee global uniqueness) + self.ID = rule_summary[4] self.birth_iteration = rule_summary[5] self.condition_indexes = rule_summary[0] #list of feature indexes from the dataset that are 'specified' in this rule self.condition_values = rule_summary[1] #list of feature values or value-ranges corresponding to the feature indexes in self.feature_index_list @@ -522,6 +545,7 @@ def reestablish_rule(self,rule_summary,heros): self.match_cover = sum(self.instance_outcome_count.values()) # Assign class that yields highest rule accuracy - regardless of current target instance class self.instance_outcome_prop = copy.deepcopy(self.instance_outcome_count) + #self.ID = self.encode_rule_binary(heros.env.num_feat) #Convert class counts first into class accuracies then into 'useful' accuracies to take class imbalance into account for each in self.instance_outcome_prop: self.instance_outcome_prop[each] /= self.match_cover @@ -579,7 +603,7 @@ def complete_rule_evaluation_class(self,heros,random,target_instance_outcome): if target_instance_outcome in candidate_actions: #go with the current target instance class if there is a tie for best class self.action = target_instance_outcome else: - self.action = random.choice(candidate_actions) + self.action = random.choice(sorted(candidate_actions)) self.correct_cover = self.instance_outcome_count[self.action] # Calculate rule accuracy *************************** try: @@ -606,9 +630,12 @@ def complete_rule_evaluation_class(self,heros,random,target_instance_outcome): if self.fitness is None: #Pareto front only has (0,0) for useful_accuracy and useful_coverage self.fitness = pow(self.accuracy, heros.nu) if front_updated: #all rule-fitnesses will be re-calculated externally + #self.encoding = self.encode_rule_binary(heros.env.num_feat) return True else: print("Fitness metric not available.") + + #self.encoding = self.encode_rule_binary(heros.env.num_feat) return False @@ -746,6 +773,7 @@ def equals(self,other_rule): return False #final check yields inequality return True #rules are equivalent return False #initial or secondary checks yield inequality + #return self.encoding == other_rule.encoding def get_deletion_vote(self): @@ -812,6 +840,62 @@ def translate_rule(self,feature_names,heros): translation += " THEN: predict outcome '"+str(self.action)+"' with "+str(100 * self.instance_outcome_prop[self.action])+"% confidence based on "+str(self.match_cover)+' matching training instances ('+str(round(100*self.match_cover /float(heros.env.num_instances),2))+"% of training instances)." print(translation) + def to_explanation_dict(self, feature_names, heros): + """Return a structured, LLM-friendly explanation of this rule. + + The structure includes both machine- and human-readable fields for conditions and + key rule statistics useful for downstream reasoning layers. + """ + # Ensure deterministic ordering of conditions + self.order_rule_conditions() + conditions = [] + for i in range(len(self.condition_indexes)): + feature_index = self.condition_indexes[i] + value = self.condition_values[i] + is_categorical = (heros.env.feat_types[feature_index] == 1) + if is_categorical: + human = { + "text": str(feature_names[feature_index])+" = "+str(value) + } + cond = { + "feature_index": feature_index, + "feature_name": feature_names[feature_index], + "type": "categorical", + "operator": "=", + "value": value, + "human_readable": human["text"] + } + else: + # quantitative range (min, max) + range_min, range_max = value[0], value[1] + human_text = str(feature_names[feature_index])+" in ["+str(range_min)+", "+str(range_max)+"]" + cond = { + "feature_index": feature_index, + "feature_name": feature_names[feature_index], + "type": "quantitative", + "operator": "in_range", + "min": range_min, + "max": range_max, + "human_readable": human_text + } + conditions.append(cond) + + explanation = { + "rule_id": getattr(self, "ID", None), + "action": self.action, + "instance_outcome_proportions": dict(self.instance_outcome_prop) if hasattr(self, "instance_outcome_prop") else {}, + "numerosity": self.numerosity, + "fitness": self.fitness, + "accuracy": self.accuracy, + "match_cover": self.match_cover, + "correct_cover": self.correct_cover, + "average_match_set_size": self.ave_match_set_size, + "deletion_probability": self.deletion_prob, + "birth_iteration": self.birth_iteration, + "conditions": conditions + } + return explanation + def order_rule_conditions(self): """ Order the rule conditions by increasing feature index; keeping the ordering consistent between condition_indexes and condition_values.""" @@ -825,4 +909,72 @@ def order_rule_conditions(self): sorted_list1, sorted_list2 = zip(*sorted_combined) # Convert the tuples back to lists self.condition_indexes = list(sorted_list1) - self.condition_values = list(sorted_list2) \ No newline at end of file + self.condition_values = list(sorted_list2) + + """def encode_rule_binary(self, num_features): + # --- 1. Bitmask --- + bitmask = ['0'] * num_features + for idx in self.condition_indexes: + bitmask[idx] = '1' + bitmask_str = ''.join(bitmask) + + # --- 2. Type indicators + values --- + type_indicators = ['0'] * num_features # all values are int → '0' + value_bits = ['00'] * num_features # pre-fill with 2-bit zeros + + # Sorted index-value pairs for consistent position + index_to_value = dict(zip(self.condition_indexes, self.condition_values)) + for i in range(num_features): + if i in index_to_value: + val = index_to_value[i] + if not (0 <= val <= 3): + raise ValueError(f"Value {val} at index {i} exceeds 2-bit range.") + value_bits[i] = format(val, '02b') # 2 bits per int + + type_str = ''.join(type_indicators) + values_str = ''.join(value_bits) + + # --- 3. Action (assumed 2-bit) --- + if not (0 <= self.action <= 3): + raise ValueError(f"Action value {self.action} exceeds 2-bit range.") + action_bits = format(self.action, '02b') + + # --- 4. Combine everything --- + full_binary_str = bitmask_str + type_str + values_str + action_bits + return full_binary_str""" + + def encode_rule_binary(self, num_features): + "Deterministically encodes a rule into a binary string." + # --- 1. Bitmask: fixed order for feature indexes --- + bitmask = ['0'] * num_features + for idx in sorted(self.condition_indexes): # sort to ensure order + bitmask[idx] = '1' + bitmask_str = ''.join(bitmask) + # --- 2. Condition types and values --- + # Pair condition values with sorted condition indexes + sorted_pairs = sorted(zip(self.condition_indexes, self.condition_values), key=lambda x: x[0]) + encoded_values = [] + type_indicators = [] + for _, value in sorted_pairs: + if isinstance(value, int): + type_indicators.append('0') + encoded_values.append(format(value, '032b')) + elif isinstance(value, tuple) and len(value) == 2: + type_indicators.append('1') + min_binary = format(struct.unpack('>I', struct.pack('>f', value[0]))[0], '032b') + max_binary = format(struct.unpack('>I', struct.pack('>f', value[1]))[0], '032b') + encoded_values.append(min_binary + max_binary) + #else: + #raise ValueError(f”Unsupported value type: {value}“) + type_str = ''.join(type_indicators) + # --- 3. Action: fixed 32-bit integer --- + action_binary = format(self.action, '032b') + # --- 4. Combine all sections into final binary string --- + full_binary_str = ( + bitmask_str + + type_str + + ''.join(encoded_values) + + action_binary + ) + # --- 5. Return the full binary string --- + return full_binary_str \ No newline at end of file diff --git a/src/skheros/methods/rule_compaction.py b/src/skheros/methods/rule_compaction.py index e338382..02343eb 100644 --- a/src/skheros/methods/rule_compaction.py +++ b/src/skheros/methods/rule_compaction.py @@ -22,6 +22,7 @@ def basic_rule_cleaning(self,heros): if rule.useful_accuracy <= 0: #Remove bad rule from population heros.rule_population.pop_set.pop(index) + heros.rule_population.micro_pop_count -= rule.numerosity else: index += 1 if heros.verbose: diff --git a/src/skheros/methods/rule_population.py b/src/skheros/methods/rule_population.py index 02b1da2..af53782 100644 --- a/src/skheros/methods/rule_population.py +++ b/src/skheros/methods/rule_population.py @@ -1,13 +1,23 @@ import copy import pandas as pd import ast -from .rule import RULE +from skheros.methods.rule import RULE import seaborn as sns import matplotlib.pyplot as plt from scipy.cluster.hierarchy import linkage #, dendrogram, leaves_list import networkx as nx from collections import defaultdict from itertools import combinations +import struct +from sklearn.ensemble import RandomForestClassifier +from sklearn.tree import _tree#, DecisionTreeClassifier +from sklearn.preprocessing import OneHotEncoder +#from collections import Counter +#from sklearn import tree as sktree +#from matplotlib.table import Table +#from textwrap import fill +#import matplotlib.patches as mpatches +import matplotlib.pyplot as plt class RULE_POP: def __init__(self): @@ -20,31 +30,26 @@ def __init__(self): self.pop_set_archive = {} self.pop_set_hold = None #Experimental - self.explored_rules = [] + self.explored_rules = {} self.archive_discovered_rules = False #True value is experimental - def add_new_explored_rules(self,rule): + def add_new_explored_rules(self,rule, heros): """Stores the unique and essential information to reconstitute an explored rule without re-evaluation.""" - rule_entry = [rule.condition_indexes, rule.condition_values, rule.action, rule.instance_outcome_count, rule.ID, rule.birth_iteration] - self.explored_rules.append(rule_entry) + #rule_entry = [rule.condition_indexes, rule.condition_values, rule.action, rule.instance_outcome_count, rule.ID, rule.birth_iteration] + #self.explored_rules.append(rule_entry) + self.explored_rules[rule.encoding] = rule.instance_outcome_count def clear_explored_rules(self): - self.explored_rules = None + self.explored_rules = {} - def rule_exists(self, target_rule): + def rule_exists(self, target_rule, heros): """Checks the explored rules list to see if a given 'new' rule has been previously discovered and evaluated, returning that rule's reference in explored rules.""" - #print('test') - #print(target_rule.condition_indexes) - #print(target_rule.condition_values) - - for rule_summary in self.explored_rules: - if self.equals(target_rule,rule_summary): - #print(rule_summary[0]) - #print(rule_summary[1]) - return rule_summary + encoded = target_rule.encode_rule_binary(heros.env.num_feat) + if encoded in self.explored_rules: + return self.decode_rule_binary(encoded, heros.env.num_feat) return None @@ -102,7 +107,7 @@ def make_match_set(self, instance,heros,random,np): if len(new_rule.condition_indexes) > 0: #prevents completely general rules from being added to the population #Check for duplicate rule in {P} - important since covering runs if {C} is empty, which can generate an existing rule in the match set if self.archive_discovered_rules: - rule_summary = self.rule_exists(new_rule) + rule_summary = self.rule_exists(new_rule,heros) if rule_summary == None: self.evaluate_covered_rule(new_rule,outcome_state,heros,random) else: @@ -110,7 +115,7 @@ def make_match_set(self, instance,heros,random,np): else: self.evaluate_covered_rule(new_rule,outcome_state,heros,random) if self.no_identical_rule_exists(new_rule,heros,'match_set'): - self.add_rule_to_pop(new_rule) + self.add_rule_to_pop(new_rule,heros) self.match_set.append(len(self.pop_set)-1) heros.timer.covering_time_stop() #covering time tracking @@ -221,6 +226,7 @@ def genetic_algorithm(self, instance, heros, random,np): heros.timer.selection_time_start() #parent selection time tracking parent_list = self.tournament_selection(heros,random) heros.timer.selection_time_stop() #parent selection time tracking + # INITIALIZE OFFSPRING ************************************* heros.timer.mating_time_start() #mating time tracking offspring_list = [] @@ -228,30 +234,36 @@ def genetic_algorithm(self, instance, heros, random,np): new_rule = RULE(heros) new_rule.initialize_by_parent(parent_rule,heros) offspring_list.append(new_rule) + # CROSSOVER OPERATOR ************************************** if len(offspring_list) > 1: #crossover only applied between two parent rules if random.random() < heros.cross_prob: offspring_list[0].uniform_crossover(offspring_list[1],heros,random,np) #for offspring in offspring_list: #debug # self.debug_confirm_offspring_match(offspring, instance,heros,'crossover',parent_list) + # MUTATION OPERATOR *************************************** for offspring in offspring_list: offspring.mutation(instance_state,outcome_state,heros,random,np) #for offspring in offspring_list: #debug # self.debug_confirm_offspring_match(offspring, instance,heros,'mutation',parent_list) heros.timer.mating_time_stop() #mating time tracking + #Check for offspring duplication if len(offspring_list) > 1: if offspring_list[0].equals(offspring_list[1]): offspring_list.pop() + #print('This happened') + #print("Random Seed Check post GA - equal offspring: "+ str(random.random())) if len(offspring_list) > 1: print("ERROR: More than 2 expected offspring in GA") + # CHECK FOR DUPLICATE RULES IN {P} and EVALUATE Non-Duplicate Ruels front_updated = False final_offspring_list = [] for offspring in offspring_list: if self.archive_discovered_rules: - rule_summary = self.rule_exists(offspring) + rule_summary = self.rule_exists(offspring,heros) if rule_summary == None: heros.timer.rule_eval_time_start() #rule evaluation time tracking front_changed = self.evaluate_offspring_rule(offspring,outcome_state,heros,random) @@ -269,6 +281,7 @@ def genetic_algorithm(self, instance, heros, random,np): if self.no_identical_rule_exists(offspring,heros,'pop_set'): final_offspring_list.append(offspring) + # Update all rule fitness values if one or both offspring rules updated the pareto front heros.timer.rule_eval_time_start() #rule evaluation time tracking if heros.fitness_function == 'pareto' and front_updated: #new 3/29/25 @@ -277,26 +290,36 @@ def genetic_algorithm(self, instance, heros, random,np): for offspring in final_offspring_list: offspring.update_rule_fitness(heros) heros.timer.rule_eval_time_stop() #rule evaluation time tracking + # INSERT RULE(S) IN POPULATON (OPTIONAL GA SUBSUMPTION) *************************** - self.process_offspring(parent_list,final_offspring_list,heros) + return self.process_offspring(parent_list,final_offspring_list,heros) def tournament_selection(self,heros,random): """ Applies tournament selection to choose and return two parent rules. """ - parent_options = copy.deepcopy(self.match_set) + parent_options = sorted(copy.deepcopy(self.match_set)) #extra code to ensure random seed reproducibility parent_list = [] + #print("length of match set: "+str(len(self.match_set))) + #for rule_ref in parent_options: #debugging + # self.pop_set[rule_ref].show_rule() + if len(parent_options) == 1: #only one rule in {M} - parent_list = [self.pop_set[self.match_set[0]]] #only one parent returned + #parent_list = [self.pop_set[self.match_set[0]]] #only one parent returned + parent_list = [self.pop_set[parent_options[0]]] elif len(parent_options) == 2: #only two rules in {M} - parent_list = [self.pop_set[self.match_set[0]],self.pop_set[self.match_set[1]]] + #parent_list = [self.pop_set[self.match_set[0]],self.pop_set[self.match_set[1]]] + parent_list = [self.pop_set[parent_options[0]], self.pop_set[parent_options[1]]] else: while len(parent_list) < 2: tournament_size = max(2,int(len(parent_options)*heros.theta_sel)) tournament_set = random.sample(parent_options,tournament_size) - best_fitness = 0 - best_rule_index = self.match_set[0] + #best_fitness = 0 + #best_rule_index = self.match_set[0] + best_rule_index = tournament_set[0] + best_fitness = self.pop_set[best_rule_index].fitness + for i in tournament_set: - if self.pop_set[i].fitness >= best_fitness: + if self.pop_set[i].fitness > best_fitness or (self.pop_set[i].fitness == best_fitness and self.pop_set[i].ID < self.pop_set[best_rule_index].ID): #extra code to ensure random seed reproducibility best_fitness = self.pop_set[i].fitness best_rule_index = i parent_list.append(self.pop_set[best_rule_index]) @@ -305,19 +328,24 @@ def tournament_selection(self,heros,random): def process_offspring(self,parent_list,offspring_list,heros): + new_rules = [] """ Activates GA subsumption (if used), and then inserts offpring rules into population as needed. """ if heros.subsumption == 'ga' or heros.subsumption == 'both': #apply subsumption and insert rule(s) as needed heros.timer.subsumption_time_start() for offspring in offspring_list: - self.ga_subsumption(offspring,parent_list,heros) + new_rules.extend(self.ga_subsumption(offspring,parent_list,heros)) heros.timer.subsumption_time_stop() else: #insert rule(s) as needed following rule equality check for offspring in offspring_list: - self.add_rule_to_pop(offspring) + self.add_rule_to_pop(offspring,heros) + print("process") + new_rules = offspring_list + return new_rules def ga_subsumption(self,offspring,parent_list,heros): """ Applies GA subsumption. """ + new_rules = [] offspring_subsumed = False for parent in parent_list: if not offspring_subsumed: @@ -326,24 +354,10 @@ def ga_subsumption(self,offspring,parent_list,heros): self.micro_pop_count += 1 parent.update_numerosity(1) if not offspring_subsumed: - self.add_rule_to_pop(offspring) + self.add_rule_to_pop(offspring,heros) + new_rules.append(offspring) + return new_rules - """ - def add_covered_rule_to_pop(self,new_rule,outcome_state,heros,random): #old now - #Adds a new rule to the population via covering: either as a new rule entry in the population or increasing the numerosity of a rule that already exists. - heros.timer.covering_time_stop() #covering time tracking - heros.timer.rule_eval_time_start() #rule evaluation time tracking - if heros.outcome_type == 'class': - front_updated = new_rule.complete_rule_evaluation_class(heros,random,outcome_state) #only called if brand new rule being added to population - elif heros.outcome_type == 'quant': - front_updated = new_rule.complete_rule_evaluation_quant(heros) #only called if brand new rule being added to population - else: - pass - if heros.fitness_function == 'pareto' and front_updated: #new 3/29/25 - self.global_fitness_update(heros) - heros.timer.rule_eval_time_stop() #rule evaluation time tracking - heros.timer.covering_time_start() #covering time tracking - """ def evaluate_covered_rule(self,new_rule,outcome_state,heros,random): heros.timer.covering_time_stop() #covering time tracking @@ -407,14 +421,14 @@ def search_match_set_for_identical_rule(self,new_rule): return None - def add_rule_to_pop(self,new_rule): + def add_rule_to_pop(self,new_rule,heros): """ Add new and novel rule to population, updating key relevant parameters. """ new_rule.assign_ID(self.ID_counter) self.pop_set.append(new_rule) self.ID_counter += 1 #every time a new rule gets added to the pop (that isn't in the current pop) it is assigned a new unique ID self.micro_pop_count += 1 if self.archive_discovered_rules: - self.add_new_explored_rules(new_rule) + self.add_new_explored_rules(new_rule,heros) def make_correct_set(self,outcome_state,heros): @@ -467,10 +481,11 @@ def delete_rule(self,random): new_sum = new_sum + vote_list[i] if new_sum > choicePoint: # Select classifier for deletion # Delete classifier---------------------------------- - rule.update_numerosity(-1) self.micro_pop_count -= 1 - if rule.numerosity < 1: # When all micro-classifiers for a given classifier have been depleted. + if rule.numerosity == 1: # When all micro-classifiers for a given classifier have been depleted. self.remove_macro_rule(i) + else: + rule.update_numerosity(-1) return @@ -502,11 +517,10 @@ def order_all_rule_conditions(self): def load_rule_population(self, pop_df, heros, random, np): """ Load a HEROS rule population data frame, then instantiates and evaluates all rules. Each specified rule must have a condition and action at minimum. """ - self.ID_counter = pop_df['ID'].astype(int).max() + self.ID_counter = pop_df['ID'].astype(int).max() + 1 if heros.verbose: print("Initializing Rule Population via Loaded File!") print('Max Rule ID in Loaded Population: '+str(self.ID_counter)) - self.ID_counter += 1 for index, row in pop_df.iterrows(): # Initialize the rule loaded_rule = RULE(heros) @@ -542,8 +556,8 @@ def load_rule_population(self, pop_df, heros, random, np): front_updated = loaded_rule.complete_rule_evaluation_quant(heros) #only called if brand new rule being added to population # Add rule to the population self.pop_set.append(loaded_rule) - self.ID_counter += 1 #every time a new rule gets added to the pop (that isn't in the current pop) it is assigned a new unique ID self.micro_pop_count += loaded_rule.numerosity + # Update all rule fitness values (if pareto front rule fitness used) if heros.fitness_function == 'pareto': #new 3/29/25 self.global_fitness_update(heros) @@ -551,7 +565,434 @@ def load_rule_population(self, pop_df, heros, random, np): print('Loading Rule Population Complete: '+str(len(self.pop_set))+' unique rules and '+str(self.micro_pop_count)+' total rules loaded.') - def export_rule_population(self): + def tree_init_population(self, X, y, heros, random, np, verbose = False, bstrap = False): + """ Trains a set of decision trees using random forest classifier and then extracts rules from tree branches, deduplicates the candidate rule population, converts rules to HEROS format and lastly evaluates all unique rules and updates remaining rule parameters. Initial exploration of methodology by Harsh Bandhey, and early contributions to method development by following UPenn students: Akshita Islam, Khoi Dinh, and Gabe Gabe Lipschutz-Villa. """ + + # STEP 1: Hard Coded Random Forest Hyperparameters for Tree Training and Rule Extraction -------------------------------- + RF_INIT_SHARED = { + "n_estimators": 10, + "bootstrap": bstrap, + "oob_score": False, + "n_jobs": -1, + "random_state": heros.random_state, + "max_features": "sqrt", + } + + max_depth_values = [1, 2, 3, 4, 5, 6, 7, None] + + rf_settings = [ + { + **RF_INIT_SHARED, + "max_depth": depth + } + for depth in max_depth_values + ] + # ----------------------------------------------------------------------------------------------------------------- + print('Beginning Decision Tree Rule Inititialization...') + #-------------------------------------------------------------------------------------------------------------------- + # STEP 2: One Hot Encode the categorical features for decision tree training (since random forest classifier expects quantitative features) + #original_X = X.copy() if hasattr(X, 'copy') else X + onehot_mapping = {} # Maps one-hot encoded feature index -> (original_feat_idx, categorical_value) + reverse_onehot_mapping = {} # Maps (original_feat_idx, categorical_value) -> one-hot encoded feature index + quant_feat_mapping = {} # Maps encoded quantitative feature index -> original feature index + + if heros.cat_feature_indexes is not None and len(heros.cat_feature_indexes) > 0: + print(f"\nOne-hot encoding {len(heros.cat_feature_indexes)} categorical features...") + + # Convert X to numpy array if it's a DataFrame + if hasattr(X, 'values'): + X_array = X.values + X_is_dataframe = True + X_columns = list(X.columns) + else: + X_array = np.array(X) + X_is_dataframe = False + X_columns = None + + # Separate categorical and quantitative features + cat_feat_indexes = sorted(heros.cat_feature_indexes) + quant_feat_indexes = sorted([i for i in range(X_array.shape[1]) if i not in cat_feat_indexes]) + + # Extract categorical and quantitative columns + cat_data = X_array[:, cat_feat_indexes] + quant_data = X_array[:, quant_feat_indexes] if quant_feat_indexes else None + + # One-hot encode categorical features + onehot_encoder = OneHotEncoder(sparse_output=False, drop=None, handle_unknown='ignore') + cat_onehot = onehot_encoder.fit_transform(cat_data) + + # Build mapping: one-hot encoded feature index -> (original_feat_idx, categorical_value) + # Also build mapping for quantitative features: encoded_idx -> original_idx + if quant_feat_indexes: + for encoded_idx, orig_idx in enumerate(quant_feat_indexes): + quant_feat_mapping[encoded_idx] = orig_idx + + # Build one-hot mapping + #current_onehot_idx = 0 + num_quant = len(quant_feat_indexes) if quant_feat_indexes else 0 + + for cat_col_idx, orig_cat_idx in enumerate(cat_feat_indexes): + # Get the categories from the encoder (in order) + if hasattr(onehot_encoder, 'categories_'): + encoder_categories = onehot_encoder.categories_[cat_col_idx] + else: + # Fallback: use unique values from data + encoder_categories = np.unique(cat_data[:, cat_col_idx]) + + # Find the start index for this categorical feature's one-hot columns and count how many one-hot columns come before this feature + onehot_start_idx = 0 + for prev_cat_idx in cat_feat_indexes: + if prev_cat_idx == orig_cat_idx: + break + prev_cat_col_idx = cat_feat_indexes.index(prev_cat_idx) + if hasattr(onehot_encoder, 'categories_'): + onehot_start_idx += len(onehot_encoder.categories_[prev_cat_col_idx]) + else: + onehot_start_idx += len(np.unique(cat_data[:, prev_cat_col_idx])) + + # Map each one-hot column for this categorical feature + for cat_val_idx, cat_val in enumerate(encoder_categories): + onehot_feat_idx = num_quant + onehot_start_idx + cat_val_idx + onehot_mapping[onehot_feat_idx] = (orig_cat_idx, cat_val) + reverse_onehot_mapping[(orig_cat_idx, cat_val)] = onehot_feat_idx + + # Combine quantitative and one-hot encoded features + if quant_data is not None: + X_encoded = np.hstack([quant_data, cat_onehot]) + else: + X_encoded = cat_onehot + + # Convert back to DataFrame if original was DataFrame + if X_is_dataframe: + # Create new column names + new_columns = [] + if quant_feat_indexes: + new_columns.extend([X_columns[i] for i in quant_feat_indexes]) + for orig_cat_idx in cat_feat_indexes: + cat_values = heros.env.feat_c_values[orig_cat_idx] + if hasattr(onehot_encoder, 'categories_'): + encoder_categories = onehot_encoder.categories_[cat_feat_indexes.index(orig_cat_idx)] + else: + encoder_categories = np.unique(cat_data[:, cat_feat_indexes.index(orig_cat_idx)]) + for cat_val in encoder_categories: + new_columns.append(f"{X_columns[orig_cat_idx]}_{cat_val}") + X = pd.DataFrame(X_encoded, columns=new_columns, index=X.index if hasattr(X, 'index') else None) + else: + X = X_encoded + + print(f" Original features: {X_array.shape[1]}, After one-hot encoding: {X.shape[1]}") + print(f" One-hot mapping created for {len(onehot_mapping)} encoded features") + print(f" Quantitative feature mapping: {len(quant_feat_mapping)} features") + else: + print("\nNo categorical features to encode.") + + #-------------------------------------------------------------------------------------------------------------------- + # STEP 3: Train multiple random forest classifiers with varying hyperparameters to create a diverse set of decision trees for rule extraction + rf_models = [] + tree_depths_by_rf = [] + for idx, params in enumerate(rf_settings): + rf = RandomForestClassifier( + **params + ) + rf.fit(X, y) + rf_models.append(rf) + tree_depths = [estimator.tree_.max_depth for estimator in rf.estimators_] + tree_depths_by_rf.append(tree_depths) + + # Save the first RF for fidelity proof and visualization - FOR DEBUGGING ONLY, CAN BE REMOVED LATER + self.rf_model = rf_models[0] + + print("Random Seed Check After RF: "+ str(random.random())) + + def print_rf_training_summary(rf_models): + print("\nSummary: Trained {} random forests with varying hyperparameters.".format(len(rf_models))) + for i, rf in enumerate(rf_models): + depths = [estimator.tree_.max_depth for estimator in rf.estimators_] + print(f" RF {i+1}: n_estimators={len(rf.estimators_)}, tree depths={depths}") + + if verbose: + print_rf_training_summary(rf_models) + + # STEP 4: Extract rules from all trees in all forests + print("\nExtracting rules from all decision tree branches in all forests...") + all_rules = [] + branch_paths = [] + + def recurse_tree(tree, node_id, path, rules, branch_paths=None, onehot_mapping=None): #consider updating to only store condition (no action) + if tree.children_left[node_id] == _tree.TREE_LEAF: + condition_indexes = [] + condition_values = [] + for feat_idx, threshold, direction in path: + condition_indexes.append(feat_idx) + condition_values.append((direction, threshold)) + values = tree.value[node_id][0] + action = np.argmax(values) + rules.append([condition_indexes, condition_values, action]) + if branch_paths is not None: + branch_paths.append((list(condition_indexes), list(condition_values), action, list(path))) + return + left_id = tree.children_left[node_id] + feat_idx = tree.feature[node_id] + threshold = tree.threshold[node_id] + recurse_tree(tree, left_id, path + [(feat_idx, threshold, 'leq')], rules, branch_paths, onehot_mapping) + right_id = tree.children_right[node_id] + recurse_tree(tree, right_id, path + [(feat_idx, threshold, 'gt')], rules, branch_paths, onehot_mapping) + + for rf in rf_models: + for estimator in rf.estimators_: + recurse_tree(estimator.tree_, 0, [], all_rules, branch_paths, onehot_mapping) + + if verbose: + # Visual: Tree Depth vs. Number of Rules Produced + rf_depths = [max([est.tree_.max_depth for est in rf.estimators_]) for rf in rf_models] + rules_per_rf = [] + for rf in rf_models: + rf_rules = [] + for estimator in rf.estimators_: + local_rules = [] + recurse_tree(estimator.tree_, 0, [], local_rules) + rf_rules.extend(local_rules) + rules_per_rf.append(len(rf_rules)) + plt.figure(figsize=(7, 4)) + plt.scatter(rf_depths, rules_per_rf, c='#81c784', s=80) + plt.xlabel("Max Tree Depth in RF") + plt.ylabel("Number of Rules Extracted") + plt.title("Tree Depth vs. Number of Rules Extracted") + plt.grid(True) + plt.savefig("output/tree_depth_vs_num_rules.png", bbox_inches="tight") + plt.show() + print("Random Seed Check After Rule Extract: "+ str(random.random())) + + # STEP 5: Deduplicate rules (based on rule's condition and action) + print("Deduplicating rules...") + #rule_tuples = [tuple((tuple(r[0]), tuple(r[1]), r[2])) for r in all_rules] + #unique_rules_tuples = list(set(rule_tuples)) + #unique_rules = [[list(r[0]), list(r[1]), r[2]] for r in unique_rules_tuples] + + # 1. Convert to tuples so they are hashable for the set + rule_tuples = [tuple((tuple(r[0]), tuple(r[1]), r[2])) for r in all_rules] + + # 2. Use set to get unique items, but IMMEDIATELY sort the resulting list + # Sorting ensures that the order is identical across every run + unique_rules_tuples = sorted(list(set(rule_tuples))) + + # 3. Convert back to the original list-of-lists format + unique_rules = [[list(r[0]), list(r[1]), r[2]] for r in unique_rules_tuples] + + if verbose: + print("\nSummary: Extracted {} branch-rules from all trees.".format(len(all_rules))) + print("After deduplication, {} unique rules remain.".format(len(unique_rules))) + + print("Random Seed Check After Deduplication: "+ str(random.random())) + # STEP 5: Convert rules to HEROS format, check for redundancy, and add to population + print("\nConverting extracted rules to HEROS format and checking for redundancy...") + + # -------------------------------------------------------------------------------------------------------- + def convert_path_to_minmax(condition_indexes, condition_values, onehot_mapping, quant_feat_mapping): + """Convert a list of (direction, threshold) for each feature into HEROS format. + Handles both quantitative features (min/max ranges) and categorical features (equality checks). + Maps one-hot encoded features back to original categorical features.""" + minmax_dict = {} # For quantitative features: {orig_feat_idx: [min, max]} + categorical_dict = {} # For categorical features: {orig_feat_idx: set of values} + + for idx, (direction, threshold) in zip(condition_indexes, condition_values): + # Check if this is a one-hot encoded feature + if idx in onehot_mapping: + # This is a one-hot encoded categorical feature + orig_feat_idx, cat_value = onehot_mapping[idx] + + # For one-hot encoding: features are binary (0 or 1) - Threshold is typically 0.5 + # If direction is 'gt' and threshold <= 0.5, it means the one-hot feature is 1 (category IS present) + # If direction is 'leq' and threshold < 0.5, it means the one-hot feature is 0 (category NOT present) + if direction == 'gt' and threshold <= 0.5: + # This branch means the one-hot feature is 1, so the category IS present + if orig_feat_idx not in categorical_dict: + categorical_dict[orig_feat_idx] = set() + categorical_dict[orig_feat_idx].add(cat_value) + # If direction is 'leq' and threshold < 0.5, the category is NOT present (we ignore it) + # Note: We only add categories that are explicitly present (value = 1) + else: + # This is a quantitative feature + # Map encoded index back to original index + if quant_feat_mapping and idx in quant_feat_mapping: + orig_idx = quant_feat_mapping[idx] + else: + # No one-hot encoding was done, so index is already original + orig_idx = idx + + if orig_idx not in minmax_dict: + minmax_dict[orig_idx] = [float('-inf'), float('inf')] + if direction == 'leq': + minmax_dict[orig_idx][1] = min(minmax_dict[orig_idx][1], threshold) + elif direction == 'gt': + minmax_dict[orig_idx][0] = max(minmax_dict[orig_idx][0], np.nextafter(threshold, threshold+1)) + + # Build final condition lists + clean_indexes = [] + clean_values = [] + + # Add quantitative features + for idx in sorted(minmax_dict.keys()): + min_val, max_val = minmax_dict[idx] + if min_val <= max_val: + clean_indexes.append(idx) + clean_values.append([min_val, max_val]) + + # Add categorical features - we need to check if all one-hot conditions for a feature point to the same value + for orig_feat_idx in sorted(categorical_dict.keys()): + cat_values = categorical_dict[orig_feat_idx] + # If only one value is in the set, that's the categorical condition + if len(cat_values) == 1: + clean_indexes.append(orig_feat_idx) + clean_values.append(list(cat_values)[0]) # Single categorical value, not a range + # If multiple values, we might need to handle this differently - For now, we'll take the first one (though this might not be correct) + elif len(cat_values) > 1: + # Multiple categories for same feature - this shouldn't happen in a valid tree path - But if it does, we'll use the first one + clean_indexes.append(orig_feat_idx) + clean_values.append(list(cat_values)[0]) + return clean_indexes, clean_values + # -------------------------------------------------------------------------------------------------------- + + for rule_data in unique_rules: + raw_condition_indexes, raw_condition_values, action = rule_data + condition_indexes, condition_values = convert_path_to_minmax(raw_condition_indexes, raw_condition_values, onehot_mapping, quant_feat_mapping) + if len(condition_indexes) == 0: + continue + + # Create a new RULE object + rule_obj = RULE(heros) + #rule_obj.condition_indexes = list(condition_indexes) + rule_obj.condition_indexes = [x.item() if hasattr(x, 'item') else x for x in condition_indexes] + #print(type(rule_obj.condition_indexes[0])) + #rule_obj.condition_values = list(condition_values) + rule_obj.condition_values = [x.item() if hasattr(x, 'item') else x for x in condition_values] #CHECK THIS STILL WORKS FOR Quantitative features + #print(type(rule_obj.condition_values[0])) + rule_obj.action = None + rule_obj.numerosity = 1 + rule_obj.birth_iteration = 0 + try: #FUTURE EXPANSION TO QUANTITATIVE OUTCOMES NEEDED + if hasattr(rule_obj, 'complete_rule_evaluation_class'): #Evaluates rules and assignes best outcome. + front_updated = rule_obj.complete_rule_evaluation_class(heros, random, None) + else: + continue + if not hasattr(rule_obj, 'match_cover') or rule_obj.match_cover == 0: + continue + except Exception as e: + print(f"An unexpected error occurred: {e}") + print(f"Type of unexpected exception: {type(e)}") + continue + if heros.fitness_function == 'pareto': #Needs expansion for non-pareto option + rule_obj.update_rule_fitness(heros) + identical_rule = self.search_pop_for_identical_rule(rule_obj) + if identical_rule is not None: + identical_rule.update_numerosity(1) + self.micro_pop_count += 1 + else: + rule_obj.assign_ID(self.ID_counter) + self.pop_set.append(rule_obj) + self.ID_counter += 1 + self.micro_pop_count += 1 + + #Global Fitness update + if heros.fitness_function == 'pareto': #Needs expansion for non-pareto option + self.global_fitness_update(heros) + print("Random Seed Check After Convert to HEROS rules: "+ str(random.random())) + + def print_rule_conversion_summary(pop_set, micro_pop_count): + print("\nSummary: Converted rules to HEROS format and added to population.") + print(f"Total Population Numerosity: {micro_pop_count}") + print(f"Unique HEROS Rules: {len(pop_set)}") + + print_rule_conversion_summary(self.pop_set, self.micro_pop_count) + + self.order_all_rule_conditions() #New potential random seed reproducibitliy fix + + """ + if verbose: + + + # STEP 8: Visualize the first decision tree in the random forest + print("\nVisualizing the first decision tree in the random forest...") + try: + estimator = self.rf_model.estimators_[0] + plt.figure(figsize=(20, 10)) + sktree.plot_tree( + estimator, + feature_names=list(X.columns) if hasattr(X, 'columns') else None, + class_names=[str(c) for c in np.unique(y)], + filled=True, rounded=True + ) + plt.title("First Decision Tree in Random Forest") + plt.savefig("output/decision_tree_visualization_matplotlib.png", bbox_inches="tight") + plt.show() + print("Decision tree visualization saved as 'decision_tree_visualization_matplotlib.png'") + except Exception as e: + print(f"Could not visualize decision tree: {e}") + + def print_tree_visualization_summary(): + print("\nSummary: Plotted and saved the first decision tree from the random forest.") + print_tree_visualization_summary() + + # STEP 9: Visualize a single branch and its conversion to a HEROS rule + print("\nVisualizing a single branch and its corresponding rule...") + try: + branch = None + for rf in rf_models: + if len(rf.estimators_) > 0: + tree = rf.estimators_[0].tree_ + branch_paths_local = [] + recurse_tree(tree, 0, [], [], branch_paths_local) + if branch_paths_local: + branch = branch_paths_local[0] + break + if branch is not None: + cond_indexes, cond_values, action, path = branch + print("Example branch path:") + for step in path: + feat_idx, threshold, direction = step + feat_name = X.columns[feat_idx] if hasattr(X, 'columns') else f"f{feat_idx}" + print(f" If {feat_name} {'<=' if direction == 'leq' else '>'} {threshold:.4f}") + print(f" --> Predict class: {action}") + heros_indexes, heros_values = convert_path_to_minmax(cond_indexes, cond_values) + print("Converted to HEROS rule format:") + for idx, (minv, maxv) in zip(heros_indexes, heros_values): + feat_name = X.columns[idx] if hasattr(X, 'columns') else f"f{idx}" + print(f" {feat_name}: [{minv:.4f}, {maxv:.4f}]") + print(f" Action: {action}") + # Visualize the branch as a path in the tree + print("Visualizing the branch as a path in the tree...") + try: + estimator = self.rf_model.estimators_[0] + plt.figure(figsize=(20, 10)) + sktree.plot_tree( + estimator, + feature_names=list(X.columns) if hasattr(X, 'columns') else None, + class_names=[str(c) for c in np.unique(y)], + filled=True, rounded=True, + impurity=False, + proportion=False, + precision=2 + ) + # Highlight the branch path (not trivial in matplotlib, so just print info) + plt.title("First Decision Tree with Example Branch (see printed path)") + plt.savefig("output/decision_tree_with_branch.png", bbox_inches="tight") + plt.show() + print("Decision tree with branch visualization saved as 'decision_tree_with_branch.png'") + except Exception as e: + print(f"Could not visualize branch in tree: {e}") + else: + print("No branch found for visualization.") + except Exception as e: + print(f"Could not visualize branch-to-rule conversion: {e}") + + def print_branch_visualization_summary(): + print("\nSummary: Printed a single branch from a tree and its conversion to a HEROS rule.") + print_branch_visualization_summary() + """ + + + + def export_rule_population(self,rsl='Unspecified'): """ Prepares and exports a dataframe capturing the rule population.""" pop_list = [] column_names = ['ID', @@ -569,7 +1010,7 @@ def export_rule_population(self): 'Prediction', 'Outcome Range Probability', 'Birth Iteration', - 'Specified Count', + 'Specified Count (RSL='+str(rsl)+')', 'Average Match Set Size', 'Deletion Probabiilty'] for rule in self.pop_set: @@ -767,4 +1208,87 @@ def plot_rule_pop_network(self, feature_names, weighting='useful_accuracy', disp if save: plt.savefig(output_path+'/rule_pop_network.png', bbox_inches="tight") if show: - plt.show() \ No newline at end of file + plt.show() + + """def decode_rule_binary(self, binary_str, num_features): + + Decodes a binary encoded rule string (compact version with only 2-bit int values, no float ranges). + + Returns: + [ + condition_indexes: list[int], + condition_values: list[int], + action: int, + instance_outcome_count: dict[int, int] + ] + + instance_outcome_count = self.explored_rules[binary_str] + ptr = 0 + + # --- Step 1: Decode bitmask (num_features bits) --- + bitmask_str = binary_str[ptr:ptr + num_features] + condition_indexes = [i for i, b in enumerate(bitmask_str) if b == '1'] + ptr += num_features + + # --- Step 2: Decode type indicators (num_features bits) --- + type_indicators = binary_str[ptr:ptr + num_features] + ptr += num_features + + # --- Step 3: Decode all condition values (2 bits each) --- + condition_values = [] + for i in range(num_features): + val_binary = binary_str[ptr:ptr + 2] + val = int(val_binary, 2) + ptr += 2 + condition_values.append(val) + + # Filter only used condition values (based on bitmask) + used_condition_values = [condition_values[i] for i in condition_indexes] + + # --- Step 4: Decode action (2 bits) --- + action_binary = binary_str[ptr:ptr + 2] + action = int(action_binary, 2) + ptr += 2 + + return [condition_indexes, used_condition_values, action, instance_outcome_count]""" + + def decode_rule_binary(self, binary_str, num_features): + """" + Decodes a binary encoded rule string (without outcome count). + Returns: + [ + condition_indexes: list[int], + condition_values: list[int or tuple(float, float)], + action: int + ] + """ + instance_outcome_count = self.explored_rules[binary_str] + ptr = 0 # bit pointer + # --- Step 1: Decode bitmask --- + bitmask_str = binary_str[ptr:ptr + num_features] + condition_indexes = [i for i, b in enumerate(bitmask_str) if b == '1'] + ptr += num_features + # --- Step 2: Decode type indicators --- + type_indicators = binary_str[ptr:ptr + len(condition_indexes)] + ptr += len(condition_indexes) + # --- Step 3: Decode condition values --- + condition_values = [] + for indicator in type_indicators: + if indicator == '0': + val_binary = binary_str[ptr:ptr + 32] + condition_values.append(int(val_binary, 2)) + ptr += 32 + elif indicator == '1': + min_binary = binary_str[ptr:ptr + 32] + max_binary = binary_str[ptr + 32:ptr + 64] + min_val = struct.unpack('>f', int(min_binary, 2).to_bytes(4, 'big'))[0] + max_val = struct.unpack('>f', int(max_binary, 2).to_bytes(4, 'big'))[0] + condition_values.append((min_val, max_val)) + ptr += 64 + #else: + #raise ValueError(f”Invalid type indicator: {indicator}“) + # --- Step 4: Decode action --- + action_binary = binary_str[ptr:ptr + 32] + action = int(action_binary, 2) + ptr += 32 + return [condition_indexes, condition_values, action, instance_outcome_count] \ No newline at end of file diff --git a/src/skheros/methods/rule_tracking.py b/src/skheros/methods/rule_tracking.py index 2a0e451..d663f02 100644 --- a/src/skheros/methods/rule_tracking.py +++ b/src/skheros/methods/rule_tracking.py @@ -25,6 +25,7 @@ def __init__(self, heros): pass self.tracking_list = [] self.tracking_entry = [] + self.alternations = [] def update_prediction_list(self,outcome_prediction,outcome_truth,heros): @@ -82,7 +83,8 @@ def print_tracking_entry(self): """ Prints the tracking information for the current training iteration. """ self.tracking_entry = [round(num,3) for num in self.tracking_entry] report_df = pd.DataFrame([self.tracking_entry], columns=self.tracking_header,index=None) - print(report_df) + print(report_df.to_string(index=False)) + #print(report_df) def plot_rule_tracking(self,show=True, save=False, output_path=None): @@ -97,6 +99,22 @@ def plot_rule_tracking(self,show=True, save=False, output_path=None): ax2.plot(tracking_df['Iteration'], tracking_df['Unique Rule Count'], label="Unique Rule Count", color='red') ax2.set_ylabel('Macro Population Size (Unique Rule Count)', color='r') ax2.tick_params(axis='y', labelcolor='r') + + y_min, y_max = ax1.get_ylim() + label_y = y_max - 0.02 * (y_max - y_min) + + for x in self.alternations: + ax1.axvline(x=x, color='green', linestyle=':', linewidth=1) + ax1.text( + x + 0.5, + label_y, + f"alt {self.alternations.index(x)}", + rotation=0, + va='top', + ha='right', + fontsize=8, + color='green' + ) if save: plt.savefig(output_path+'/rule_tracking_line_graph.png', bbox_inches="tight") if show: diff --git a/tests/test_heros.py b/tests/test_heros.py index 715a08b..0418def 100644 --- a/tests/test_heros.py +++ b/tests/test_heros.py @@ -99,7 +99,7 @@ def test_mixed_feature_types(): print(ek) heros = HEROS(outcome_type='class',iterations=20000,pop_size=500,cross_prob=0.8,mut_prob=0.04,nu=1,beta=0.2,theta_sel=0.5, fitness_function='pareto',subsumption='both',rsl=0,feat_track=None, model_iterations=40, - model_pop_size=100,model_pop_init='target_acc',new_gen=1.0,merge_prob=0.1,rule_pop_init=None,compaction='sub', + model_pop_size=100,model_pop_init='target_acc',new_gen=1.0,merge_prob=0.1,rule_pop_init="dt",compaction='sub', track_performance=1000,model_tracking=True,stored_rule_iterations=None,stored_model_iterations=None,random_state=42,verbose=True) heros = heros.fit(X, y, None, cat_feat_indexes=cat_feat_indexes, ek=ek) #Select best model from the front