SDoE: implementing input type dependent ordering capability (#1194)

* implementing difficulty column and ordering depending on input difficulty.

* remove order.py

* add test for order_blocks function

* add difficulty to config files so tests pass

* save one final design

* fix test_order

* Format files with Black

---------

Co-authored-by: Ludovico Bianchi <lbianchi@lbl.gov>

Author: sotorrio1

foqus_lib/framework/sdoe/order.py

@@ -24,6 +24,7 @@
 from dask.distributed import get_client
 import numpy as np
 import pandas as pd
+from python_tsp.exact import solve_tsp_dynamic_programming
 
 from foqus_lib.framework.uq.Common import Common
 from foqus_lib.framework.uq.ResponseSurfaces import ResponseSurfaces
@@ -71,6 +72,10 @@ def run(config_file: str, nd: int, test: bool = False) -> Tuple[Dict, Dict, floa
     min_vals = [float(s) for s in config["INPUT"]["min_vals"].split(",")]
 
     types = [s.strip() for s in config["INPUT"]["types"].split(",")]
+    difficulty = [s.strip() for s in config["INPUT"]["difficulty"].split(",")]
+    type_idx = types.index("Index")
+    diff_no_idx = difficulty.copy()
+    del diff_no_idx[type_idx]
     # 'Input' columns
     idx = [x for x, t in zip(include, types) if t == "Input"]
     # 'Index' column (should only be one)
@@ -202,6 +207,10 @@ def run(config_file: str, nd: int, test: bool = False) -> Tuple[Dict, Dict, floa
                 "dmat": os.path.join(outdir, "nusf_dmat_{}.npy".format(suffix)),
             }
             save(fnames[mwr], results[mwr], elapsed_time)
+            if all(x == "Hard" for x in diff_no_idx):
+                rank(fnames[mwr])
+            elif any(x == "Hard" for x in diff_no_idx):
+                order_blocks(fnames[mwr], difficulty)
 
     if sf_method == "usf":
         suffix = "d{}_n{}_{}".format(nd, nr, "+".join(include))
@@ -210,6 +219,10 @@ def run(config_file: str, nd: int, test: bool = False) -> Tuple[Dict, Dict, floa
             "dmat": os.path.join(outdir, "usf_dmat_{}.npy".format(suffix)),
         }
         save(fnames, results, elapsed_time)
+        if all(x == "Hard" for x in diff_no_idx):
+            rank(fnames)
+        elif any(x == "Hard" for x in diff_no_idx):
+            order_blocks(fnames, difficulty)
 
     if sf_method == "irsf":
         fnames = {}
@@ -230,6 +243,47 @@ def run(config_file: str, nd: int, test: bool = False) -> Tuple[Dict, Dict, floa
     return fnames, results, elapsed_time
 
 
+def rank(fnames):
+    """return fnames ranked"""
+    dist_mat = np.load(fnames["dmat"])
+
+    permutation, _distance = solve_tsp_dynamic_programming(dist_mat)
+
+    # retrieve ranked list
+    cand = load(fnames["cand"])
+    ranked_cand = cand.loc[permutation]
+
+    # save the output
+    fname_ranked = fnames["cand"]
+
+    write(fname_ranked, ranked_cand)
+
+    return fname_ranked
+
+
+def order_blocks(fnames, difficulty):
+    # load candidate set
+    cand = load(fnames["cand"])
+    cols = list(cand.columns)
+
+    diff_arr = np.array(difficulty)
+    diff_idx_arr = np.where(diff_arr == "Hard")[0]
+    diff_idx = list(diff_idx_arr)
+
+    col_order = []
+    for i in diff_idx:
+        col_order.append(cols[i])
+
+    sorted_cand = cand.sort_values(col_order)
+
+    # save the output
+    fname_blocks = fnames["cand"]
+
+    write(fname_blocks, sorted_cand)
+
+    return fname_blocks
+
+
 def dataImputation(fname: str, y: int, rsMethodName: str, eval_fname: str) -> str:
     """
     args: fname, y, rsMethodName, eval_fname

foqus_lib/framework/sdoe/sdoe.py

@@ -10,6 +10,7 @@ min_vals = 0.0,0.0,0.0,0.0
 max_vals = 440.0,1.0,1.0,1.0
 include = __id,V1,V2,Y
 types = Index,Input,Input,Response
+difficulty = Easy,Easy,Easy,Easy
 
 [SF]
 sf_method = irsf

foqus_lib/framework/sdoe/test/config_irsf.ini

@@ -10,6 +10,7 @@ min_vals = 0.0,3004.0,1000.0,0.12,0.1,4.33
 max_vals = 372.0,11675.0,2750.0,0.18,0.3,9.3
 include = __id,L,G,w,lldg,CI Width Prior
 types = Index,Input,Input,Input,Input,Weight
+difficulty = Easy,Easy,Easy,Easy,Easy,Easy
 
 [WEIGHT]
 weight_mode = by_user

foqus_lib/framework/sdoe/test/config_nusf.ini

@@ -11,6 +11,7 @@ min_vals = 0.0,0.12,1000.0,0.1,3020.0
 max_vals = 241.0,0.18,2700.0,0.3,11392.0
 include = __id,w,G,lldg,L
 types = Index,Input,Input,Input,Input
+difficulty = Easy,Easy,Easy,Easy,Easy
 
 [SF]
 sf_method = usf

foqus_lib/framework/sdoe/test/config_usf.ini

@@ -24,18 +24,11 @@
 import numpy as np
 import pandas as pd
 
-from foqus_lib.framework.sdoe import df_utils, order
-
-
-def test_mat2tuples():
-    """Test mat2tuples"""
-    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    lte = order.mat2tuples(arr)
-    assert lte == [(1, 0, 4), (2, 0, 7), (2, 1, 8)]
+from foqus_lib.framework.sdoe import df_utils, sdoe
 
 
 def test_rank():
-    """Call to order.rank() using hard-coded data written to temp files"""
+    """Call to sdoe.rank() using hard-coded data written to temp files"""
 
     # candidate dataframe to write to cand file
     cand_df = pd.DataFrame(
@@ -137,11 +130,11 @@ def test_rank():
     dmat_fn = pl.Path(sys.path[0], "tmp_dmat.npy")
     np.save(dmat_fn, dmat)
 
-    # file name dict to be passed to order.rank()
+    # file name dict to be passed to sdoe.rank()
     fnames = {"cand": str(cand_fn), "dmat": str(dmat_fn)}
 
     # Make the actual call
-    fname_ranked = order.rank(fnames)
+    fname_ranked = sdoe.rank(fnames)
 
     # Ranked results as a dataframe
     ret_ranked_df = df_utils.load(fname_ranked)
@@ -161,6 +154,50 @@ def test_rank():
     # Clean up tmp files
     cand_fn.unlink()
     dmat_fn.unlink()
-    pl.Path(fname_ranked).unlink()
+
+    assert test_results
+
+
+def test_order_blocks():
+    """Call to sdoe.order_blocks() using hard-coded data written to temp files"""
+
+    # candidate dataframe to write to cand file
+    cand_df = pd.DataFrame(
+        {
+            "w": [0.15, 0.15, 0.15, 0.175, 0.175, 0.15, 0.15, 0.15],
+            "G": [2700, 2500, 2000, 2500, 2500, 1500, 1500, 2000],
+            "lldg": [0.15, 0.15, 0.25, 0.25, 0.3, 0.15, 0.15, 0.3],
+            "L": [10039, 9060, 7519, 7358, 6185, 3100, 3454, 8529],
+        }
+    )
+    cand_fn = pl.Path(sys.path[0], "tmp_cand.csv")
+    df_utils.write(cand_fn, cand_df)
+
+    # file name dict to be passed to sdoe.order_blocks()
+    fnames = {"cand": str(cand_fn)}
+
+    # difficulty list
+    difficulty = ["Hard", "Hard", "Easy", "Easy"]
+
+    # Make the actual call
+    fname_blocks = sdoe.order_blocks(fnames, difficulty)
+
+    # Ranked results as a dataframe
+    ret_blocks_df = df_utils.load(fname_blocks)
+
+    # Expected ranked results as dataframe
+    blocks_df = pd.DataFrame(
+        {
+            "w": [0.15, 0.15, 0.15, 0.15, 0.15, 0.15, 0.175, 0.175],
+            "G": [1500, 1500, 2000, 2000, 2500, 2700, 2500, 2500],
+            "lldg": [0.15, 0.15, 0.25, 0.3, 0.15, 0.15, 0.25, 0.3],
+            "L": [3100, 3454, 7519, 8529, 9060, 10039, 7358, 6185],
+        }
+    )
+
+    test_results = ret_blocks_df.equals(blocks_df)
+
+    # Clean up tmp files
+    cand_fn.unlink()
 
     assert test_results