Update app.py

app.py

@@ -47,7 +47,46 @@ class SpeakerVerification:
         probability = max(0.0, min(1.0, probability))
         return probability
     
-    def verify_speaker(self, audio_path1: str, audio_path2: str) -> tuple[float, str]:
+    def calculate_confidence_metrics(self, score_value: float) -> dict:
+        """Calculate various confidence metrics."""
+        try:
+            # Distance from threshold
+            threshold_distance = abs(score_value - self.threshold)
+            
+            # Normalized confidence score (0-1 scale)
+            normalized_confidence = (score_value + 1) / 2
+            
+            # Certainty score based on distance from decision boundary
+            certainty = 1 - (1 / (1 + np.exp(5 * threshold_distance)))
+            
+            # Decision strength (how far from ambiguous region)
+            ambiguous_region = 0.1
+            if abs(score_value - self.threshold) < ambiguous_region:
+                decision_strength = "Low"
+            elif abs(score_value - self.threshold) < ambiguous_region * 2:
+                decision_strength = "Medium"
+            else:
+                decision_strength = "High"
+            
+            # Confidence level categories
+            if certainty < 0.6:
+                confidence_level = "Low"
+            elif certainty < 0.8:
+                confidence_level = "Medium"
+            else:
+                confidence_level = "High"
+
+            return {
+                "certainty_score": certainty,
+                "threshold_distance": threshold_distance,
+                "decision_strength": decision_strength,
+                "confidence_level": confidence_level
+            }
+        except Exception as e:
+            print(f"Error calculating confidence metrics: {str(e)}")
+            return {}
+
+    def verify_speaker(self, audio_path1: str, audio_path2: str) -> tuple:
         try:
             wav_path1 = self.convert_audio(audio_path1)
             wav_path2 = self.convert_audio(audio_path2)
@@ -63,11 +102,14 @@ class SpeakerVerification:
             probability = self.score_to_probability(score_value)
             decision = "Same speaker" if prediction.item() else "Different speakers"
             
-            return probability, decision, score_value
+            # Calculate confidence metrics
+            confidence_metrics = self.calculate_confidence_metrics(score_value)
+            
+            return probability, decision, score_value, confidence_metrics
 
         except Exception as e:
             print(f"Error in speaker verification: {str(e)}")
-            return 0.0, f"Error: {str(e)}"
+            return 0.0, f"Error: {str(e)}", 0.0, {}
 
     def get_embeddings(self, audio_path: str):
         wav_path = self.convert_audio(audio_path)
@@ -109,24 +151,30 @@ class SpeakerVerification:
 def create_gradio_interface():
     speaker_verifier = SpeakerVerification()
     
-    def process_audio(audio1, audio2):
-        try:
-            if audio1 is None or audio2 is None:
-                return "Error: Please provide both audio samples", None
-            
-            probability, decision, score = speaker_verifier.verify_speaker(audio1, audio2)
-            emb1 = speaker_verifier.get_embeddings(audio1)
-            emb2 = speaker_verifier.get_embeddings(audio2)
-            
-            embeddings_plot = speaker_verifier.plot_embeddings_comparison(emb1, emb2)
-            
-            #result_text = f"Probability: {probability:.2%}\nCosine similarity: {score}\nDecision: {decision}"
-            result_text = f"Cosine similarity (threshold for the model=0.25): {score}\nDecision: {decision}"
-            
-            return result_text, embeddings_plot
+def process_audio(audio1, audio2):
+    try:
+        if audio1 is None or audio2 is None:
+            return "Error: Please provide both audio samples", None
         
-        except Exception as e:
-            return f"Error processing audio: {str(e)}", None
+        probability, decision, score, confidence_metrics = speaker_verifier.verify_speaker(audio1, audio2)
+        emb1 = speaker_verifier.get_embeddings(audio1)
+        emb2 = speaker_verifier.get_embeddings(audio2)
+        
+        embeddings_plot = speaker_verifier.plot_embeddings_comparison(emb1, emb2)
+        
+        result_text = (
+            f"Cosine similarity (threshold=0.25): {score:.3f}\n"
+            f"Decision: {decision}\n"
+            f"Certainty Score: {confidence_metrics['certainty_score']:.2f}\n"
+            f"Threshold Distance: {confidence_metrics['threshold_distance']:.3f}\n"
+            f"Decision Strength: {confidence_metrics['decision_strength']}\n"
+            f"Confidence Level: {confidence_metrics['confidence_level']}"
+        )
+        
+        return result_text, embeddings_plot
+    
+    except Exception as e:
+        return f"Error processing audio: {str(e)}", None
 
     interface = gr.Interface(
         fn=process_audio,