Update MLATE model selection and optimization app

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.venv-test/

app.py

@@ -1,10 +1,10 @@
 import os
+from pathlib import Path
 import streamlit as st
 import pandas as pd
 import joblib
 import optuna
 import numpy as np
-from catboost import CatBoostClassifier
 
 from google import genai
 from google.genai import types
@@ -33,12 +33,197 @@ def safe_number_input(label, **kwargs):
 
 st.number_input = safe_number_input
 
-gemini_key = os.getenv("GEMINI_API_KEY")
-if not gemini_key:
-    st.error("Gemini API key not found. Please set GEMINI_API_KEY in your Space settings.")
-    st.stop()
-
-client = genai.Client(api_key=gemini_key)
+APP_DIR = Path(__file__).resolve().parent
+MODEL_ROOT = APP_DIR / "models"
+PREPROCESSOR_DIR = MODEL_ROOT / "preprocessors"
+
+MODEL_TASKS = {
+    "printability": {
+        "folder": MODEL_ROOT / "printability",
+        "prefix": "Printability_",
+        "label_encoder": "label_encoder_printability.pkl",
+    },
+    "cell_response": {
+        "folder": MODEL_ROOT / "cell response",
+        "prefix": "Cell_Response_",
+        "label_encoder": "label_encoder_cell_response.pkl",
+    },
+}
+
+DL_MODEL_CONFIGS = {
+    ("printability", "ResNet"): {"n_layers": 6, "hidden_dim": 302, "dropout": 0.190106, "activation_func": "relu"},
+    ("printability", "MLP"): {"n_layers": 3, "hidden_dim": 367, "dropout": 0.169472, "activation_func": "tanh"},
+    ("printability", "1D_CNN"): {"n_layers": 6, "hidden_dim": 287, "dropout": 0.233072, "activation_func": "relu"},
+    ("printability", "FT_Transformer"): {"n_layers": 3, "hidden_dim": 437, "dropout": 0.324095, "activation_func": "GELU"},
+    ("printability", "TabNet_Lite"): {"n_layers": 4, "hidden_dim": 283, "dropout": 0.309445, "activation_func": "relu"},
+    ("printability", "NODE_Lite"): {"n_layers": 5, "hidden_dim": 289, "dropout": 0.145481, "activation_func": "SELU"},
+    ("cell_response", "ResNet"): {"n_layers": 4, "hidden_dim": 269, "dropout": 0.229224, "activation_func": "tanh"},
+    ("cell_response", "MLP"): {"n_layers": 5, "hidden_dim": 238, "dropout": 0.256294, "activation_func": "ELU"},
+    ("cell_response", "1D_CNN"): {"n_layers": 6, "hidden_dim": 134, "dropout": 0.158794, "activation_func": "SiLU"},
+    ("cell_response", "FT_Transformer"): {"n_layers": 5, "hidden_dim": 395, "dropout": 0.185155, "activation_func": "SiLU"},
+    ("cell_response", "TabNet_Lite"): {"n_layers": 5, "hidden_dim": 342, "dropout": 0.103486, "activation_func": "SiLU"},
+    ("cell_response", "NODE_Lite"): {"n_layers": 2, "hidden_dim": 127, "dropout": 0.328308, "activation_func": "SiLU"},
+}
+
+MODEL_RANKINGS = {
+    "printability": [
+        "HistGradientBoosting", "TabPFN 2.6", "Bagging", "GradientBoosting", "TabICL v2",
+        "XGBoost", "LightGBM", "KNeighbors", "LabelPropagation", "ExtraTrees", "MLP",
+        "LabelSpreading", "TabNet Lite", "MLP DL", "ResNet", "1D CNN", "DecisionTree",
+        "NODE Lite", "LinearSVC", "LDA", "PassiveAggressive", "CalibratedClassifierCV",
+        "LogisticRegression", "RidgeClassifier", "FT Transformer", "Perceptron",
+        "MultinomialNB", "RadiusNeighbors", "ComplementNB", "NuSVC", "AdaBoost",
+        "SGD", "BernoulliNB", "GaussianNB", "QDA", "RandomForest", "ExtraTreeClassifier",
+        "DummyClassifier",
+    ],
+    "cell_response": [
+        "HistGradientBoosting", "TabICL v2", "TabPFN 2.6", "XGBoost", "Bagging",
+        "KNeighbors", "LabelPropagation", "LabelSpreading", "LightGBM", "FT Transformer",
+        "CalibratedClassifierCV", "ResNet", "NODE Lite", "1D CNN", "MLP DL", "LDA",
+        "NuSVC", "MultinomialNB", "LogisticRegression", "LinearSVC", "Perceptron",
+        "QDA", "RidgeClassifier", "ExtraTrees", "ExtraTreeClassifier", "AdaBoost",
+        "DecisionTree", "RandomForest", "GradientBoosting", "SGD", "MLP",
+        "PassiveAggressive", "ComplementNB", "TabNet Lite", "BernoulliNB",
+        "RadiusNeighbors", "DummyClassifier", "GaussianNB",
+    ],
+}
+
+PERFORMANCE_GUIDE = {
+    "printability": """
+| Rank | Model | Framework | Accuracy | F1 | AUC | MCC |
+|---:|---|---|---:|---:|---:|---:|
+| 1 | HistGradientBoosting | Machine Learning | 0.80 | 0.80 | 0.94 | 0.69 |
+| 2 | TabPFN 2.6 | Deep Learning / Transformer | 0.80 | 0.80 | 0.94 | 0.69 |
+| 3 | Bagging | Machine Learning | 0.79 | 0.79 | 0.93 | 0.67 |
+| 4 | GradientBoosting | Machine Learning | 0.79 | 0.79 | 0.93 | 0.66 |
+| 5 | TabICL v2 | Deep Learning / Transformer | 0.79 | 0.79 | 0.94 | 0.68 |
+| 6 | XGBoost | Machine Learning | 0.78 | 0.78 | 0.93 | 0.66 |
+| 7 | LightGBM | Machine Learning | 0.77 | 0.77 | 0.93 | 0.64 |
+| 8 | KNeighbors | Machine Learning | 0.77 | 0.77 | 0.90 | 0.64 |
+| 9 | LabelPropagation | Machine Learning | 0.77 | 0.77 | 0.82 | 0.64 |
+| 10 | ExtraTrees | Machine Learning | 0.77 | 0.77 | 0.92 | 0.63 |
+""",
+    "cell_response": """
+| Rank | Model | Framework | Accuracy | F1 | AUC | MCC |
+|---:|---|---|---:|---:|---:|---:|
+| 1 | HistGradientBoosting | Machine Learning | 0.81 | 0.81 | 0.96 | 0.67 |
+| 2 | TabICL v2 | Deep Learning / Transformer | 0.79 | 0.79 | 0.97 | 0.65 |
+| 3 | TabPFN 2.6 | Deep Learning / Transformer | 0.78 | 0.78 | 0.96 | 0.63 |
+| 4 | XGBoost | Machine Learning | 0.79 | 0.77 | 0.96 | 0.65 |
+| 5 | Bagging | Machine Learning | 0.77 | 0.77 | 0.95 | 0.62 |
+| 6 | KNeighbors | Machine Learning | 0.77 | 0.77 | 0.93 | 0.61 |
+| 7 | LabelPropagation | Machine Learning | 0.77 | 0.77 | 0.93 | 0.61 |
+| 8 | LabelSpreading | Machine Learning | 0.78 | 0.76 | 0.93 | 0.61 |
+| 9 | LightGBM | Machine Learning | 0.78 | 0.76 | 0.96 | 0.64 |
+| 10 | FT Transformer | Deep Learning / Transformer | 0.76 | 0.76 | 0.94 | 0.61 |
+""",
+}
+
+PERFORMANCE_GUIDE_FULL = {
+    "printability": """
+# Printability - Merged Performance Summary
+
+This file contains the aggregated and benchmarked results of traditional Machine Learning (ML) and Deep Learning / Transformer architectures for predicting **Printability**, sorted hierarchically by **F1 Score** and **Accuracy**.
+
+| Rank | Model | Framework | Accuracy | Precision | Recall | F1 | AUC | MCC | Kappa |
+|---:|---|---|---:|---:|---:|---:|---:|---:|---:|
+| 1 | HistGradientBoosting | Machine Learning | 0.80 | 0.80 | 0.80 | 0.80 | 0.94 | 0.69 | 0.69 |
+| 2 | TabPFN 2.6 | Deep Learning / Transformer | 0.80 | 0.81 | 0.80 | 0.80 | 0.94 | 0.69 | 0.68 |
+| 3 | Bagging | Machine Learning | 0.79 | 0.79 | 0.79 | 0.79 | 0.93 | 0.67 | 0.67 |
+| 4 | GradientBoosting | Machine Learning | 0.79 | 0.79 | 0.79 | 0.79 | 0.93 | 0.66 | 0.66 |
+| 5 | TabICL v2 | Deep Learning / Transformer | 0.79 | 0.81 | 0.79 | 0.79 | 0.94 | 0.68 | 0.67 |
+| 6 | XGBoost | Machine Learning | 0.78 | 0.79 | 0.78 | 0.78 | 0.93 | 0.66 | 0.65 |
+| 7 | LightGBM | Machine Learning | 0.77 | 0.78 | 0.77 | 0.77 | 0.93 | 0.64 | 0.64 |
+| 8 | KNeighbors | Machine Learning | 0.77 | 0.78 | 0.77 | 0.77 | 0.90 | 0.64 | 0.64 |
+| 9 | LabelPropagation | Machine Learning | 0.77 | 0.77 | 0.77 | 0.77 | 0.82 | 0.64 | 0.63 |
+| 10 | ExtraTrees | Machine Learning | 0.77 | 0.77 | 0.77 | 0.77 | 0.92 | 0.63 | 0.63 |
+| 11 | MLP | Machine Learning | 0.76 | 0.76 | 0.76 | 0.76 | 0.90 | 0.63 | 0.63 |
+| 12 | LabelSpreading | Machine Learning | 0.76 | 0.76 | 0.76 | 0.76 | 0.90 | 0.62 | 0.62 |
+| 13 | TabNet Lite | Deep Learning / Transformer | 0.74 | 0.74 | 0.74 | 0.74 | 0.91 | 0.59 | 0.59 |
+| 14 | MLP (DL) | Deep Learning / Transformer | 0.73 | 0.73 | 0.73 | 0.73 | 0.91 | 0.58 | 0.58 |
+| 15 | ResNet | Deep Learning / Transformer | 0.73 | 0.73 | 0.73 | 0.73 | 0.91 | 0.57 | 0.57 |
+| 16 | 1D CNN | Deep Learning / Transformer | 0.71 | 0.73 | 0.71 | 0.72 | 0.89 | 0.56 | 0.56 |
+| 17 | DecisionTree | Machine Learning | 0.71 | 0.72 | 0.71 | 0.71 | 0.89 | 0.54 | 0.54 |
+| 18 | NODE Lite | Deep Learning / Transformer | 0.69 | 0.70 | 0.69 | 0.70 | 0.90 | 0.52 | 0.52 |
+| 19 | LinearSVC | Machine Learning | 0.69 | 0.68 | 0.69 | 0.68 | 0.85 | 0.49 | 0.49 |
+| 20 | LDA | Machine Learning | 0.68 | 0.68 | 0.68 | 0.68 | 0.84 | 0.49 | 0.48 |
+| 21 | PassiveAggressive | Machine Learning | 0.69 | 0.68 | 0.69 | 0.67 | 0.85 | 0.48 | 0.48 |
+| 22 | CalibratedClassifierCV | Machine Learning | 0.68 | 0.68 | 0.68 | 0.67 | 0.85 | 0.48 | 0.48 |
+| 23 | LogisticRegression | Machine Learning | 0.68 | 0.67 | 0.68 | 0.67 | 0.85 | 0.47 | 0.47 |
+| 24 | RidgeClassifier | Machine Learning | 0.68 | 0.67 | 0.68 | 0.66 | 0.84 | 0.46 | 0.46 |
+| 25 | FT Transformer | Deep Learning / Transformer | 0.66 | 0.65 | 0.66 | 0.65 | 0.87 | 0.45 | 0.45 |
+| 26 | Perceptron | Machine Learning | 0.67 | 0.68 | 0.67 | 0.64 | 0.84 | 0.45 | 0.42 |
+| 27 | MultinomialNB | Machine Learning | 0.64 | 0.69 | 0.64 | 0.64 | 0.83 | 0.45 | 0.43 |
+| 28 | RadiusNeighbors | Machine Learning | 0.66 | 0.70 | 0.66 | 0.63 | 0.87 | 0.43 | 0.39 |
+| 29 | ComplementNB | Machine Learning | 0.63 | 0.67 | 0.63 | 0.63 | 0.82 | 0.44 | 0.43 |
+| 30 | NuSVC | Machine Learning | 0.60 | 0.69 | 0.60 | 0.61 | 0.84 | 0.45 | 0.42 |
+| 31 | AdaBoost | Machine Learning | 0.62 | 0.59 | 0.62 | 0.58 | 0.80 | 0.38 | 0.37 |
+| 32 | SGD | Machine Learning | 0.63 | 0.59 | 0.63 | 0.57 | 0.82 | 0.36 | 0.35 |
+| 33 | BernoulliNB | Machine Learning | 0.59 | 0.62 | 0.59 | 0.55 | 0.77 | 0.32 | 0.31 |
+| 34 | GaussianNB | Machine Learning | 0.33 | 0.70 | 0.33 | 0.36 | 0.74 | 0.25 | 0.19 |
+| 35 | QDA | Machine Learning | 0.52 | 0.27 | 0.52 | 0.35 | 0.80 | 0.00 | 0.00 |
+| 36 | RandomForest | Machine Learning | 0.52 | 0.27 | 0.52 | 0.35 | 0.78 | 0.00 | 0.00 |
+| 37 | ExtraTreeClassifier | Machine Learning | 0.52 | 0.27 | 0.52 | 0.35 | 0.50 | 0.00 | 0.00 |
+| 38 | DummyClassifier | Machine Learning | 0.52 | 0.27 | 0.52 | 0.35 | 0.50 | 0.00 | 0.00 |
+""",
+    "cell_response": """
+# Cell Response - Merged Performance Summary
+
+This file contains the aggregated and benchmarked results of traditional Machine Learning (ML) and Deep Learning / Transformer architectures for predicting **Cell Response**, sorted hierarchically by **F1 Score** and **Accuracy**.
+
+| Rank | Model | Framework | Accuracy | Precision | Recall | F1 | AUC | MCC | Kappa |
+|---:|---|---|---:|---:|---:|---:|---:|---:|---:|
+| 1 | HistGradientBoosting | Machine Learning | 0.81 | 0.81 | 0.81 | 0.81 | 0.96 | 0.67 | 0.67 |
+| 2 | TabICL v2 | Deep Learning / Transformer | 0.79 | 0.79 | 0.79 | 0.79 | 0.97 | 0.65 | 0.65 |
+| 3 | TabPFN 2.6 | Deep Learning / Transformer | 0.78 | 0.78 | 0.78 | 0.78 | 0.96 | 0.63 | 0.63 |
+| 4 | XGBoost | Machine Learning | 0.79 | 0.76 | 0.79 | 0.77 | 0.96 | 0.65 | 0.64 |
+| 5 | Bagging | Machine Learning | 0.77 | 0.78 | 0.77 | 0.77 | 0.95 | 0.62 | 0.62 |
+| 6 | KNeighbors | Machine Learning | 0.77 | 0.77 | 0.77 | 0.77 | 0.93 | 0.61 | 0.61 |
+| 7 | LabelPropagation | Machine Learning | 0.77 | 0.77 | 0.77 | 0.77 | 0.93 | 0.61 | 0.61 |
+| 8 | LabelSpreading | Machine Learning | 0.78 | 0.76 | 0.78 | 0.76 | 0.93 | 0.61 | 0.61 |
+| 9 | LightGBM | Machine Learning | 0.78 | 0.79 | 0.78 | 0.76 | 0.96 | 0.64 | 0.63 |
+| 10 | FT Transformer | Deep Learning / Transformer | 0.76 | 0.79 | 0.76 | 0.76 | 0.94 | 0.61 | 0.60 |
+| 11 | CalibratedClassifierCV | Machine Learning | 0.76 | 0.76 | 0.76 | 0.75 | 0.94 | 0.59 | 0.59 |
+| 12 | ResNet | Deep Learning / Transformer | 0.76 | 0.76 | 0.76 | 0.75 | 0.94 | 0.59 | 0.59 |
+| 13 | NODE Lite | Deep Learning / Transformer | 0.76 | 0.75 | 0.76 | 0.75 | 0.95 | 0.59 | 0.59 |
+| 14 | 1D CNN | Deep Learning / Transformer | 0.75 | 0.76 | 0.75 | 0.74 | 0.95 | 0.59 | 0.59 |
+| 15 | MLP (DL) | Deep Learning / Transformer | 0.75 | 0.75 | 0.75 | 0.74 | 0.95 | 0.57 | 0.57 |
+| 16 | LDA | Machine Learning | 0.75 | 0.72 | 0.75 | 0.73 | 0.94 | 0.55 | 0.55 |
+| 17 | NuSVC | Machine Learning | 0.74 | 0.73 | 0.74 | 0.73 | 0.95 | 0.55 | 0.55 |
+| 18 | MultinomialNB | Machine Learning | 0.74 | 0.72 | 0.74 | 0.73 | 0.95 | 0.55 | 0.55 |
+| 19 | LogisticRegression | Machine Learning | 0.74 | 0.70 | 0.74 | 0.71 | 0.95 | 0.54 | 0.54 |
+| 20 | LinearSVC | Machine Learning | 0.74 | 0.71 | 0.74 | 0.70 | 0.94 | 0.53 | 0.52 |
+| 21 | Perceptron | Machine Learning | 0.74 | 0.68 | 0.74 | 0.70 | 0.94 | 0.53 | 0.52 |
+| 22 | QDA | Machine Learning | 0.74 | 0.68 | 0.74 | 0.70 | 0.94 | 0.57 | 0.55 |
+| 23 | RidgeClassifier | Machine Learning | 0.73 | 0.70 | 0.73 | 0.70 | 0.94 | 0.52 | 0.51 |
+| 24 | ExtraTrees | Machine Learning | 0.74 | 0.71 | 0.74 | 0.68 | 0.95 | 0.55 | 0.52 |
+| 25 | ExtraTreeClassifier | Machine Learning | 0.73 | 0.67 | 0.73 | 0.68 | 0.91 | 0.54 | 0.52 |
+| 26 | AdaBoost | Machine Learning | 0.74 | 0.65 | 0.74 | 0.67 | 0.91 | 0.59 | 0.55 |
+| 27 | DecisionTree | Machine Learning | 0.74 | 0.65 | 0.74 | 0.67 | 0.92 | 0.59 | 0.55 |
+| 28 | RandomForest | Machine Learning | 0.74 | 0.65 | 0.74 | 0.67 | 0.92 | 0.59 | 0.55 |
+| 29 | GradientBoosting | Machine Learning | 0.74 | 0.65 | 0.74 | 0.67 | 0.92 | 0.59 | 0.55 |
+| 30 | SGD | Machine Learning | 0.71 | 0.65 | 0.71 | 0.66 | 0.92 | 0.49 | 0.47 |
+| 31 | MLP | Machine Learning | 0.73 | 0.61 | 0.73 | 0.65 | 0.93 | 0.55 | 0.52 |
+| 32 | PassiveAggressive | Machine Learning | 0.73 | 0.65 | 0.73 | 0.65 | 0.92 | 0.52 | 0.49 |
+| 33 | ComplementNB | Machine Learning | 0.72 | 0.65 | 0.72 | 0.65 | 0.93 | 0.49 | 0.47 |
+| 34 | TabNet Lite | Deep Learning / Transformer | 0.70 | 0.67 | 0.70 | 0.65 | 0.93 | 0.48 | 0.46 |
+| 35 | BernoulliNB | Machine Learning | 0.71 | 0.60 | 0.71 | 0.63 | 0.93 | 0.48 | 0.45 |
+| 36 | RadiusNeighbors | Machine Learning | 0.60 | 0.36 | 0.60 | 0.45 | 0.50 | 0.00 | 0.00 |
+| 37 | DummyClassifier | Machine Learning | 0.60 | 0.36 | 0.60 | 0.45 | 0.50 | 0.00 | 0.00 |
+| 38 | GaussianNB | Machine Learning | 0.28 | 0.69 | 0.28 | 0.34 | 0.84 | 0.18 | 0.14 |
+""",
+}
+
+GEMINI_MODELS = [
+    "gemini-3.5-flash",
+    "gemini-3.1-flash-lite",
+    "gemini-3.1-pro-preview",
+    "gemini-3.1-flash-lite-preview",
+    "gemini-3-flash-preview",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+]
 
 def scaffold_quality_combined(printability, cell_response, 
                               weight_printability=0.3, weight_cell_response=0.7):
@@ -79,28 +264,342 @@ PRINT_PARAM_NAMES = [
 ]
 
 @st.cache_resource
-def load_encoder():
-    return joblib.load('cell_line_encoder.joblib')
+def load_prediction_preprocessors():
+    return {
+        "preprocessor": joblib.load(PREPROCESSOR_DIR / "preprocessor.pkl"),
+        "feature_cols": joblib.load(PREPROCESSOR_DIR / "feature_cols.pkl"),
+        "printability_encoder": joblib.load(PREPROCESSOR_DIR / MODEL_TASKS["printability"]["label_encoder"]),
+        "cell_response_encoder": joblib.load(PREPROCESSOR_DIR / MODEL_TASKS["cell_response"]["label_encoder"]),
+    }
+
+def model_display_name(path, prefix):
+    name = path.stem.replace("_model", "")
+    if name.startswith(prefix):
+        name = name[len(prefix):]
+    return f"{name} ({path.suffix.lstrip('.')})"
+
+def model_rank_key(display_name, task_key):
+    base_name = display_name.rsplit(" (", 1)[0]
+    rank_aliases = {
+        "1D_CNN": "1D CNN",
+        "FT_Transformer": "FT Transformer",
+        "NODE_Lite": "NODE Lite",
+        "TabNet_Lite": "TabNet Lite",
+        "TabPFN_2.6": "TabPFN 2.6",
+        "TabICL_v2": "TabICL v2",
+        "ExtraTree": "ExtraTreeClassifier",
+    }
+    rank_name = rank_aliases.get(base_name, base_name)
+    if base_name == "MLP" and display_name.endswith("(pth)"):
+        rank_name = "MLP DL"
+    ranking = MODEL_RANKINGS[task_key]
+    rank = ranking.index(rank_name) if rank_name in ranking else len(ranking)
+    return rank, base_name.lower(), display_name
+
+def discover_model_options(task_key):
+    task = MODEL_TASKS[task_key]
+    files = []
+    for suffix in ("*.pkl", "*.joblib", "*.pth"):
+        files.extend(task["folder"].glob(suffix))
+    options = {model_display_name(path, task["prefix"]): str(path) for path in files}
+    return dict(sorted(options.items(), key=lambda item: model_rank_key(item[0], task_key)))
+
+def parse_architecture(path, task_key):
+    stem = Path(path).stem.replace("_model", "")
+    prefix = MODEL_TASKS[task_key]["prefix"]
+    return stem[len(prefix):] if stem.startswith(prefix) else stem
+
+def build_torch_model(architecture, input_dim, out_dim, cfg):
+    import torch
+    import torch.nn as nn
+
+    activation_funcs = {
+        "relu": nn.ReLU, "tanh": nn.Tanh, "GELU": nn.GELU,
+        "SELU": nn.SELU, "ELU": nn.ELU, "SiLU": nn.SiLU,
+    }
+    act = activation_funcs[cfg["activation_func"]]
+
+    class ResidualBlock(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.linear = nn.Linear(cfg["hidden_dim"], cfg["hidden_dim"])
+            self.bn = nn.BatchNorm1d(cfg["hidden_dim"])
+            self.act = act()
+            self.dropout = nn.Dropout(cfg["dropout"])
+        def forward(self, x):
+            return x + self.dropout(self.act(self.bn(self.linear(x))))
+
+    class TissueResNet(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.input_layer = nn.Sequential(
+                nn.Linear(input_dim, cfg["hidden_dim"]),
+                nn.BatchNorm1d(cfg["hidden_dim"]),
+                act(),
+            )
+            self.blocks = nn.ModuleList([ResidualBlock() for _ in range(cfg["n_layers"])])
+            self.output_layer = nn.Linear(cfg["hidden_dim"], out_dim)
+        def forward(self, x):
+            x = self.input_layer(x)
+            for block in self.blocks:
+                x = block(x)
+            return self.output_layer(x)
+
+    class StandardMLP(nn.Module):
+        def __init__(self):
+            super().__init__()
+            layers = []
+            in_dim = input_dim
+            for _ in range(cfg["n_layers"]):
+                layers.extend([
+                    nn.Linear(in_dim, cfg["hidden_dim"]),
+                    nn.BatchNorm1d(cfg["hidden_dim"]),
+                    act(),
+                    nn.Dropout(cfg["dropout"]),
+                ])
+                in_dim = cfg["hidden_dim"]
+            layers.append(nn.Linear(cfg["hidden_dim"], out_dim))
+            self.network = nn.Sequential(*layers)
+        def forward(self, x):
+            return self.network(x)
+
+    class Tabular1DCNN(nn.Module):
+        def __init__(self):
+            super().__init__()
+            layers = []
+            in_channels = 1
+            for _ in range(cfg["n_layers"]):
+                layers.extend([
+                    nn.Conv1d(in_channels, cfg["hidden_dim"], kernel_size=3, padding=1),
+                    nn.BatchNorm1d(cfg["hidden_dim"]),
+                    act(),
+                    nn.Dropout(cfg["dropout"]),
+                ])
+                in_channels = cfg["hidden_dim"]
+            self.conv_net = nn.Sequential(*layers)
+            self.pool = nn.AdaptiveAvgPool1d(1)
+            self.fc = nn.Linear(cfg["hidden_dim"], out_dim)
+        def forward(self, x):
+            x = self.conv_net(x.unsqueeze(1))
+            return self.fc(self.pool(x).squeeze(2))
+
+    class FTTransformer(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.d_token = max(4, (cfg["hidden_dim"] // 4) * 4)
+            self.feature_embeddings = nn.ModuleList([nn.Linear(1, self.d_token) for _ in range(input_dim)])
+            self.cls_token = nn.Parameter(torch.randn(1, 1, self.d_token))
+            encoder_layer = nn.TransformerEncoderLayer(
+                d_model=self.d_token, nhead=4, dropout=cfg["dropout"], batch_first=True
+            )
+            self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=cfg["n_layers"])
+            self.fc = nn.Linear(self.d_token, out_dim)
+        def forward(self, x):
+            batch_size = x.size(0)
+            tokens = [self.feature_embeddings[i](x[:, i:i+1]).unsqueeze(1) for i in range(x.size(1))]
+            x_emb = torch.cat([self.cls_token.expand(batch_size, -1, -1)] + tokens, dim=1)
+            return self.fc(self.transformer(x_emb)[:, 0, :])
+
+    class TabNetLite(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.n_steps = max(1, cfg["n_layers"])
+            self.initial_bn = nn.BatchNorm1d(input_dim)
+            self.transformers = nn.ModuleList([
+                nn.Sequential(
+                    nn.Linear(input_dim, cfg["hidden_dim"]),
+                    nn.BatchNorm1d(cfg["hidden_dim"]),
+                    act(),
+                    nn.Dropout(cfg["dropout"]),
+                )
+                for _ in range(self.n_steps)
+            ])
+            self.attentions = nn.ModuleList([
+                nn.Sequential(
+                    nn.Linear(cfg["hidden_dim"], input_dim),
+                    nn.BatchNorm1d(input_dim),
+                    nn.Softmax(dim=-1),
+                )
+                for _ in range(self.n_steps)
+            ])
+            self.fc_out = nn.Linear(cfg["hidden_dim"], out_dim)
+        def forward(self, x):
+            x = self.initial_bn(x)
+            out_agg, prior = 0, torch.ones_like(x)
+            feat_rep = self.transformers[0](x)
+            for step in range(self.n_steps):
+                mask = self.attentions[step](feat_rep) * prior
+                prior = prior * (1.0 - mask)
+                feat_rep = self.transformers[step](x * mask)
+                out_agg += feat_rep
+            return self.fc_out(out_agg)
+
+    class NeuralDecisionForest(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.n_trees = max(1, cfg["hidden_dim"] // 16)
+            self.depth = max(2, cfg["n_layers"] + 1)
+            self.n_leaves = 2 ** self.depth
+            self.trees = nn.ModuleList([
+                nn.Sequential(
+                    nn.Linear(input_dim, self.n_leaves),
+                    nn.Dropout(cfg["dropout"]),
+                    nn.Softmax(dim=-1),
+                )
+                for _ in range(self.n_trees)
+            ])
+            self.leaf_weights = nn.Parameter(torch.randn(self.n_trees, self.n_leaves, out_dim))
+        def forward(self, x):
+            out = 0
+            for i, tree in enumerate(self.trees):
+                out += torch.matmul(tree(x), self.leaf_weights[i])
+            return out / self.n_trees
+
+    builders = {
+        "ResNet": TissueResNet,
+        "MLP": StandardMLP,
+        "1D_CNN": Tabular1DCNN,
+        "FT_Transformer": FTTransformer,
+        "TabNet_Lite": TabNetLite,
+        "NODE_Lite": NeuralDecisionForest,
+    }
+    return builders[architecture]()
 
 @st.cache_resource
-def load_scalers():
-    return (
-        joblib.load('scaler_printability.joblib'),
-        joblib.load('scaler_cell_response.joblib')
+def load_prediction_model(path, task_key, input_dim, out_dim):
+    path = Path(path)
+    if path.suffix in {".pkl", ".joblib"}:
+        return {"kind": "sklearn", "model": joblib.load(path)}
+
+    if path.suffix == ".pth":
+        import torch
+        architecture = parse_architecture(path, task_key)
+        cfg = DL_MODEL_CONFIGS.get((task_key, architecture))
+        if cfg is None:
+            raise ValueError(f"No architecture configuration found for {path.name}.")
+        model = build_torch_model(architecture, input_dim, out_dim, cfg)
+        state_dict = torch.load(path, map_location="cpu")
+        model.load_state_dict(state_dict)
+        model.eval()
+        return {"kind": "torch", "model": model}
+
+    raise ValueError(f"Unsupported model file: {path.name}")
+
+def softmax(values):
+    values = np.asarray(values, dtype=float)
+    values = values - np.max(values)
+    exp_values = np.exp(values)
+    return exp_values / exp_values.sum()
+
+def expected_class_value(model_bundle, x_raw, preprocessor, label_encoder):
+    x_model = preprocessor.transform(x_raw).astype(np.float32)
+
+    if model_bundle["kind"] == "torch":
+        import torch
+        with torch.no_grad():
+            logits = model_bundle["model"](torch.tensor(x_model, dtype=torch.float32)).numpy()[0]
+        probs = softmax(logits)
+        labels = label_encoder.classes_.astype(float)
+        return float(np.dot(probs, labels))
+
+    model = model_bundle["model"]
+    if hasattr(model, "predict_proba"):
+        probs = model.predict_proba(x_model)[0]
+        classes = np.asarray(model.classes_, dtype=int)
+        labels = label_encoder.inverse_transform(classes).astype(float)
+        return float(np.dot(probs, labels))
+
+    if hasattr(model, "decision_function"):
+        scores = np.asarray(model.decision_function(x_model)[0])
+        if scores.ndim == 0:
+            p_high = 1.0 / (1.0 + np.exp(-scores))
+            probs = np.array([1.0 - p_high, p_high])
+        else:
+            probs = softmax(scores)
+        classes = np.asarray(model.classes_, dtype=int)
+        labels = label_encoder.inverse_transform(classes).astype(float)
+        return float(np.dot(probs, labels))
+
+    pred = np.asarray(model.predict(x_model), dtype=int)
+    return float(label_encoder.inverse_transform(pred)[0])
+
+prediction_assets = load_prediction_preprocessors()
+preprocessor = prediction_assets["preprocessor"]
+feature_cols = prediction_assets["feature_cols"]
+label_encoder_print = prediction_assets["printability_encoder"]
+label_encoder_cell = prediction_assets["cell_response_encoder"]
+
+sample_for_shape = {col: 0.0 for col in feature_cols}
+sample_for_shape["Cell Line"] = CELL_LINE_OPTIONS[0]
+preprocessed_input_dim = preprocessor.transform(pd.DataFrame([sample_for_shape])[feature_cols]).shape[1]
+
+@st.dialog("Optimization Trials")
+def show_trial_guidance():
+    st.markdown(
+        """
+        The trial count controls how many candidate scaffold settings Optuna tests before choosing the best WSSQ.
+
+        **Recommended range:** 100-1000 trials.
+
+        **Default:** 300 trials, which is a balanced choice for normal use.
+
+        **Runtime impact:** running time grows roughly in proportion to the number of trials. Use 50-100 for a quick test, 300 for a balanced run, and 500-1000 when you want a more thorough search and can wait longer.
+        """
     )
 
-@st.cache_resource
-def load_models():
-    m_p = CatBoostClassifier(); m_p.load_model('catboost_printability.cbm')
-    m_c = CatBoostClassifier(); m_c.load_model('catboost_cell_response.cbm')
-    return m_p, m_c
+@st.dialog("Weighted Synergistic Scaffold Quality (WSSQ)")
+def show_wssq_guidance():
+    st.markdown(
+        """
+        WSSQ is the optimization score used in MLATE to combine **printability** and **cell response** into one scaffold-quality objective.
+
+        In the manuscript, WSSQ was introduced to handle two practical needs: acellular 3D-printed scaffolds, where cell response is not applicable in the same way, and bioprinted scaffolds, where biological response is central to scaffold quality. Cell response is weighted strongly because it reflects explicit biological outcomes and also indirectly captures scaffold physical and mechanical properties such as pore structure, interconnectivity, elasticity, and compressive behavior.
+
+        The app normalizes printability and cell response, then combines them using two components:
+
+        - **Weighted harmonic mean:** rewards balanced high values and penalizes weak performance in either target.
+        - **Weighted multiplicative component:** captures synergy between printability and cell response.
 
-encoder          = load_encoder()
-scaler_print, scaler_cell = load_scalers()
-model_print,   model_cell = load_models()
+        The final WSSQ is scaled from 0 to 100%. If printability is 0, WSSQ is 0. If cell response is at the minimum biological-response level, the score falls back to normalized printability. Otherwise, both targets contribute according to the sidebar weights.
 
-feature_order_print = list(scaler_print.feature_names_in_)
-feature_order_cell  = list(scaler_cell.feature_names_in_)
+        Practically, a scaffold with excellent cell response but poor printability can score lower than a scaffold with slightly lower cell response but better balance, because WSSQ is designed to favor experimentally useful, well-balanced scaffold candidates.
+        """
+    )
+
+@st.dialog("Model Selection Guide", width="large")
+def show_model_selection_guidance():
+    st.markdown(
+        """
+        Models are sorted by the merged benchmark summaries you provided, using F1 score and accuracy as the main ranking criteria. The highest-ranked available model appears first in each dropdown.
+
+        Use the top-ranked models when you want the strongest benchmarked predictive performance. If a selected model fails to load because of local package-version incompatibility, choose the next ranked model in the same task until the environment is aligned with the model artifacts.
+        """
+    )
+    tab_print, tab_cell = st.tabs(["Printability", "Cell Response"])
+    with tab_print:
+        st.markdown(PERFORMANCE_GUIDE["printability"])
+        with st.expander("Show more"):
+            st.markdown(PERFORMANCE_GUIDE_FULL["printability"])
+    with tab_cell:
+        st.markdown(PERFORMANCE_GUIDE["cell_response"])
+        with st.expander("Show more"):
+            st.markdown(PERFORMANCE_GUIDE_FULL["cell_response"])
+
+@st.dialog("How to Get a Gemini API Key")
+def show_gemini_api_key_guidance():
+    st.markdown(
+        """
+        To generate a fabrication procedure, you need a Gemini API key from Google. Creating a key only takes a minute, and Google provides a free tier.
+
+        1. Open [Google AI Studio API Keys](https://aistudio.google.com/app/apikey) and sign in with your Google/Gmail account if prompted.
+        2. If this is your first visit, accept the terms of service and continue.
+        3. Click **Get API key** or **Create API key**.
+        4. Choose an existing Google Cloud project, or select **Create API key in new project**.
+        5. Copy the generated key, return to this app, and paste it into the **Gemini API Key** box.
+
+        **Important:** Treat your API key like a password. Do not share it publicly or paste it into files that will be uploaded online. This app uses your key only for the current protocol generation request and does not save it.
+        """
+    )
 
 if 'bio_rows' not in st.session_state:
     st.session_state.bio_rows = [{
@@ -129,11 +628,60 @@ w_cell_pct = st.sidebar.slider("Cell Response Weight (%)", min_value=0, max_valu
 # Printability is dynamically calculated and cannot be changed manually
 w_print_pct = 100 - w_cell_pct
 st.sidebar.number_input("Printability Weight (%)", value=w_print_pct, disabled=True, help="Auto-calculated to ensure sum is 100%")
+if st.sidebar.button("What is WSSQ?", use_container_width=True):
+    show_wssq_guidance()
 
 # Convert back to 0.0 - 1.0 for the mathematical formula
 w_cell = w_cell_pct / 100.0
 w_print = w_print_pct / 100.0
 
+print_model_options = discover_model_options("printability")
+cell_model_options = discover_model_options("cell_response")
+
+if not print_model_options or not cell_model_options:
+    st.error("No selectable prediction models were found in the models folder.")
+    st.stop()
+
+selected_print_model_name = st.sidebar.selectbox(
+    "Printability Model",
+    list(print_model_options.keys()),
+    key="printability_model_select",
+)
+selected_cell_model_name = st.sidebar.selectbox(
+    "Cell Response Model",
+    list(cell_model_options.keys()),
+    key="cell_response_model_select",
+)
+if st.sidebar.button("Model Selection Guide", use_container_width=True):
+    show_model_selection_guidance()
+
+n_trials = st.sidebar.number_input(
+    "Optimization Trials",
+    min_value=10,
+    max_value=10000,
+    value=300,
+    step=50,
+    help="Number of Optuna trials used when you click Optimize WSSQ.",
+)
+if st.sidebar.button("Trial Count Help", use_container_width=True):
+    show_trial_guidance()
+
+gemini_key = st.sidebar.text_input(
+    "Gemini API Key",
+    value=os.getenv("GEMINI_API_KEY", ""),
+    type="password",
+    help="Used only when generating the LLM-based fabrication procedure.",
+)
+if st.sidebar.button("How to Get API Key", use_container_width=True):
+    show_gemini_api_key_guidance()
+
+gemini_model = st.sidebar.selectbox(
+    "Gemini Model",
+    GEMINI_MODELS,
+    index=0,
+    key="gemini_model_select",
+)
+
 st.title("MLATE: Machine Learning Applications in Tissue Engineering")
 st.markdown(
     "<p style='font-size:1.2em; color:grey;'>"
@@ -162,9 +710,10 @@ for i, row in enumerate(st.session_state.bio_rows):
 
     c1, c2, c3, c4, c5 = st.columns([2, 1, 1, 1, 0.3])
     mat = c1.selectbox(
-        "", options,
+        "Biomaterial", options,
         index=options.index(row['mat']) if row['mat'] in options else 0,
-        key=f"bio_mat_{i}"
+        key=f"bio_mat_{i}",
+        label_visibility="collapsed",
     )
     st.session_state.bio_rows[i]['mat'] = mat
 
@@ -299,6 +848,28 @@ st.markdown("---")
 
 if st.button("Optimize WSSQ"):
     with st.spinner("Running Optuna…"):
+        try:
+            model_print = load_prediction_model(
+                print_model_options[selected_print_model_name],
+                "printability",
+                preprocessed_input_dim,
+                len(label_encoder_print.classes_),
+            )
+            model_cell = load_prediction_model(
+                cell_model_options[selected_cell_model_name],
+                "cell_response",
+                preprocessed_input_dim,
+                len(label_encoder_cell.classes_),
+            )
+        except Exception as exc:
+            st.error(
+                "Could not load the selected prediction model. This model will only work when the "
+                "running environment matches the saved artifact dependencies. For HistGradientBoosting, "
+                "use numpy>=2.0 in the Python environment that runs Streamlit.\n\n"
+                f"Details:\n{exc}"
+            )
+            st.stop()
+
         def objective(trial):
             bi_vals = {
                 r['mat']: trial.suggest_float(
@@ -325,19 +896,12 @@ if st.button("Optimize WSSQ"):
 
             feat = {**bi_vals, **pp_vals}
             feat["Cell Density (cells/mL)"] = cd
-            feat.update(
-                encoder.transform(pd.DataFrame({"Cell Line":[cell_line]}))
-                       .iloc[0].to_dict()
-            )
+            feat["Cell Line"] = cell_line
 
-            X = pd.DataFrame([feat])
-            Xp = X.reindex(columns=feature_order_print, fill_value=0.0)
-            Xc = X.reindex(columns=feature_order_cell,  fill_value=0.0)
+            X = pd.DataFrame([feat]).reindex(columns=feature_cols, fill_value=0.0)
 
-            p_proba = model_print.predict_proba(scaler_print.transform(Xp))[0]
-            c_proba = model_cell .predict_proba(scaler_cell .transform(Xc))[0]
-            exp_p = float(np.dot(p_proba, model_print.classes_.astype(float)))
-            exp_c = float(np.dot(c_proba, model_cell .classes_.astype(float)))
+            exp_p = expected_class_value(model_print, X, preprocessor, label_encoder_print)
+            exp_c = expected_class_value(model_cell, X, preprocessor, label_encoder_cell)
 
             np.random.seed(42)
             # Use dynamic weights from the sidebar sliders
@@ -361,7 +925,7 @@ if st.button("Optimize WSSQ"):
             sampler=sampler,
             pruner=optuna.pruners.MedianPruner()
         )
-        study.optimize(objective, n_trials=1000)
+        study.optimize(objective, n_trials=int(n_trials))
         
         # Store results in session state to persist after rerun
         st.session_state.best_params = study.best_trial.params
@@ -384,7 +948,12 @@ if 'best_params' in st.session_state:
     )
 
     if st.button("Generate Fabrication Procedure"):
+        if not gemini_key:
+            st.error("Please enter your Gemini API key in the sidebar before generating a fabrication procedure.")
+            st.stop()
+
         with st.spinner("Generating rigorous fabrication procedure…"):
+            client = genai.Client(api_key=gemini_key)
             
             formatted_params = "\n".join([
                 f"- {k.replace('bio__', 'Biomaterial: ').replace('pp__', 'Print Setting: ')}: {v:.2f}"
@@ -422,7 +991,7 @@ if 'best_params' in st.session_state:
                 final_prompt += f"\n**Additional User Constraints & Inquiries (Integrate these into the protocol):**\n{user_inquiry}"
 
             resp = client.models.generate_content(
-                model="gemini-2.5-flash-lite",
+                model=gemini_model,
                 contents=final_prompt,
                 config=types.GenerateContentConfig(
                     system_instruction=(
@@ -440,4 +1009,4 @@ if 'best_params' in st.session_state:
             )
 
             st.markdown("## Fabrication Procedure")
-            st.markdown(resp.text)
+            st.markdown(resp.text)

catboost_printability.cbm → models/cell response/Cell_Response_1D_CNN_model.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3c0a21e8657aa8d990f62750f9a8342227ba51ec7f02136a8882069ba7a64952
-size 81574688
+oid sha256:f70717cc4444f97c2e20465a4c8b9f845bdc2daf9c202940f93eead164cff4b0
+size 1113045

models/cell response/Cell_Response_AdaBoost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b48ae05ebd1292beb4fa80c174e604dcc59ec1d110ef6b10e58e52e014af34eb
+size 209772

models/cell response/Cell_Response_Bagging.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a675e99d706e3a0d067f763561e07d47070784c176ee8d62aef57dc6fcce1b2b
+size 1589916

cell_line_encoder.joblib → models/cell response/Cell_Response_BernoulliNB.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8c62b2bc4682c3e67f364511201060dea195f93ed9ff90bd930a1443cc3aa73d
-size 25655
+oid sha256:d255aa6a97b9eb85ba154f09059fef319931e3a68ef5f05cac63d9b96cde8304
+size 11919

models/cell response/Cell_Response_CalibratedClassifierCV.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34ef9c42687fa42a0f81b24823e4325e4b1ee8422422317492400ae6d07336ed
+size 10412

models/cell response/Cell_Response_ComplementNB.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4fc2165c356f1c0c1cfdcf9ad01dad9a552cef4706b359f49d9ccc70d4402b4
+size 13071

scaler_printability.joblib → models/cell response/Cell_Response_DecisionTree.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0f5c37a1cb5bd29c1a4fb868808e305545c4930b31a22e25e8e7271e861fe1a4
-size 7703
+oid sha256:22469b5cc3c669706f3bd5b96379f8d26fecf478f7867f2df2cada910c1beb87
+size 1649

scaler_cell_response.joblib → models/cell response/Cell_Response_DummyClassifier.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0e8ad571c0a19952513271331ff8140a64eff4325c0b5d11f702ffca2c38a8c9
-size 7703
+oid sha256:5c2d13a951982709550ec71eebb9e0585ed02165280b8e08587b8229ca683094
+size 639

models/cell response/Cell_Response_ExtraTree.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecf6cfe975b9bae1fd67796f9754f24837f7691e99cb976bf38f3a4db9b56592
+size 2705

models/cell response/Cell_Response_ExtraTrees.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a7989a7733d5013777e20972c8d233f1719d93b23bd33c490a36e49a1dbd7a1
+size 793841

catboost_cell_response.cbm → models/cell response/Cell_Response_FT_Transformer_model.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d8eeb02258c9780147ea7e4030757f3ba7d4d80b7530f74cff79cd3e0481c23e
-size 98406080
+oid sha256:e9f9c7750f1594daaf0c36f722814b030b23bd5a12b899e2b4d912954f3761c9
+size 45076412

models/cell response/Cell_Response_GaussianNB.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:835125ad7ffce8a24e8a89ac6af4e94108e69e262301e40f2aac9e0d0c872d48
+size 11935

models/cell response/Cell_Response_GradientBoosting.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06c095734b4c2ab779f369987cd8fce7dc0ae0fed22413a0879d0aa021f9f933
+size 481962

models/cell response/Cell_Response_HistGradientBoosting.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d53b8bdb8a5137461c4be6f5bb7b9c60e8c3ad9376c1fda18a8edd52a7dc7c57
+size 1010734

models/cell response/Cell_Response_KNeighbors.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60c934e5877f0524bf1d13683e3ae339182a212b71f0b2017233d0ebcc4bb876
+size 3548502

models/cell response/Cell_Response_LDA.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:596c41b26b585f7eb520520eec27589a990e7f0c8a6d7623423cb8d872b2eef4
+size 9443

models/cell response/Cell_Response_LabelPropagation.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:136a5ca830e55a3fae9b097afc121b276294a43822f2c50c78ca755c0fbab98a
+size 2347800

models/cell response/Cell_Response_LabelSpreading.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:248ea1f34e286c939f3d81b7e0a983db48b7ee88f3c08bede2729f2650143892
+size 1223023

models/cell response/Cell_Response_LightGBM.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe1a7ac9c25508dcf5639cf64d3286e1b9f752debf16bd1875b44b5091cc0491
+size 1552684

models/cell response/Cell_Response_LinearSVC.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4dbdfc34b36b5385c39dd31bb5fdde824616bc1357661ced6704b34d802d11db
+size 37964

models/cell response/Cell_Response_LogisticRegression.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e609d345c492bb68e9c9fbda8ef9b0acb73b8beebd212d515b7c23be01502f35
+size 6447

models/cell response/Cell_Response_MLP.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a17c1d1e68a25074f87f836ff8726943b146ca62be9f683b6cfc487332792a9f
+size 1244052

models/cell response/Cell_Response_MLP_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51d34e040f5681704b3119c04b9b08881cb72b1e6c9799c39b99e7158016d4bf
+size 1079652

models/cell response/Cell_Response_MultinomialNB.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c770fa8292e9027fd90cd81196c746e294143dc0c6a2256185d640ac6a740264
+size 11903

models/cell response/Cell_Response_NODE_Lite_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfea4e05557355a92e031f2329be19b5e90f19f913a30d6a5a3f33f0c879f073
+size 38724

models/cell response/Cell_Response_NuSVC.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17fe9887f6e6b3406b79b83dc20fbb9e04049de61d360c3c7c5c5492f509a233
+size 932687

models/cell response/Cell_Response_PassiveAggressive.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8113b6af5e28e93e3ce83f0a85ecac45f4dde7d543c002377493786734e47f5
+size 22764

models/cell response/Cell_Response_Perceptron.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1c0ce5c5425f9974624eeb2821dd6981a945b4d7dbd1521175ce4d2445aa14a
+size 22748

models/cell response/Cell_Response_QDA.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3d0300d01053acde77c9f0c79aa5ae385349b9f5e6666609a78a3d463f4b415
+size 367160

models/cell response/Cell_Response_RadiusNeighbors.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bfda1acdc5fb36f1b40dc04c955c652fccc5a66f32027534dcd69e4c6635341
+size 3479055

models/cell response/Cell_Response_RandomForest.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f3053956b46b8d0c74a52b6ac0f13aeb8ac74b56b7c2c0dd5bb872256ce883a
+size 332673

models/cell response/Cell_Response_ResNet_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:944e1b741ee964877bab40fd94e54b9be1164677c99d4132516fad76f2a2a30f
+size 1352549

models/cell response/Cell_Response_RidgeClassifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37db18fde6d0e4cc43d048d12457cf16c505b81fe2e4f8e88a8a3fdb35704f12
+size 21148

models/cell response/Cell_Response_SGD.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15d2ee2711131ff81259d756689f3b2c4eed4d4aa612df08d8dfca8dfb6aa908
+size 3987

models/cell response/Cell_Response_TabICL_v2.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34f5f68afdd324c18901a6aec64662fa3049992b46f0bfafd0c4e7f33a0ecb43
+size 3595929

models/cell response/Cell_Response_TabNet_Lite_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5390d355028d8c9dc10810517e8622ae24a6ec568a706b01ab63cf2d71da7e5
+size 1973188

models/cell response/Cell_Response_TabPFN_2.6.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e94ae36afa55bf2d92253ab3a41fe75967e741a40c20af4cfc4f0d5be1be69e4
+size 1212783

models/cell response/Cell_Response_XGBoost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:483ecf0b6d7e3cf90ad1e31859ad5d7de77c67379c5574df79d9da823a5e96c3
+size 1735817

models/preprocessors/feature_cols.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3a045e40d698347d8b260e980d4271c50bbe5c7dd0e14363f5d3ec734b17e8a
+size 2841

models/preprocessors/label_encoder_cell_response.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8dee86699c0433019442cd223b7bbe83c27dc5097d3942aa128c5b1eec17da59
+size 367

models/preprocessors/label_encoder_printability.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee6eddf5091c4429a1ad40759cb7cc49ff5a3acb4450f529359c058eefc0771c
+size 359

models/preprocessors/preprocessor.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9d91db4db191c3eb411f99a5f82a12f1f044c85f4a0e7096010b1cf70a27a02
+size 38481

models/printability/Printability_1D_CNN_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b96f399e3e548ce7f0b815f2092ede680ecbdbe96617b81f2335b0d548b0632c
+size 5000675

models/printability/Printability_AdaBoost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6283ac39e40e3234c153a7241367781316c31c1aefa2e0501edcc17679a40efb
+size 168308

models/printability/Printability_Bagging.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58a1b12b467887c97da2d278778bce5504d203d1746b492feaa6ed0bd3c845e4
+size 11463188

models/printability/Printability_BernoulliNB.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:518379522054a43fc6fe7140901e6944728b50833069a57a3ce32a1f7a3b36ab
+size 9687

models/printability/Printability_CalibratedClassifierCV.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:229166fe376a8809f5618f56d85b08212c8be0d4d8047db22aeaeaec3905beeb
+size 41268

models/printability/Printability_ComplementNB.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca825ba4811afa56f0bc8e7a71230897ae16a5e562fb1cdf582d94875b69f334
+size 10839