fix: Remove demo testing calls from inference script

Author: Linked-Liszt

src/ui/app/model_inference.py

@@ -26,7 +26,6 @@ def load_model(self):
         try:
             if not self.model_path.exists():
                 print(f"Warning: Model file not found at {self.model_path}")
-                print("Running in demo mode with dummy predictions")
                 return
 
             # Import the model class from copied model files
@@ -50,7 +49,6 @@ def load_model(self):
 
         except Exception as e:
             print(f"Error loading model: {e}")
-            print("Running in demo mode with dummy predictions")
             self.model = None
 
     def preprocess_data(self, x: List[float], y: List[float]) -> torch.Tensor:
@@ -101,8 +99,11 @@ def predict(self, x: List[float], y: List[float]) -> Dict:
             Dictionary with predictions and confidence scores
         """
         if self.model is None:
-            # Return dummy predictions for demo mode
-            return self._dummy_predictions()
+            return {
+                "status": "error",
+                "error": f"Model not loaded. Expected checkpoint at {self.model_path}",
+                "http_status": 503
+            }
 
         try:
             # Preprocess data
@@ -114,24 +115,26 @@ def predict(self, x: List[float], y: List[float]) -> Dict:
 
             # Process output (adjust based on your model's output format)
             processed = self._process_model_output(output)
+            overall_confidence = self._compute_overall_confidence(processed)
 
             predictions = {
                 "status": "success",
                 "predictions": processed,
-                "confidence": 0.85,  # Placeholder - calculate from model output
                 "model_info": {
                     "type": "AlphaDiffract",
                     "device": str(self.device)
                 }
             }
+            if overall_confidence is not None:
+                predictions["confidence"] = overall_confidence
 
             return predictions
 
         except Exception as e:
             return {
                 "status": "error",
                 "error": str(e),
-                "predictions": self._dummy_predictions()
+                "http_status": 500
             }
 
     def _process_model_output(self, output) -> Dict:
@@ -224,13 +227,19 @@ def _process_model_output(self, output) -> Dict:
         # Handle tensor output
         elif isinstance(output, torch.Tensor):
             probs = output.cpu().numpy()
+            confidence = None
+            if output.ndim >= 1 and output.shape[-1] > 1:
+                prob_tensor = torch.softmax(output, dim=-1)
+                confidence = float(prob_tensor.max().item())
+
             predictions = [
                 {
                     "phase": f"Predicted Phase",
-                    "confidence": 0.82,
                     "details": f"Output shape: {probs.shape}"
                 }
             ]
+            if confidence is not None:
+                predictions[0]["confidence"] = confidence
 
             return {
                 "phase_predictions": predictions,
@@ -257,18 +266,14 @@ def _get_space_group_symbol(self, sg_number: int) -> str:
             return f"SG{sg_number}"
         except Exception:
             return f"SG{sg_number}"
-    
-    def _dummy_predictions(self) -> Dict:
-        """Return dummy predictions when model is not available"""
-        return {
-            "status": "demo",
-            "message": "Running in demo mode - model not loaded",
-            "predictions": {
-                "phase_predictions": [
-                    {"phase": "Demo Phase 1", "confidence": 0.75},
-                    {"phase": "Demo Phase 2", "confidence": 0.45},
-                ],
-                "intensity_profile": []
-            },
-            "confidence": 0.60
-        }
+
+    def _compute_overall_confidence(self, processed: Dict) -> Optional[float]:
+        """Compute overall confidence from available per-phase confidences."""
+        phase_predictions = processed.get("phase_predictions", []) if isinstance(processed, dict) else []
+        confidences = [
+            float(p["confidence"]) for p in phase_predictions
+            if isinstance(p, dict) and "confidence" in p and p["confidence"] is not None
+        ]
+        if not confidences:
+            return None
+        return float(np.mean(confidences))

src/ui/requirements.txt

@@ -5,3 +5,4 @@ numpy==1.24.3
 torch==2.1.0
 pytorch-lightning==2.5.5
 pydantic==2.5.0
+spglib==2.4.0