Upload app.py with huggingface_hub

app.py

@@ -364,7 +364,7 @@ class ModelManager:
         return features_dict
     
     def predict_brain_activity(self, features_dict):
-        """Run brain encoder forward pass."""
+        """Run brain encoder forward pass using BOTH ridge and deep models."""
         # Determine which features to use
         if 'image_multi_layer' in features_dict:
             input_features = features_dict['image_multi_layer']
@@ -384,26 +384,43 @@ class ModelManager:
         if len(all_modality_features) > 1:
             input_features = torch.mean(torch.stack(all_modality_features), dim=0)
         
+        input_features_np = input_features.cpu().numpy()
         input_features = input_features.to(self.device)
         
-        # Forward pass through brain encoder
-        with torch.no_grad():
-            predictions, intermediates = self.brain_encoder(input_features, return_intermediates=True)
+        # ── Primary: Ridge Model (proven baseline from Algonauts 2023) ──
+        if self.ridge_model is not None:
+            ridge = self.ridge_model
+            X_norm = (input_features_np - ridge['feat_mean']) / ridge['feat_std']
+            pred_z = ridge['model'].predict(X_norm)
+            pred_np = (pred_z * ridge['fmri_std'] + ridge['fmri_mean']).flatten()
+            
+            # Clip extreme values for better visualization (keep 99.5th percentile)
+            clip_val = np.percentile(np.abs(pred_np), 99.5)
+            pred_np = np.clip(pred_np, -clip_val, clip_val)
+        else:
+            # Fallback to deep encoder
+            with torch.no_grad():
+                predictions, _ = self.brain_encoder(input_features, return_intermediates=True)
+            pred_np = predictions.cpu().numpy().flatten()
         
-        pred_np = predictions.cpu().numpy().flatten()
+        # ── Deep encoder for intermediates and uncertainty ──
+        with torch.no_grad():
+            deep_pred, intermediates = self.brain_encoder(input_features, return_intermediates=True)
         
-        # Compute modality contributions
+        # Compute modality contributions using ridge (more reliable)
         modality_contributions = {}
-        for key in ['image_multi_layer', 'text_multi_layer', 'audio_multi_layer']:
-            if key in features_dict:
-                modality_name = key.split('_')[0]
-                feat = features_dict[key].to(self.device)
-                with torch.no_grad():
-                    single_pred = self.brain_encoder(feat)
-                modality_contributions[modality_name] = single_pred.cpu().numpy().flatten()
-        
-        # Compute uncertainty via dropout MC
-        self.brain_encoder.train()  # Enable dropout
+        if self.ridge_model is not None:
+            for key in ['image_multi_layer', 'text_multi_layer', 'audio_multi_layer']:
+                if key in features_dict:
+                    modality_name = key.split('_')[0]
+                    feat_np = features_dict[key].cpu().numpy()
+                    X_n = (feat_np - ridge['feat_mean']) / ridge['feat_std']
+                    mp = (ridge['model'].predict(X_n) * ridge['fmri_std'] + ridge['fmri_mean']).flatten()
+                    mp = np.clip(mp, -clip_val, clip_val)
+                    modality_contributions[modality_name] = mp
+        
+        # Compute uncertainty via dropout MC (deep encoder)
+        self.brain_encoder.train()
         mc_predictions = []
         for _ in range(10):
             with torch.no_grad():
@@ -414,8 +431,18 @@ class ModelManager:
         mc_predictions = np.array(mc_predictions)
         uncertainty = np.std(mc_predictions, axis=0)
         
-        # Compute ROI summaries
-        roi_summary = self._compute_roi_summary(pred_np, uncertainty)
+        # Compute ROI summaries using z-scored per-voxel predictions
+        # This shows which regions are MORE or LESS activated compared to baseline
+        if self.ridge_model is not None:
+            baseline_mean = self.ridge_model['fmri_mean']
+            baseline_std = self.ridge_model['fmri_std']
+            # Z-score predictions relative to training distribution
+            n_v = min(len(pred_np), len(baseline_mean))
+            pred_z = (pred_np[:n_v] - baseline_mean[:n_v]) / (baseline_std[:n_v] + 1e-8)
+        else:
+            pred_z = pred_np
+        
+        roi_summary = self._compute_roi_summary(pred_z, uncertainty)
         
         # Validation checks
         warnings = self._validate_predictions(pred_np)