remove some bike_bench code

bike_bench_internal/benchmark_models/results/models/CTGAN.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1cbceb9dfe3ffc3be54c4a19a90412905753834a7e1f58637d1be7e906305975
-size 4287183
+oid sha256:493ee9d845adc3fb6ed9d26eadfda1b87e45bbf1f591050d4c389af1d45e37e9
+size 4081377

bike_bench_internal/benchmark_models/results/models/TVAE.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9bdf3070e85d642be9f23f2a562215169821535f033cf72b94e9e4b2c5d188f4
-size 2339380
+oid sha256:1e7ff6161cc5f0bf1c86acee3ca056e4067b3d734c2d67b1541ac128a08f7777
+size 2284778

bike_bench_internal/src/bikebench.egg-info/SOURCES.txt

@@ -7,108 +7,34 @@ src/bikebench.egg-info/PKG-INFO
 src/bikebench.egg-info/SOURCES.txt
 src/bikebench.egg-info/dependency_links.txt
 src/bikebench.egg-info/top_level.txt
-src/bikebench/benchmark_models/__init__.py
-src/bikebench/benchmark_models/benchmarking_utils.py
-src/bikebench/benchmark_models/generative_modeling_utils.py
-src/bikebench/benchmark_models/libmoon/__init__.py
-src/bikebench/benchmark_models/libmoon/example.py
-src/bikebench/benchmark_models/libmoon/problem/__init__.py
-src/bikebench/benchmark_models/libmoon/problem/mop.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/__init__.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/fair_classify.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/mnist.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/objectives.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/loaders/__init__.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/loaders/adult_loader.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/loaders/compas_loader.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/loaders/credit_loader.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/loaders/multimnist_loader.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/model/__init__.py
-src/bikebench/benchmark_models/libmoon/problem/mtl/model/simple.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/__init__.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/dtlz.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/maf.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/re.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/re_original.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/vlmop.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/wfg.py
-src/bikebench/benchmark_models/libmoon/problem/synthetic/zdt.py
-src/bikebench/benchmark_models/libmoon/solver/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/base_solver.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/core_solver.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/epo_solver.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/functions_evaluation.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/functions_hv_grad_3d.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/functions_hv_python3.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/gradhv.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/mgda_core.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/mgda_solver.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/min_norm_solvers_numpy.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/moosvgd.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/pmgda.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/pmtl.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/run/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/run/run_grad.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/utils/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/gradient/utils/util.py
-src/bikebench/benchmark_models/libmoon/solver/mobo/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/mobo/dirhvego.py
-src/bikebench/benchmark_models/libmoon/solver/mobo/mobod.py
-src/bikebench/benchmark_models/libmoon/solver/mobo/utils/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/mobo/utils/termination.py
-src/bikebench/benchmark_models/libmoon/solver/moea/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/moea/moead.py
-src/bikebench/benchmark_models/libmoon/solver/moea/moead_pfl.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/decomposition.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/genetic_operator.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/population.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/termination.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/utils_ea.py
-src/bikebench/benchmark_models/libmoon/solver/moea/utils/weight_vector.py
-src/bikebench/benchmark_models/libmoon/solver/pfl/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/pfl/run.py
-src/bikebench/benchmark_models/libmoon/solver/pfl/model/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/pfl/model/simple.py
-src/bikebench/benchmark_models/libmoon/solver/psl/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/psl/run_mtl_condition.py
-src/bikebench/benchmark_models/libmoon/solver/psl/run_mtl_psl.py
-src/bikebench/benchmark_models/libmoon/solver/psl/run_simple_psl.py
-src/bikebench/benchmark_models/libmoon/solver/psl/util.py
-src/bikebench/benchmark_models/libmoon/solver/psl/model/__init__.py
-src/bikebench/benchmark_models/libmoon/solver/psl/model/mtl.py
-src/bikebench/benchmark_models/libmoon/solver/psl/model/simple.py
-src/bikebench/benchmark_models/libmoon/util_global/__init__.py
-src/bikebench/benchmark_models/libmoon/util_global/constant.py
-src/bikebench/benchmark_models/libmoon/util_global/scalarization.py
-src/bikebench/benchmark_models/libmoon/util_global/weight_factor/__init__.py
-src/bikebench/benchmark_models/libmoon/util_global/weight_factor/das_dennis.py
-src/bikebench/benchmark_models/libmoon/util_global/weight_factor/funs.py
-src/bikebench/benchmark_models/libmoon/visulization/__init__.py
-src/bikebench/benchmark_models/libmoon/visulization/util.py
-src/bikebench/benchmark_models/libmoon/visulization/view_res.py
+src/bikebench/benchmarking/__init__ .py
+src/bikebench/benchmarking/benchmarker.py
+src/bikebench/benchmarking/benchmarking_utils.py
+src/bikebench/benchmarking/score_report.py
+src/bikebench/benchmarking/scoring.py
 src/bikebench/conditioning/__init__.py
 src/bikebench/conditioning/conditioning.py
 src/bikebench/data_loading/__init__.py
 src/bikebench/data_loading/data_loading.py
 src/bikebench/data_loading/dataverse_utils.py
+src/bikebench/data_loading/execute_upload_missing.py
 src/bikebench/design_evaluation/__init__.py
 src/bikebench/design_evaluation/design_evaluation.py
-src/bikebench/design_evaluation/score_report.py
-src/bikebench/design_evaluation/scoring.py
 src/bikebench/embedding/__init__.py
 src/bikebench/embedding/clip_embedding_calculator.py
 src/bikebench/embedding/dataset_rendering_tools.py
 src/bikebench/embedding/embedding_predictor.py
-src/bikebench/embedding/execute_emb.py
 src/bikebench/ergonomics/__init__.py
 src/bikebench/ergonomics/joint_angles.py
 src/bikebench/prediction/__init__.py
 src/bikebench/prediction/aero_predictor.py
-src/bikebench/prediction/clip_predictor.py
+src/bikebench/prediction/aesthetics_predictor.py
 src/bikebench/prediction/evaluators.py
+src/bikebench/prediction/model_definitions.py
 src/bikebench/prediction/prediction_utils.py
+src/bikebench/prediction/structural_predictor.py
+src/bikebench/prediction/usability_predictor.py
+src/bikebench/prediction/validity_predictor.py
 src/bikebench/rendering/BikeCAD_server_client.py
 src/bikebench/rendering/BikeCAD_server_manager.py
 src/bikebench/rendering/__init__.py

bike_bench_internal/src/bikebench.egg-info/top_level.txt

@@ -1,2 +1,3 @@
 bikebench
+biked_commons
 resources

bike_bench_internal/src/bikebench/benchmarking/benchmarking_utils.py

@@ -8,10 +8,23 @@ from bikebench.conditioning import conditioning
 from tqdm import trange, tqdm
 from bikebench.transformation import ordered_columns
 
-def get_test_conditions():
-    rider_conditions = conditioning.sample_riders(100, split="test")
-    use_case_conditions = conditioning.sample_use_case(100, split="test")
-    image_embeddings = conditioning.sample_embedding(100, split="test")
+def get_train_conditions(n, randomize=True, device="cpu", mode = "embedding"):
+    rider_conditions = conditioning.sample_riders(n, split="train", randomize=randomize, device=device)
+    use_case_conditions = conditioning.sample_use_case(n, split="train", randomize=randomize, device=device)
+
+    if mode == "text":
+        texts = conditioning.sample_text(n, split="train", randomize=randomize)
+        conditions = {"Rider": rider_conditions, "Use Case": use_case_conditions, "Text": texts}
+        return conditions
+    elif mode == "embedding":
+        image_embeddings = conditioning.sample_embedding(n, split="train", randomize=randomize, device=device)
+        conditions = {"Rider": rider_conditions, "Use Case": use_case_conditions, "Embedding": image_embeddings}
+        return conditions
+
+def get_test_conditions(device="cpu"):
+    rider_conditions = conditioning.sample_riders(100, split="test", device=device)
+    use_case_conditions = conditioning.sample_use_case(100, split="test", device=device)
+    image_embeddings = conditioning.sample_embedding(100, split="test", device=device)
 
     rider_conditions_repeated = rider_conditions.repeat_interleave(100, dim=0)
     use_case_conditions_repeated = use_case_conditions.repeat_interleave(100, dim=0)
@@ -21,27 +34,37 @@ def get_test_conditions():
 
     return conditions
 
-def get_single_test_condition(idx=0, device="cpu"):
-    rider_condition = conditioning.sample_riders(100, split="test")
-    use_case_condition = conditioning.sample_use_case(100, split="test")
-    image_embedding = conditioning.sample_embedding(100, split="test")
-
+def get_single_test_condition(idx=0, device="cpu", mode = "embedding"):
+    rider_condition = conditioning.sample_riders(100, split="test", device=device)
+    use_case_condition = conditioning.sample_use_case(100, split="test", device=device)
     rider_condition = rider_condition[idx].to(device)
     use_case_condition = use_case_condition[idx].to(device)
-    image_embedding = image_embedding[idx].to(device)
+    if mode == "text":
+        text = conditioning.sample_text(100, split="test")
+        text = text[idx]
+        condition = {"Rider": rider_condition, "Use Case": use_case_condition, "Text": text}
+        return condition
+
+    elif mode == "embedding":
+        image_embedding = conditioning.sample_embedding(100, split="test", device=device)
+
 
-    condition = {"Rider": rider_condition, "Use Case": use_case_condition, "Embedding": image_embedding}
-    return condition
+        image_embedding = image_embedding[idx].to(device)
+
+        condition = {"Rider": rider_condition, "Use Case": use_case_condition, "Embedding": image_embedding}
+        return condition
+    else:
+        raise ValueError("mode must be 'text' or 'embedding'")
 
-def evaluate(result_tens, device, evaluate_as_aggregate = False):
+def evaluate_designs(result_tens, evaluate_as_aggregate = False):
     data_columns = ordered_columns.bike_bench_columns
-    evaluations = get_standard_evaluations(device)
-    evaluator, requirement_names, requirement_types = construct_tensor_evaluator(evaluations, data_columns, device=device)
+    evaluations = get_standard_evaluations("cpu")
+    evaluator, requirement_names, is_objective, is_conditional = construct_tensor_evaluator(evaluations, data_columns, device="cpu")
 
     if evaluate_as_aggregate:
-        condition = get_test_conditions()
-        main_scorer = construct_scorer(MainScores, evaluations, data_columns, device)
-        detailed_scorer = construct_scorer(DetailedScores, evaluations, data_columns, device)
+        condition = get_test_conditions("cpu")
+        main_scorer = construct_scorer(MainScores, evaluations, data_columns, "cpu")
+        detailed_scorer = construct_scorer(DetailedScores, evaluations, data_columns, "cpu")
 
         main_scores = main_scorer(result_tens, condition)
         detailed_scores = detailed_scorer(result_tens, condition)
@@ -50,16 +73,17 @@ def evaluate(result_tens, device, evaluate_as_aggregate = False):
         all_detailed_scores = []
         all_evaluation_scores = []
 
-        main_scorer = construct_scorer(MainScores, evaluations, data_columns, device)
-        detailed_scorer = construct_scorer(DetailedScores, evaluations, data_columns, device)
+        main_scorer = construct_scorer(MainScores, evaluations, data_columns, "cpu")
+        detailed_scorer = construct_scorer(DetailedScores, evaluations, data_columns, "cpu")
         for i in trange(100):
             result_slice = result_tens[i*100:(i+1)*100]
-            condition = get_single_test_condition(i, device)
+            condition = get_single_test_condition(i, "cpu")
 
+            result_slice = result_slice.detach().cpu()
             evaluation_scores = evaluator(result_slice, condition)
 
-            main_scores = main_scorer(result_slice.detach(), condition, preevaluated_scores = evaluation_scores) #main scores is a series
-            detailed_scores = detailed_scorer(result_slice.detach(), condition, preevaluated_scores = evaluation_scores) #detailed scores is a series
+            main_scores = main_scorer(result_slice, condition, preevaluated_scores = evaluation_scores) #main scores is a series
+            detailed_scores = detailed_scorer(result_slice, condition, preevaluated_scores = evaluation_scores) #detailed scores is a series
 
             all_main_scores.append(main_scores)
             all_detailed_scores.append(detailed_scores)
@@ -72,6 +96,12 @@ def evaluate(result_tens, device, evaluate_as_aggregate = False):
 
     return main_scores, detailed_scores, all_evaluation_scores
 
+
+        
+
+
+
+
 # def get_condition_by_idx(idx=0):
 #     rider_condition = conditioning.sample_riders(10, split="test")
 #     use_case_condition = conditioning.sample_use_case(10, split="test")

bike_bench_internal/src/bikebench/benchmarking/scoring.py

@@ -156,7 +156,7 @@ class AverageConstraintViolation(ScoringFunction):
         return self.names
 
     def evaluate(self, designs, objective_scores, constraint_scores, objective_names, constraint_names, obj_ref_point):
-        self.names = [f"Mean Violations ↓"] #counts average number of violated constraints per design
+        self.names = [f"Constraint Violation ↓"] #counts average number of violated constraints per design
         validity_boolean = constraint_scores > 0
         return np.mean(np.sum(validity_boolean, axis=1))
     
@@ -170,7 +170,7 @@ class AverageNovelty(ScoringFunction):
         self.reference_designs = self.scaler.transform(raw_ref)
 
     def return_names(self) -> List[str]:
-        return ["Mean Novelty ↑"]
+        return ["Novelty ↑"]
 
     def evaluate(self, designs, objective_scores, constraint_scores, objective_names, constraint_names, obj_ref_point):
         scaled_designs = self.scaler.transform(designs)
@@ -195,6 +195,8 @@ class DPPDiversity(ScoringFunction):
         return ["Diversity ↓ (DPP)"]
 
     def evaluate(self, designs, objective_scores, constraint_scores, objective_names, constraint_names, obj_ref_point):
+        #deduplicate designs
+        designs = np.unique(designs, axis=0)
 
         # Convert to numpy and scale like AverageNovelty
         X = np.asarray(designs, dtype=np.float64)
@@ -286,9 +288,9 @@ class MeanConstraintViolationMagnitude(ScoringFunction):
         return meanscores
 
 def construct_scorer(scoring_functions: List[ScoringFunction], evaluation_functions: List[EvaluationFunction], column_names: List[str], device: str = "cpu") -> callable:
-    evaluator, requirement_names, requirement_types = construct_tensor_evaluator(evaluation_functions, column_names, device=device)
+    evaluator, requirement_names, is_objective, is_conditional = construct_tensor_evaluator(evaluation_functions, column_names, device=device)
     requirement_names = np.array(requirement_names)
-    isobjective = torch.tensor(requirement_types) == 1
+    isobjective = torch.tensor(is_objective, dtype=bool)
     objective_names = requirement_names[isobjective]
     constraint_names = requirement_names[~isobjective]
 

bike_bench_internal/src/bikebench/conditioning/conditioning.py

@@ -79,41 +79,48 @@ def _get_embed_tensor(split: str, device: torch.device = None):
     cpu = _ensure_embed_cpu(split)
     return _to_device_cached(cpu, _DEVICE_CACHE["embed"][split], device)
 
+def get_indices(N, num_samples, randomize=False):
+    if randomize:
+        idx = torch.randint(0, N, (num_samples,))
+    else:
+        reps = num_samples // N + 1
+        idx = torch.arange(N).repeat(reps)[:num_samples]
+    return idx
+
 def sample_riders(num_samples: int, split="test",
                   randomize=False, device: torch.device = None):
+
+    if split=="test" and randomize:
+        print("Warning: Randomizing order of test data when benchmark expects fixed order!")
     data = _get_rider_tensor(split, device)
     N = data.size(0)
-    if randomize:
-        idx = torch.randint(0, N, (num_samples,), device=data.device)
-    else:
-        reps = num_samples // N + 1
-        idx = torch.arange(N, device=data.device).repeat(reps)[:num_samples]
+    idx = get_indices(N, num_samples, randomize)
+    idx.to(device)
     return data[idx]
 
-def sample_embedding(num_samples: int, split="test", device: torch.device = None):
+def sample_embedding(num_samples: int, split="test", randomize = False, device: torch.device = None):
+    #warn if split is test and randomize is true
+    if split=="test" and randomize:
+        print("Warning: Randomizing order of test data when benchmark expects fixed order!")
+
     data = _get_embed_tensor(split, device)
     N = data.size(0)
-    if split=="train":
-        idx = torch.randint(0, N, (num_samples,), device=data.device)
-    else:
-        reps = num_samples // N + 1
-        idx = torch.arange(N, device=data.device).repeat(reps)[:num_samples]
+    idx = get_indices(N, num_samples, randomize)
+    idx.to(device)
     return data[idx]
 
-def sample_use_case(num_samples: int, split=None, device: torch.device = None):
+def sample_use_case(num_samples: int, split=None, randomize = False, device: torch.device = None):
+    if split=="test" and randomize:
+        print("Warning: Randomizing order of test data when benchmark expects fixed order!")
     onehot = torch.eye(3, dtype=torch.float32)
-    if split=="train":
-        idx = torch.randint(0, 3, (num_samples,), device=onehot.device)
-    else:
-        reps = num_samples // 3 + 1
-        idx = torch.arange(3, device=onehot.device).repeat(reps)[:num_samples]
+    idx = get_indices(3, num_samples, randomize)
+    idx.to(device)
     return onehot[idx]
 
 def sample_text(num_samples, split="test", randomize=False):
     text_data = _ensure_text(split)
     if not text_data:
         return []
-    if randomize:
-        return np.random.choice(text_data, size=num_samples, replace=True).tolist()
-    reps = num_samples // len(text_data) + 1
-    return (text_data * reps)[:num_samples]
+    N = len(text_data)
+    idx = get_indices(N, num_samples, randomize)
+    return [text_data[i] for i in idx]

bike_bench_internal/src/bikebench/data_loading/data_loading.py

@@ -11,6 +11,7 @@ import requests
 from tqdm import tqdm
 
 from bikebench.resource_utils import datasets_path
+from bikebench.transformation.one_hot_encoding import ONE_HOT_ENCODED_BIKEBENCH_COLUMNS, BOOLEAN_COLUMNS
 
 # ------------------------------------------------------------------------------------
 # Config
@@ -238,11 +239,21 @@ def load_bike_bench_test(*, repair: bool = False, doi: str = DATAVERSE_DOI):
 
 def load_bike_bench_mixed_modality_train(*, repair: bool = False, doi: str = DATAVERSE_DOI):
     path = download_if_missing("Generative_Modeling_Datasets/bike_bench_mixed_modality.csv", repair=repair, doi=doi)
-    return pd.read_csv(path, index_col=0)
+    df =  pd.read_csv(path, index_col=0)
+    categorical_cols = ONE_HOT_ENCODED_BIKEBENCH_COLUMNS
+    boolean_cols = BOOLEAN_COLUMNS
+    continuous_cols = df.columns.difference(categorical_cols + boolean_cols).tolist()
+    df[continuous_cols] = df[continuous_cols].astype(np.float32)
+    return df
 
 def load_bike_bench_mixed_modality_test(*, repair: bool = False, doi: str = DATAVERSE_DOI):
     path = download_if_missing("Generative_Modeling_Datasets/bike_bench_mixed_modality_test.csv", repair=repair, doi=doi)
-    return pd.read_csv(path, index_col=0)
+    df = pd.read_csv(path, index_col=0)
+    categorical_cols = ONE_HOT_ENCODED_BIKEBENCH_COLUMNS
+    boolean_cols = BOOLEAN_COLUMNS
+    continuous_cols = df.columns.difference(categorical_cols + boolean_cols).tolist()
+    df[continuous_cols] = df[continuous_cols].astype(np.float32)
+    return df
 
 # ---- Original_BIKED_Data (numbered helpers) ----
 def _find_numbered_file(base_dir: Path, n: int, exts: set[str], paren_style: bool = False) -> str:

bike_bench_internal/src/bikebench/data_loading/dataverse_utils.py

@@ -151,10 +151,18 @@ def _upload_new(doi: str, path: Path, directory_label: str) -> int:
     r.raise_for_status()
     return r.json()["data"]["files"][0]["dataFile"]["id"]
 
-def _replace_file(file_id: int, path: Path) -> int:
+def _replace_file(file_id: int, path: Path, *, directory_label: Optional[str] = None, label: Optional[str] = None, force: bool = True, restrict: bool = False) -> int:
     url = f"{DV_API}/files/{file_id}/replace"
     mime = mimetypes.guess_type(str(path))[0] or "application/octet-stream"
-    data = {"jsonData": json.dumps({"forceReplace": True})}
+
+    meta = {"forceReplace": bool(force), "restrict": bool(restrict)}
+    if directory_label is not None:
+        meta["directoryLabel"] = directory_label  # <-- keep file in the same folder
+    if label is not None:
+        meta["label"] = label                      # optional; controls display name
+
+    data = {"jsonData": json.dumps(meta)}
+
     with path.open("rb") as fh:
         files = {"file": (path.name, fh, mime)}
         r = requests.post(url, data=data, files=files, headers=_headers(), timeout=600)
@@ -189,7 +197,11 @@ def upload_directory(
         if full_key in remote and replace_existing:
             fid = remote[full_key]["id"]
             print(f"REPLACE {full_key}  id={fid}")
-            _replace_file(fid, abs_path)
+            # compute the target folder and filename for metadata:
+            directory = str(PurePosixPath(full_key).parent)
+            directory = "" if directory == "." else directory
+            filename = PurePosixPath(full_key).name
+            _replace_file(fid, abs_path, directory_label=directory, label=filename)
         elif full_key in remote and not replace_existing:
             print(f"SKIP    {full_key} (exists; replace_existing=False)")
         else:

bike_bench_internal/src/bikebench/design_evaluation/design_evaluation.py

@@ -39,7 +39,11 @@ class EvaluationFunction(ABC):
         pass
 
     @abstractmethod # 1 = objective, 0 = constraint
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
+        pass
+
+    @abstractmethod
+    def is_conditional(self) -> List[str]:
         pass
 
     @abstractmethod
@@ -52,7 +56,7 @@ class AeroEvaluator(EvaluationFunction):
         super().__init__(device, dtype)
         state_path = models_and_scalers_path("aero_model_weights.pt")
         scaler_path = models_and_scalers_path("aero_scaler.pt")
-        state = torch.load(state_path, weights_only=True, map_location=torch.device(device))
+        state = torch.load(state_path, weights_only=True, map_location=device)
         self.model = get_aero_model(dropout_on=False).to(device)
         self.model.load_state_dict(state)
         self.preprocessor = Preprocessor(scaler_path=scaler_path, preprocess_fn=aero_predictor.calculate_features, device=device)
@@ -68,7 +72,10 @@ class AeroEvaluator(EvaluationFunction):
     def return_names(self) -> List[str]:
         return ['Drag Force (N)']
     
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
+        return [1]
+    
+    def is_conditional(self) -> List[str]:
         return [1]
 
     def evaluate(self, designs: torch.Tensor, conditioning: dict = {}) -> torch.Tensor:
@@ -92,7 +99,7 @@ class FrameValidityEvaluator(EvaluationFunction):
         super().__init__(device, dtype)
         state_path = models_and_scalers_path("validity_model_weights.pt")
         scaler_path = models_and_scalers_path("validity_scaler.pt")
-        state = torch.load(state_path, weights_only=True, map_location=torch.device(device))
+        state = torch.load(state_path, weights_only=True, map_location=device)
         self.model = get_validity_model(dropout_on=False).to(device)
         self.model.load_state_dict(state)
         self.preprocessor = Preprocessor(scaler_path=scaler_path, preprocess_fn=None, device=device)
@@ -105,7 +112,10 @@ class FrameValidityEvaluator(EvaluationFunction):
     def return_names(self) -> List[str]:
         return ['Predicted Frame Validity']
     
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
+        return [0]
+    
+    def is_conditional(self) -> List[str]:
         return [0]
 
     def evaluate(self, designs: torch.Tensor, conditioning: dict = {}) -> torch.Tensor:
@@ -122,7 +132,7 @@ class StructuralEvaluator(EvaluationFunction):
         super().__init__(device, dtype)
         state_path = models_and_scalers_path("structural_model_weights.pt")
         scaler_path = models_and_scalers_path("structural_scaler.pt")
-        state = torch.load(state_path, weights_only=True, map_location=torch.device(device))
+        state = torch.load(state_path, weights_only=True, map_location=device)
         self.model = get_structural_model(dropout_on = False).to(device)
         self.model.load_state_dict(state)
         self.preprocessor = Preprocessor(scaler_path=scaler_path, preprocess_fn=None, device=device)
@@ -134,8 +144,11 @@ class StructuralEvaluator(EvaluationFunction):
     def return_names(self) -> List[str]:
         return ['Mass (kg)', 'Planar Compliance Score', 'Transverse Compliance Score', 'Eccentric Compliance Score', 'Planar Safety Factor', 'Eccentric Safety Factor']
 
-    def return_types(self) -> List[str]:
-        return [1,1,1,1,0,0]
+    def is_objective(self) -> List[str]:
+        return [1, 1, 1, 1, 0, 0]
+    
+    def is_conditional(self) -> List[str]:
+        return [0, 0, 0, 0, 0, 0]
 
     def evaluate(self, designs: torch.Tensor, conditioning: dict = {}) -> torch.Tensor:
         framed_tensor = self.converter(designs)
@@ -157,32 +170,32 @@ class AestheticsEvaluator(EvaluationFunction):
         scaler_path = models_and_scalers_path("aesthetics_scaler.pt")
         self.preprocessor = Preprocessor(
             scaler_path=scaler_path,
-            preprocess_fn=aesthetics_predictor.remove_wall_thickness,
+            preprocess_fn=aesthetics_predictor.remove_wall_thickness_and_material,
             device=device
         )
-        state  = torch.load(state_path, weights_only=True, map_location=torch.device(device))
+        state  = torch.load(state_path, weights_only=True, map_location=device)
         self.model = get_aesthetics_model(dropout_on = False).to(device)
         self.model.load_state_dict(state)
         self.model.eval()
+        self.batch_size = batch_size
 
         self.mode = mode  # "Image", "Image Path", or "Text"
-        self.embedding_model = clip_embedding_calculator.ClipEmbeddingCalculator(
-            device=self.device,
-            batch_size=batch_size
-        )
 
     def variable_names(self) -> List[str]:
         return ordered_columns.bike_bench_columns
 
     def return_names(self) -> List[str]:
         # if self.mode in ["Image", "Image Path"]:
-        #     return ["Cosine Distance to Image"]
+        #     return ["Cosine Distance To Image"]
         if self.mode == "Text":
-            return ["Cosine Distance to Text"]
+            return ["Cosine Distance To Text"]
         elif self.mode == "Embedding":
-            return ["Cosine Distance to Embedding"]
+            return ["Cosine Distance To Embedding"]
 
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
+        return [1]
+    
+    def is_conditional(self) -> List[str]:
         return [1]
 
     def evaluate(self,
@@ -219,6 +232,14 @@ class AestheticsEvaluator(EvaluationFunction):
                 texts = list(cond)
             else:
                 raise TypeError("For Text mode, conditioning must be text or list of texts")
+
+            # Initialize embedding model if not already done
+            if not hasattr(self, 'embedding_model'):
+                self.embedding_model = clip_embedding_calculator.ClipEmbeddingCalculator(
+                device=self.device,
+                batch_size=self.batch_size
+                )
+            
             embed = self.embedding_model.embed_texts(texts)
         elif self.mode == "Embedding":
             if isinstance(cond, torch.Tensor):
@@ -266,7 +287,10 @@ class ValidationEvaluator(EvaluationFunction):
     def return_names(self) -> List[str]:
         return self.validation_names
     
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
+        return [0] * len(self.validation_names)
+    
+    def is_conditional(self) -> List[str]:
         return [0] * len(self.validation_names)
 
     def evaluate(self, designs: torch.Tensor, conditioning: dict = {}) -> torch.Tensor:
@@ -299,13 +323,22 @@ class ErgonomicsEvaluator(EvaluationFunction):
                     "Arm Too Long for Bike", "Saddle Too Far From Handle", "Torso Too Long for Bike",
                     "Saddle Too Far From Crank", "Upper Leg Too Long for Bike", "Lower Leg Too Long for Bike"]
     
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
         if self.penalize_constraints:
             return [1, 1, 1]
         elif self.constraints_only:
             return [0, 0, 0, 0, 0, 0]
         else:
             return [1, 1, 1, 0, 0, 0, 0, 0, 0]
+    
+    def is_conditional(self) -> List[str]:
+        if self.penalize_constraints:
+            return [1, 1, 1]
+        elif self.constraints_only:
+            return [1, 1, 1, 1, 1, 1]
+        else:
+            return [1, 1, 1, 1, 1, 1, 1, 1, 1]
+        
 
     def evaluate(self, designs: torch.Tensor, conditioning: dict = {}) -> torch.Tensor:
         assert "Rider" in conditioning, "Rider dimensions must be provided in conditioning to calculate ergonomics."
@@ -373,7 +406,7 @@ class UsabilityEvaluator(EvaluationFunction):
         super().__init__(device, dtype)
         scaler_path = models_and_scalers_path("usability_scaler.pt")
         state_path = models_and_scalers_path("usability_model_weights.pt")
-        state = torch.load(state_path, weights_only=True, map_location=torch.device(device))
+        state = torch.load(state_path, weights_only=True, map_location=device)
         self.model = get_usability_model(dropout_on=False).to(device)
         self.model.load_state_dict(state)
         self.preprocessor = Preprocessor(scaler_path=scaler_path, preprocess_fn=None, device=device)
@@ -385,8 +418,11 @@ class UsabilityEvaluator(EvaluationFunction):
         return ['Usability Score']
 
         
-    def return_types(self) -> List[str]:
+    def is_objective(self) -> List[str]:
         return [1]
+    
+    def is_conditional(self) -> List[str]:
+        return [0]
 
     def evaluate(self, designs: torch.Tensor, conditioning: dict = {}) -> torch.Tensor:
         designs = self.preprocessor(designs)
@@ -461,10 +497,12 @@ def construct_tensor_evaluator(evaluation_functions: List[EvaluationFunction], c
 
     # Flatten all return names across evaluators
     all_return_names = []
-    all_return_types = []
+    all_is_objective = []
+    all_is_conditional = []
     for evaluation_function in evaluation_functions:
         all_return_names.extend(evaluation_function.return_names())
-        all_return_types.extend(evaluation_function.return_types())
+        all_is_objective.extend(evaluation_function.is_objective())
+        all_is_conditional.extend(evaluation_function.is_conditional())
 
     def evaluate_tensor(designs: torch.Tensor, conditioning={}) -> torch.Tensor:
         n = designs.shape[0]
@@ -496,13 +534,13 @@ def construct_tensor_evaluator(evaluation_functions: List[EvaluationFunction], c
 
         return results_tensor
 
-    return evaluate_tensor, all_return_names, all_return_types
+    return evaluate_tensor, all_return_names, all_is_objective, all_is_conditional
 
 def construct_dataframe_evaluator(evaluation_functions: List[EvaluationFunction]):
 
     def evaluate_dataframe(designs: pd.DataFrame, conditioning={}) -> pd.DataFrame:
         designs_tensor = torch.tensor(designs.values, dtype=torch.float32)
-        tensor_evaluator, return_names, return_types = construct_tensor_evaluator(evaluation_functions, list(designs.columns))
+        tensor_evaluator, return_names, is_objective, all_is_conditional = construct_tensor_evaluator(evaluation_functions, list(designs.columns))
         results_tensor = tensor_evaluator(designs_tensor, conditioning)
 
         results_df = pd.DataFrame(
@@ -511,7 +549,7 @@ def construct_dataframe_evaluator(evaluation_functions: List[EvaluationFunction]
             index=designs.index
         )
 
-        return results_df, return_types
+        return results_df, is_objective, all_is_conditional
 
     return evaluate_dataframe
 

bike_bench_internal/src/bikebench/prediction/aesthetics_predictor.py

@@ -6,11 +6,10 @@ from bikebench.resource_utils import models_and_scalers_path
 from bikebench.prediction.prediction_utils import TorchStandardScaler
 
 
-def remove_wall_thickness(x, device):
-    # indices_to_drop = [27, 28, 29, 30, 31, 32, 33]
-    first_chunk = x[:, :27]
-    second_chunk = x[:, 34:]
-    x = torch.cat((first_chunk, second_chunk), dim=1)
+def remove_wall_thickness_and_material(x, device):
+    indices_to_drop = [30, 31, 32, 33, 34, 35, 36, 55, 56, 57]
+    indices_to_keep = [i for i in range(x.shape[1]) if i not in indices_to_drop]
+    x = x[:, indices_to_keep]
     return x
     
 class ResidualBlock(nn.Module):
@@ -55,7 +54,7 @@ class ResidualNetwork(nn.Module):
 
 def get_aesthetics_model(dropout_on = False):
     if dropout_on:
-        model = ResidualNetwork(80, 512, layer_size=256, layers_per_block=2, num_blocks=3)
+        model = ResidualNetwork(73, 512, layer_size=256, layers_per_block=2, num_blocks=3)
     else:
-        model = ResidualNetwork(80, 512, layer_size=256, layers_per_block=2, num_blocks=3)
+        model = ResidualNetwork(73, 512, layer_size=256, layers_per_block=2, num_blocks=3)
     return model

bike_bench_internal/src/bikebench/transformation/framed.py

@@ -64,9 +64,6 @@ BIKEBENCH_TO_FRAMED_IDENTICAL = {
 MATERIALS = {"MATERIAL OHCLASS: ALUMINIUM": "Aluminum",
              "MATERIAL OHCLASS: STEEL": "Steel",
              "MATERIAL OHCLASS: TITANIUM": "Titanium",
-             "MATERIAL OHCLASS: CARBON": "Steel", # Overridden to Steel
-             "MATERIAL OHCLASS: BAMBOO": "Steel", # Overridden to Steel
-             "MATERIAL OHCLASS: OTHER": "Steel" # Overridden to Steel
             }
 def clip_to_framed(X_clip):
     X_framed = pd.DataFrame()

bike_bench_internal/src/bikebench/transformation/one_hot_encoding.py

@@ -6,6 +6,7 @@ import pandas as pd
 ONE_HOT_ENCODED_BIKEBENCH_COLUMNS: List[str] = [
     'MATERIAL',
     'Head tube type',
+    'Down tube type',
     'RIM_STYLE front',
     'RIM_STYLE rear',
     'Handlebar style',
@@ -17,9 +18,6 @@ ONE_HOT_ENCODED_BIKEBENCH_COLUMNS: List[str] = [
 ALL_CATEGORIES = {
     'MATERIAL': [
         'ALUMINIUM',
-        'BAMBOO',
-        'CARBON',
-        'OTHER',
         'STEEL',
         'TITANIUM'
     ],
@@ -29,6 +27,11 @@ ALL_CATEGORIES = {
         '2',
         '3'
     ],
+    'Down tube type': [
+        '0',
+        '1',
+        '2'
+    ],
     'RIM_STYLE front': [
         'DISC',
         'SPOKED',
@@ -127,6 +130,12 @@ def encode_to_continuous(df: pd.DataFrame) -> pd.DataFrame:
     for col in BOOLEAN_COLUMNS:
         if col in out.columns:
             out[col] = out[col].astype(float)
+            
+    #replace any non-floats with 0.0
+    for col in out.columns:
+        if out[col].dtype == object:
+            out[col] = pd.to_numeric(out[col], errors='coerce').fillna(0.0)
+            print(f"⚠️ Warning: Column '{col}' contained non-numeric values which were converted to 0.0")
 
     return out.astype(np.float32)
 

bike_bench_internal/src/bikebench/transformation/ordered_columns.py

@@ -10,17 +10,17 @@ bike_bench_columns = ['Seatpost LENGTH', 'CS textfield', 'BB textfield', 'Stack'
        'Wall thickness Head tube', 'Wall thickness Down tube',
        'Wall thickness Chain stay', 'Wall thickness Seat stay',
        'Wall thickness Seat tube', 'Wheel diameter front', 'RDBSD',
-       'Wheel diameter rear', 'FDBSD', 'Display AEROBARS', 'BB length',
-       'Wheel cut', 'Front Fender include', 'Rear Fender include', 
+       'Wheel diameter rear', 'FDBSD', 'BB length', 'Wheel cut', 
        'BELTorCHAIN', 'Number of cogs', 'Number of chainrings',
        'FIRST color R_RGB', 'FIRST color G_RGB', 'FIRST color B_RGB',
        'SPOKES composite front', 'SPOKES composite rear', 'SBLADEW front',
-       'SBLADEW rear', 'Saddle length', 'Saddle height', 'Down tube type',
-       'MATERIAL OHCLASS: ALUMINIUM', 'MATERIAL OHCLASS: BAMBOO',
-       'MATERIAL OHCLASS: CARBON', 'MATERIAL OHCLASS: OTHER',
+       'SBLADEW rear', 'Saddle length', 'Saddle height',
+       'MATERIAL OHCLASS: ALUMINIUM',
        'MATERIAL OHCLASS: STEEL', 'MATERIAL OHCLASS: TITANIUM',
        'Head tube type OHCLASS: 0', 'Head tube type OHCLASS: 1',
        'Head tube type OHCLASS: 2', 'Head tube type OHCLASS: 3',
+       'Down tube type OHCLASS: 0', 'Down tube type OHCLASS: 1',
+       'Down tube type OHCLASS: 2',
        'RIM_STYLE front OHCLASS: DISC', 'RIM_STYLE front OHCLASS: SPOKED',
        'RIM_STYLE front OHCLASS: TRISPOKE', 'RIM_STYLE rear OHCLASS: DISC',
        'RIM_STYLE rear OHCLASS: SPOKED', 'RIM_STYLE rear OHCLASS: TRISPOKE',
@@ -34,9 +34,6 @@ bike_bench_columns = ['Seatpost LENGTH', 'CS textfield', 'BB textfield', 'Stack'
 oh_columns = [
             [
                 "MATERIAL OHCLASS: ALUMINIUM",
-                "MATERIAL OHCLASS: BAMBOO",
-                "MATERIAL OHCLASS: CARBON",
-                "MATERIAL OHCLASS: OTHER",
                 "MATERIAL OHCLASS: STEEL",
                 "MATERIAL OHCLASS: TITANIUM",
             ],
@@ -46,6 +43,11 @@ oh_columns = [
                 "Head tube type OHCLASS: 2",
                 "Head tube type OHCLASS: 3",
             ],
+            [
+                "Down tube type OHCLASS: 0",
+                "Down tube type OHCLASS: 1",
+                "Down tube type OHCLASS: 2",
+            ],
             [
                 "RIM_STYLE front OHCLASS: DISC",
                 "RIM_STYLE front OHCLASS: SPOKED",
@@ -81,9 +83,6 @@ oh_columns = [
 
 oh_bool_columns = [
     "MATERIAL OHCLASS: ALUMINIUM",
-    "MATERIAL OHCLASS: BAMBOO",
-    "MATERIAL OHCLASS: CARBON",
-    "MATERIAL OHCLASS: OTHER",
     "MATERIAL OHCLASS: STEEL",
     "MATERIAL OHCLASS: TITANIUM",
 
@@ -92,6 +91,10 @@ oh_bool_columns = [
     "Head tube type OHCLASS: 2",
     "Head tube type OHCLASS: 3",
 
+    "Down tube type OHCLASS: 0",
+    "Down tube type OHCLASS: 1",
+    "Down tube type OHCLASS: 2",
+
     "RIM_STYLE front OHCLASS: DISC",
     "RIM_STYLE front OHCLASS: SPOKED",
     "RIM_STYLE front OHCLASS: TRISPOKE",

bike_bench_internal/src/bikebench/validation/bike_bench_validation_functions.py

@@ -25,42 +25,42 @@ ZERO_IS_VALID_COLS = ['FIRST color R_RGB',
        'FIRST color G_RGB', 'FIRST color B_RGB']
 
 class SaddleHeightTooSmall(ValidationFunction):
-    def friendly_name(self) -> str: return "Saddle height too small"
+    def friendly_name(self) -> str: return "Saddle Height Too Small"
     def variable_names(self) -> List[str]: return ["Saddle height"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return 100.0 - ctx.col("Saddle height")
 
 
 class SaddleCollidesWithSeatTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Saddle collides with seat tube"
+    def friendly_name(self) -> str: return "Saddle Collides With Seat Tube"
     def variable_names(self) -> List[str]: return ["Saddle height", "Seat tube length"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return ctx.col("Seat tube length") + 40.0 - ctx.col("Saddle height")
 
 
 class SaddleTooShort(ValidationFunction):
-    def friendly_name(self) -> str: return "Saddle too short"
+    def friendly_name(self) -> str: return "Saddle Too Short"
     def variable_names(self) -> List[str]: return ["Saddle length"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return 228.0 - ctx.col("Saddle length")
 
 
 class HeadAngleOverLimit(ValidationFunction):
-    def friendly_name(self) -> str: return "Head angle over limit"
+    def friendly_name(self) -> str: return "Head Angle Over Limit"
     def variable_names(self) -> List[str]: return ["Head angle"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return ctx.col("Head angle") - 180.0
 
 
 class SeatAngleOverLimit(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat angle over limit"
+    def friendly_name(self) -> str: return "Seat Angle Over Limit"
     def variable_names(self) -> List[str]: return ["Seat angle"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return ctx.col("Seat angle") - 180.0
 
 
 class SeatPostTooShort(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat post too short"
+    def friendly_name(self) -> str: return "Seat Post Too Short"
     def variable_names(self) -> List[str]:
         return ["Seat tube length", "Seatpost LENGTH", "Saddle height", "Seat angle"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
@@ -73,7 +73,7 @@ class SeatPostTooShort(ValidationFunction):
 
 
 class SeatPostTooLong(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat post too long"
+    def friendly_name(self) -> str: return "Seat Post Too Long"
     def variable_names(self) -> List[str]:
         return ["Seatpost LENGTH", "Saddle height", "Seat angle"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
@@ -83,7 +83,7 @@ class SeatPostTooLong(ValidationFunction):
 
 
 class RearWheelInnerDiameterTooSmall(ValidationFunction):
-    def friendly_name(self) -> str: return "Rear Wheel inner diameter too small"
+    def friendly_name(self) -> str: return "Rear Wheel Inner Diameter Too Small"
     def variable_names(self) -> List[str]: return ["Wheel diameter rear", "RDBSD"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         inner_d = ctx.col("Wheel diameter rear") - 2.0 * ctx.col("RDBSD")
@@ -91,7 +91,7 @@ class RearWheelInnerDiameterTooSmall(ValidationFunction):
 
 
 class FrontWheelInnerDiameterTooSmall(ValidationFunction):
-    def friendly_name(self) -> str: return "Front Wheel inner diameter too small"
+    def friendly_name(self) -> str: return "Front Wheel Inner Diameter Too Small"
     def variable_names(self) -> List[str]: return ["Wheel diameter front", "FDBSD"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         inner_d = ctx.col("Wheel diameter front") - 2.0 * ctx.col("FDBSD")
@@ -99,14 +99,14 @@ class FrontWheelInnerDiameterTooSmall(ValidationFunction):
 
 
 class SeatTubeExtensionLongerThanSeatTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat tube extension longer than seat tube"
+    def friendly_name(self) -> str: return "Seat Tube Extension Longer Than Seat Tube"
     def variable_names(self) -> List[str]: return ["Seat tube length", "Seat tube extension2"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return ctx.col("Seat tube extension2") - ctx.col("Seat tube length")
 
 
 class HeadTubeUpperExtensionAndLowerExtensionOverlap(ValidationFunction):
-    def friendly_name(self) -> str: return "Head tube upper extension and lower extension overlap"
+    def friendly_name(self) -> str: return "Head Tube Upper Extension And Lower Extension Overlap"
     def variable_names(self) -> List[str]:
         return ["Head tube length textfield", "Head tube upper extension2", "Head tube lower extension2"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
@@ -114,14 +114,14 @@ class HeadTubeUpperExtensionAndLowerExtensionOverlap(ValidationFunction):
 
 
 class SeatStayJunctionLongerThanSeatTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat stay junction longer than seat tube"
+    def friendly_name(self) -> str: return "Seat Stay Junction Longer Than Seat Tube"
     def variable_names(self) -> List[str]: return ["Seat tube length", "Seat stay junction0"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return ctx.col("Seat stay junction0") - ctx.col("Seat tube length")
 
 
 class NonNegativeParameterIsNegative(ValidationFunction):
-    def friendly_name(self) -> str: return "Non-negative parameter is negative"
+    def friendly_name(self) -> str: return "Non-negative Parameter Is Negative"
     def variable_names(self) -> List[str]: return POSITIVE_COLS
     def validate(self, ctx: 'FeatureStore') -> torch.Tensor:
         X = torch.stack([ctx.col(c) for c in POSITIVE_COLS], dim=1)  # (n, k)
@@ -135,21 +135,21 @@ class NonNegativeParameterIsNegative(ValidationFunction):
 
 
 class ChainStaySmallerThanRearWheelRadius(ValidationFunction):
-    def friendly_name(self) -> str: return "Chain stay smaller than rear wheel radius"
+    def friendly_name(self) -> str: return "Chain Stay Smaller Than Rear Wheel Radius"
     def variable_names(self) -> List[str]: return ["CS textfield", "Wheel diameter rear"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return (ctx.col("Wheel diameter rear") * 0.5) - ctx.col("CS textfield")
 
 
 class ChainStayShorterThanBBDrop(ValidationFunction):
-    def friendly_name(self) -> str: return "Chain stay shorter than BB drop"
+    def friendly_name(self) -> str: return "Chain Stay Shorter Than BB Drop"
     def variable_names(self) -> List[str]: return ["CS textfield", "BB textfield"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return ctx.col("BB textfield") - ctx.col("CS textfield")
 
 
 class SeatStaySmallerThanRearWheelRadius(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat stay smaller than rear wheel radius"
+    def friendly_name(self) -> str: return "Seat Stay Smaller Than Rear Wheel Radius"
     def variable_names(self) -> List[str]:
         return ["CS textfield", "BB textfield","Seat tube length", "Seat stay junction0", "Seat angle", "Wheel diameter rear"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
@@ -166,9 +166,9 @@ class SeatStaySmallerThanRearWheelRadius(ValidationFunction):
         return (ctx.col("Wheel diameter rear") * 0.5) - g
 
 
-class SeatTubeIntersectsRearWheel(ValidationFunction):
+class SeatTubeCollidesWithRearWheel(ValidationFunction):
     def friendly_name(self) -> str:
-        return "Seat Tube Intersects Rear Wheel"
+        return "Seat Tube Collides With Rear Wheel"
 
     def variable_names(self) -> List[str]:
         return [
@@ -206,7 +206,7 @@ class SeatTubeIntersectsRearWheel(ValidationFunction):
 
 
 class DownTubeCantReachHeadTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Down tube can't reach head tube"
+    def friendly_name(self) -> str: return "Down Tube Can't Reach Head Tube"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head angle", "DT Length"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
@@ -215,7 +215,7 @@ class DownTubeCantReachHeadTube(ValidationFunction):
 
 class RearWheelCutoutSeversSeatTube(ValidationFunction):
     def friendly_name(self) -> str:
-        return "Rear wheel cutout severs seat tube"
+        return "Rear Wheel Cutout Severs Seat Tube"
 
     def variable_names(self) -> List[str]:
         return [
@@ -249,8 +249,8 @@ class RearWheelCutoutSeversSeatTube(ValidationFunction):
         q = torch.where(aero_mask, q_true, q_false)
         return (wheel_cut * 0.5) - q
 
-class FootIntersectsFrontWheel(ValidationFunction):
-    def friendly_name(self) -> str: return "Foot intersects front wheel"
+class FootCollidesWithFrontWheel(ValidationFunction):
+    def friendly_name(self) -> str: return "Foot Collides With Front Wheel"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head angle",
                 "BB textfield", "DT Length", "FORK0R", "Wheel diameter front", "Wheel diameter rear"]
@@ -264,14 +264,14 @@ class FootIntersectsFrontWheel(ValidationFunction):
 
 
 class CrankHitsGroundInLowestPosition(ValidationFunction):
-    def friendly_name(self) -> str: return "Crank hits ground in lowest position"
+    def friendly_name(self) -> str: return "Crank Hits Ground In Lowest Position"
     def variable_names(self) -> List[str]: return ["BB textfield", "Wheel diameter rear"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return (187.5 + ctx.col("BB textfield")) - (ctx.col("Wheel diameter rear") * 0.5)
 
 
-class RGBvalueGreaterThan255(ValidationFunction):
-    def friendly_name(self) -> str: return "RGB value greater than 255"
+class RGBValueGreaterThan255(ValidationFunction):
+    def friendly_name(self) -> str: return "RGB Value Greater Than 255"
     def variable_names(self) -> List[str]:
         return ["FIRST color R_RGB", "FIRST color G_RGB", "FIRST color B_RGB"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
@@ -285,14 +285,14 @@ class RGBvalueGreaterThan255(ValidationFunction):
 
 
 class ChainStaysIntersect(ValidationFunction):
-    def friendly_name(self) -> str: return "Chain stays intersect"
+    def friendly_name(self) -> str: return "Chain Stays Intersect"
     def variable_names(self) -> List[str]: return ["csd", "Chain stay position on BB","BB length"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         return (ctx.col("csd")*0.5 + ctx.col("Chain stay position on BB")) - (ctx.col("BB length")*0.5)
 
 
 class TubeWallThicknessExceedsRadius(ValidationFunction):
-    def friendly_name(self) -> str: return "Tube wall thickness exceeds radius"
+    def friendly_name(self) -> str: return "Tube Wall Thickness Exceeds Radius"
     def variable_names(self) -> List[str]:
         return [
             "ttd", "Wall thickness Top tube",
@@ -312,8 +312,8 @@ class TubeWallThicknessExceedsRadius(ValidationFunction):
         return torch.sum(torch.clamp_min(violation, 0.0), dim=1)
 
 
-class SeatTubeInnerDiameterThinnerThanSeatPostOuterDiameter(ValidationFunction):
-    def friendly_name(self) -> str: return "Seat tube inner diameter thinner than seat post outer diameter"
+class SeatTubeTooNarrowForSeatPost(ValidationFunction):
+    def friendly_name(self) -> str: return "Seat Tube Too Narrow For Seat Post"
     def variable_names(self) -> List[str]: return ["std", "Wall thickness Seat tube"]
     def validate(self, ctx: FeatureStore) -> torch.Tensor:
         inner_d = ctx.col("std") - ctx.col("Wall thickness Seat tube")
@@ -321,7 +321,7 @@ class SeatTubeInnerDiameterThinnerThanSeatPostOuterDiameter(ValidationFunction):
 
 
 class DownTubeImproperlyJoinsHeadTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Down tube improperly joins head tube"
+    def friendly_name(self) -> str: return "Down Tube Improperly Joins Head Tube"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head angle",
                 "DT Length", "dtd", "htd"]
@@ -347,7 +347,7 @@ class DownTubeImproperlyJoinsHeadTube(ValidationFunction):
 
 
 class TopTubeImproperlyJoinsHeadTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Top tube improperly joins head tube"
+    def friendly_name(self) -> str: return "Top Tube Improperly Joins Head Tube"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head tube upper extension2",
                 "Seat tube extension2", "Head angle", "Seat angle", "DT Length", "ttd", "htd","Seat tube length"]
@@ -376,7 +376,7 @@ class TopTubeImproperlyJoinsHeadTube(ValidationFunction):
 
 
 class TopTubeImproperlyJoinsSeatTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Top tube improperly joins seat tube"
+    def friendly_name(self) -> str: return "Top Tube Improperly Joins Seat Tube"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head tube upper extension2",
                 "Seat tube extension2", "Head angle", "Seat angle", "DT Length", "ttd", "std","Seat tube length"]
@@ -405,8 +405,8 @@ class TopTubeImproperlyJoinsSeatTube(ValidationFunction):
         return L1 + L2 - stux + below_0_pen + above_pi_pen + seatpost_clamp_default_offset
 
 
-class DownTubeIntersectsFrontWheel(ValidationFunction):
-    def friendly_name(self) -> str: return "Down tube intersects front wheel"
+class DownTubeCollidesWithFrontWheel(ValidationFunction):
+    def friendly_name(self) -> str: return "Down Tube Collides With Front Wheel"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head angle",
                 "DT Length", "BB textfield", "FORK0R", "Wheel diameter front", "Wheel diameter rear", "dtd"]
@@ -427,7 +427,7 @@ class DownTubeIntersectsFrontWheel(ValidationFunction):
 
 
 class SaddleHitsTopTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Saddle hits top tube"
+    def friendly_name(self) -> str: return "Saddle Hits Top Tube"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head tube upper extension2",
                 "Seat tube extension2", "Head angle", "Seat angle", "DT Length", "ttd", "std",
@@ -465,7 +465,7 @@ class SaddleHitsTopTube(ValidationFunction):
 
 
 class SaddleHitsHeadTube(ValidationFunction):
-    def friendly_name(self) -> str: return "Saddle hits head tube"
+    def friendly_name(self) -> str: return "Saddle Hits Head Tube"
     def variable_names(self) -> List[str]:
         return ["Stack", "Head tube length textfield", "Head tube lower extension2", "Head tube upper extension2",
                 "Seat tube extension2", "Head angle", "Seat angle", "DT Length", "ttd", "htd",
@@ -519,19 +519,19 @@ bike_bench_validation_functions: List[ValidationFunction] = [
     ChainStaySmallerThanRearWheelRadius(),
     ChainStayShorterThanBBDrop(),
     SeatStaySmallerThanRearWheelRadius(),
-    SeatTubeIntersectsRearWheel(),
+    SeatTubeCollidesWithRearWheel(),
     DownTubeCantReachHeadTube(),
     RearWheelCutoutSeversSeatTube(),
-    FootIntersectsFrontWheel(),
+    FootCollidesWithFrontWheel(),
     CrankHitsGroundInLowestPosition(),
-    RGBvalueGreaterThan255(),
+    RGBValueGreaterThan255(),
     ChainStaysIntersect(),
     TubeWallThicknessExceedsRadius(),
-    SeatTubeInnerDiameterThinnerThanSeatPostOuterDiameter(),
+    SeatTubeTooNarrowForSeatPost(),
     DownTubeImproperlyJoinsHeadTube(),
     TopTubeImproperlyJoinsHeadTube(),
     TopTubeImproperlyJoinsSeatTube(),
-    DownTubeIntersectsFrontWheel(),
+    DownTubeCollidesWithFrontWheel(),
     SaddleHitsTopTube(),
     SaddleHitsHeadTube(),
 ]
@@ -553,19 +553,19 @@ difficult_validation_functions: List[ValidationFunction] = [
     # ChainStaySmallerThanRearWheelRadius(),
     # ChainStayShorterThanBBDrop(),
     # SeatStaySmallerThanRearWheelRadius(),
-    SeatTubeIntersectsRearWheel(),
+    SeatTubeCollidesWithRearWheel(),
     # DownTubeCantReachHeadTube(),
     # RearWheelCutoutSeversSeatTube(),
-    FootIntersectsFrontWheel(),
+    FootCollidesWithFrontWheel(),
     # CrankHitsGroundInLowestPosition(),
-    # RGBvalueGreaterThan255(),
+    # RGBValueGreaterThan255(),
     # ChainStaysIntersect(),
     # TubeWallThicknessExceedsRadius(),
-    SeatTubeInnerDiameterThinnerThanSeatPostOuterDiameter(), 
+    SeatTubeTooNarrowForSeatPost(), 
     DownTubeImproperlyJoinsHeadTube(),
     # TopTubeImproperlyJoinsHeadTube(),
     TopTubeImproperlyJoinsSeatTube(),
-    # DownTubeIntersectsFrontWheel(),
+    # DownTubeCollidesWithFrontWheel(),
     # SaddleHitsTopTube(),
     # SaddleHitsHeadTube(),
 ]

bike_bench_internal/src/bikebench/xml_handling/bcad_to_bikebench.py

@@ -324,12 +324,9 @@ TYPE_SPEC = {
     "FDBSD": "float",
     "Fork type": "int",
     "Stem kind": "int",
-    "Display AEROBARS": "bool",
     "Handlebar style": "cat",
     "BB length": "float",
     "Wheel cut": "float",
-    "Front Fender include": "bool",
-    "Rear Fender include": "bool",
     "BELTorCHAIN": "bool",
     "Number of cogs": "int",
     "Number of chainrings": "int",
@@ -560,6 +557,11 @@ def build_bikebench_dataframe(
     result = converted[ordered_cols].copy()
     result.index.name = None
 
+    result["MATERIAL"] = result["MATERIAL"].map(_material_to_3class)
+
+    # Enforce schema & impute
+    result = apply_type_schema(result)
+
     # Enforce schema & impute
     result = apply_type_schema(result)
 
@@ -595,6 +597,29 @@ def build_bikebench_dataframe(
 
     return result
 
+def _material_to_3class(val: object) -> str:
+    """Map raw MATERIAL values to three classes: ALUMINIUM, STEEL, BAMBOO."""
+    if val is None or (isinstance(val, float) and pd.isna(val)):
+        return "ALUMINIUM"  # treat missing like OTHER -> ALUMINIUM
+
+    s = str(val).strip().upper()
+    # normalize a bit
+    s_norm = re.sub(r"[^A-Z]", "", s)  # remove spaces, dashes, etc.
+
+    # direct keep
+    if s_norm == "TITANIUM":
+        return "TITANIUM"
+    if s_norm == "STEEL":
+        return "STEEL"
+
+    # map CARBON (and a couple common aliases) to STEEL
+    if s_norm == "CARBON":
+        return "STEEL"
+
+    # everything else (OTHER, ALUMINIUM, ALLOY, unknowns...) → ALUMINIUM
+    return "ALUMINIUM"
+
+
 THICKNESS_COLS = [
     "Wall thickness Bottom Bracket",
     "Wall thickness Top tube",

bike_bench_internal/src/resources/misc/ref_point.csv

@@ -1,50 +1,50 @@
-Usability Score,0.96583045
-Drag Force (N),26.949783
-Knee Angle Error (deg.),121.69888
-Hip Angle Error (deg.),45.15921
-Arm Angle Error (deg.),51.60288
-Arm Too Long for Bike,-0.2584031
-Saddle Too Far From Handle,-0.0924381
-Torso Too Long for Bike,-0.40180784
-Saddle Too Far From Crank,0.18204135
-Upper Leg Too Long for Bike,-0.6047877
-Lower Leg Too Long for Bike,-0.18946144
-Cosine Distance to Embedding,0.3990872
-Mass (kg),13.66151
-Planar Compliance Score,9.490826
-Transverse Compliance Score,8.403987
-Eccentric Compliance Score,8.238781
-Planar Safety Factor,1.0
-Eccentric Safety Factor,1.0
-Predicted Frame Validity,0.5
-Saddle height too small,-130.0
-Saddle collides with seat tube,56.299988
-Saddle too short,98.0
-Head angle over limit,-97.0
-Seat angle over limit,-90.0
-Seat post too short,227.887
-Seat post too long,43.014893
-Rear Wheel inner diameter too small,52.0
-Front Wheel inner diameter too small,52.0
-Seat tube extension longer than seat tube,-80.0
-Head tube upper extension and lower extension overlap,67.59999
-Seat stay junction longer than seat tube,-82.0
-Non-negative parameter is negative,210.0
-Chain stay smaller than rear wheel radius,37.0
-Chain stay shorter than BB drop,-230.0
-Seat stay smaller than rear wheel radius,-3.105194
-Seat Tube Intersects Rear Wheel,89.69733
-Down tube can't reach head tube,-81.2265
-Rear wheel cutout severs seat tube,-12.901978
-Foot intersects front wheel,36118.047
-Crank hits ground in lowest position,32.5
-RGB value greater than 255,0.0
-Chain stays intersect,22.625
-Tube wall thickness exceeds radius,3.2742386
-Seat tube inner diameter thinner than seat post outer diameter,29.329865
-Down tube improperly joins head tube,55.09871
-Top tube improperly joins head tube,27.778019
-Top tube improperly joins seat tube,25.929976
-Down tube intersects front wheel,30.511627
-Saddle hits top tube,0.3413951
-Saddle hits head tube,-0.0586164
+Usability Score,1.0059241
+Drag Force (N),27.861992
+Knee Angle Error (deg.),127.78383
+Hip Angle Error (deg.),47.41717
+Arm Angle Error (deg.),54.18302
+Arm Too Long for Bike,-0.21971205
+Saddle Too Far From Handle,-0.056464136
+Torso Too Long for Bike,-0.366885
+Saddle Too Far From Crank,0.22086428
+Upper Leg Too Long for Bike,-0.5684242
+Lower Leg Too Long for Bike,-0.15311062
+Cosine Distance To Embedding,0.39972186
+Mass (kg),14.34326
+Planar Compliance Score,9.962891
+Transverse Compliance Score,8.808648
+Eccentric Compliance Score,8.635697
+Planar Safety Factor,1.2305812
+Eccentric Safety Factor,1.1785439
+Predicted Frame Validity,0.55
+Saddle Height Too Small,-97.435
+Saddle Collides With Seat Tube,83.23999
+Saddle Too Short,115.5
+Head Angle Over Limit,-95.1
+Seat Angle Over Limit,-87.7
+Seat Post Too Short,257.977
+Seat Post Too Long,79.27089
+Rear Wheel Inner Diameter Too Small,92.2
+Front Wheel Inner Diameter Too Small,92.2
+Seat Tube Extension Longer Than Seat Tube,-51.0
+Head Tube Upper Extension And Lower Extension Overlap,85.07499
+Seat Stay Junction Longer Than Seat Tube,-53.565
+Non-negative Parameter Is Negative,-4571.084
+Chain Stay Smaller Than Rear Wheel Radius,71.325
+Chain Stay Shorter Than BB Drop,-196.775
+Seat Stay Smaller Than Rear Wheel Radius,26.516027
+Seat Tube Collides With Rear Wheel,123.08644
+Down Tube Can't Reach Head Tube,-65.34191
+Rear Wheel Cutout Severs Seat Tube,49999972.0
+Foot Collides With Front Wheel,60363.273
+Crank Hits Ground In Lowest Position,44.55
+RGB Value Greater Than 255,38.25
+Chain Stays Intersect,40.745003
+Tube Wall Thickness Exceeds Radius,3.4379506
+Seat Tube Too Narrow For Seat Post,32.42751
+Down Tube Improperly Joins Head Tube,62.309597
+Top Tube Improperly Joins Head Tube,35.511604
+Top Tube Improperly Joins Seat Tube,42.88616
+Down Tube Collides With Front Wheel,47.536987
+Saddle Hits Top Tube,0.4291829
+Saddle Hits Head Tube,0.037365556

bike_bench_internal/src/resources/models_and_scalers/aesthetics_model_weights.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b7da88a1b263a2e75e1b8d221e63c8e0bb05e4f4f7ac20bd5cd07970f434d16a
-size 2212539
+oid sha256:79d5b3766259ab7b134eb94f1ba5632f1269c2ac23ca9b34ebe7ec387516df12
+size 2205371

bike_bench_internal/src/resources/models_and_scalers/aesthetics_scaler.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:26d2cdf2cc89b2ceb1b8a7015bbf53cc74e1448b03f0e616fbf37431f3338019
-size 3189
+oid sha256:fb3a5edc888be3f7ec468c1a852c2fce98b60d8ac90cb5f7c71ad308c342010a
+size 3061