fix: downgrade tabpfn to 0.1.11, class-level weight cache, fix ravel on list

code/models/tabpfn_wrapper.py

@@ -78,6 +78,10 @@ class TabPFNWrapper(BaseModelWrapper):
         Random seed
     """
 
+    # Class-level cache: weights are loaded once and shared across ALL instances
+    # in the same process. This prevents reloading 103 weight files on every CV fold.
+    _shared_classifier = None
+
     def __init__(
         self,
         task_type: str = 'classification',
@@ -96,18 +100,6 @@ class TabPFNWrapper(BaseModelWrapper):
     def fit(self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray]) -> 'TabPFNWrapper':
         """
         Fit TabPFN (stores training data for in-context learning).
-
-        Parameters
-        ----------
-        X : pd.DataFrame or np.ndarray, shape (n_samples, n_features)
-            Training features (max 1000 samples, 100 features)
-        y : pd.Series or np.ndarray, shape (n_samples,)
-            Training target
-
-        Returns
-        -------
-        self : TabPFNWrapper
-            Fitted model
         """
         self._validate_input(X, y)
 
@@ -145,32 +137,31 @@ class TabPFNWrapper(BaseModelWrapper):
 
             import torch
             import tabpfn
-            
+
             actual_device = 'cuda' if (self.device == 'auto' and torch.cuda.is_available()) else ('cpu' if self.device == 'auto' else self.device)
-            
-            # Reuse a cached classifier if one was injected to avoid reloading weights
-            if hasattr(self, '_cached_classifier') and self._cached_classifier is not None:
-                self.model = self._cached_classifier
-                logger.info("Reusing cached TabPFN classifier (skipping weight reload)")
-            else:
+
+            # Reuse class-level cached classifier so weights are only loaded ONCE
+            # per process, not once per CV fold.
+            if TabPFNWrapper._shared_classifier is None:
+                logger.info("Creating new TabPFNClassifier and caching at class level...")
                 if hasattr(tabpfn, '__version__') and tabpfn.__version__.startswith('0.1'):
-                    self.model = TabPFNClassifier(device=actual_device, N_ensemble_configurations=self.n_ensemble)
+                    TabPFNWrapper._shared_classifier = TabPFNClassifier(
+                        device=actual_device,
+                        N_ensemble_configurations=self.n_ensemble
+                    )
                 else:
-                    self.model = TabPFNClassifier(device=actual_device)
-                
-                # Store in global cache for future reuse
-                try:
-                    import benchmark
-                    benchmark._TABPFN_CACHED_MODEL = self.model
-                except (ImportError, AttributeError):
-                    try:
-                        import webapp.benchmark as wb
-                        wb._TABPFN_CACHED_MODEL = self.model
-                    except (ImportError, AttributeError):
-                        pass
-
-            # Fit model
-            self.model.fit(X, y)
+                    TabPFNWrapper._shared_classifier = TabPFNClassifier(device=actual_device)
+            else:
+                logger.info("Reusing cached TabPFN classifier (weights NOT reloaded).")
+
+            self.model = TabPFNWrapper._shared_classifier
+
+            # Fit — for v0.1.x, overwrite_warning=True suppresses the data size warning
+            try:
+                self.model.fit(X, y, overwrite_warning=True)
+            except TypeError:
+                # v2+ doesn't accept overwrite_warning kwarg
+                self.model.fit(X, y)
 
             self.is_fitted = True
             self.fit_time = time.time() - start_time

webapp/benchmark.py

@@ -63,15 +63,10 @@ def _tabpfn(task):
     if task != "classification":
         raise ValueError("TabPFN only supports classification tasks")
     from models.tabpfn_wrapper import TabPFNWrapper
-    wrapper = TabPFNWrapper(task_type=task, random_state=RAND)
-    # Re-use the cached TabPFNClassifier model if available to avoid
-    # reloading weights on every CV fold (saves ~2s per fold + RAM)
-    global _TABPFN_CACHED_MODEL
-    if _TABPFN_CACHED_MODEL is not None:
-        wrapper._cached_classifier = _TABPFN_CACHED_MODEL
-    return wrapper
-
-_TABPFN_CACHED_MODEL = None
+    # TabPFNWrapper uses a class-level _shared_classifier so weights are only
+    # loaded once per process regardless of how many instances are created.
+    return TabPFNWrapper(task_type=task, random_state=RAND)
+
 
 
 class _SAPModel:

webapp/main.py

@@ -245,7 +245,7 @@ async def predict(data: dict):
         X_test, _ = _prep(input_df, encoders=CHAMPION_INFO.get("encoders"))
         
         if CHAMPION_INFO["task"] == "classification":
-            raw_pred = CHAMPION_MODEL.predict(X_test)
+            raw_pred = np.array(CHAMPION_MODEL.predict(X_test))
             # Flatten if nested (CatBoost/Sklearn sometimes return [[val]] or [val])
             pred_val = raw_pred.ravel()[0]
             pred_idx = int(pred_val)
@@ -266,7 +266,7 @@ async def predict(data: dict):
                 "labels": CHAMPION_INFO["labels"]
             }
         else:
-            raw_pred = CHAMPION_MODEL.predict(X_test)
+            raw_pred = np.array(CHAMPION_MODEL.predict(X_test))
             pred = float(raw_pred.ravel()[0])
             return {"prediction": pred}
             

webapp/requirements.txt

@@ -9,5 +9,5 @@ scikit-learn>=1.3.0
 scipy>=1.10.0
 pandas>=2.0.0
 numpy>=1.24.0
-tabpfn>=7.1.1
+tabpfn==0.1.11
 huggingface_hub