Bug Fixes

app.py

@@ -1,7 +1,6 @@
 import os
-os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
 
-import streamlit as st
+import gradio as gr
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -9,9 +8,7 @@ import soundfile as sf
 import torchaudio
 from transformers import Wav2Vec2FeatureExtractor, Wav2Vec2Model
 import numpy as np
-from pathlib import Path
 import json
-import tempfile
 
 # ============================================================
 # MODEL DEFINITION
@@ -41,75 +38,22 @@ class Wav2Vec2ForSpeakerEmbedding(nn.Module):
 
 
 # ============================================================
-# AUDIO PROCESSING
+# GLOBAL SETUP
 # ============================================================
 
-def process_audio(audio_file, feature_extractor, max_length=16000*3):
-    """Process uploaded audio file"""
-    try:
-        # Save uploaded file temporarily
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_file:
-            tmp_file.write(audio_file.getvalue())
-            tmp_path = tmp_file.name
-        
-        # Load audio
-        waveform, sr = sf.read(tmp_path, dtype='float32')
-        waveform = torch.from_numpy(waveform)
-        
-        # Convert to mono
-        if len(waveform.shape) > 1:
-            waveform = torch.mean(waveform, dim=-1)
-        
-        # Resample to 16kHz
-        if sr != 16000:
-            resampler = torchaudio.transforms.Resample(sr, 16000)
-            waveform = resampler(waveform)
-        
-        # Take middle chunk
-        if len(waveform) > max_length:
-            start = (len(waveform) - max_length) // 2
-            waveform = waveform[start:start + max_length]
-        elif len(waveform) < max_length:
-            padding = max_length - len(waveform)
-            waveform = torch.nn.functional.pad(waveform, (0, padding))
-        
-        # Normalize
-        if waveform.abs().max() > 0:
-            waveform = waveform / waveform.abs().max()
-        
-        # Extract features
-        inputs = feature_extractor(
-            waveform.numpy(),
-            sampling_rate=16000,
-            return_tensors="pt"
-        )
-        
-        # Cleanup
-        os.unlink(tmp_path)
-        
-        return inputs.input_values, waveform.numpy(), sr
-    
-    except Exception as e:
-        st.error(f"Error processing audio: {e}")
-        return None, None, None
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
+# Load model
+model = Wav2Vec2ForSpeakerEmbedding(embedding_size=256).to(device)
+checkpoint = torch.load('best_embedding_model.pth', map_location=device)
+model.load_state_dict(checkpoint['model_state_dict'])
+model.eval()
 
-def get_embedding(model, audio_file, feature_extractor, device):
-    """Extract embedding from audio file"""
-    inputs, waveform, sr = process_audio(audio_file, feature_extractor)
-    if inputs is None:
-        return None
-    
-    model.eval()
-    with torch.no_grad():
-        inputs = inputs.to(device)
-        embedding = model(inputs)
-    
-    return embedding.cpu().numpy()
+feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained("facebook/wav2vec2-base")
 
 
 # ============================================================
-# ENROLLMENT DATABASE
+# DATABASE
 # ============================================================
 
 class EnrollmentDB:
@@ -135,10 +79,6 @@ class EnrollmentDB:
         self.save_db()
     
     def verify(self, embedding, threshold=0.75):
-        """
-        Verify against all enrolled users
-        Returns: (best_match_name, similarity_score, is_verified)
-        """
         if not self.enrollments:
             return None, 0.0, False
         
@@ -156,12 +96,14 @@ class EnrollmentDB:
                 best_match = name
         
         is_verified = best_score >= threshold
-        
         return best_match, best_score, is_verified
     
     def get_all_users(self):
         return list(self.enrollments.keys())
     
+    def get_user_count(self):
+        return len(self.enrollments)
+    
     def remove_user(self, name):
         if name in self.enrollments:
             del self.enrollments[name]
@@ -169,326 +111,353 @@ class EnrollmentDB:
             return True
         return False
 
+db = EnrollmentDB()
+
 
 # ============================================================
-# STREAMLIT APP
+# AUDIO PROCESSING
 # ============================================================
 
-@st.cache_resource
-def load_model():
-    """Load model once and cache it"""
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+def process_audio(audio_path, max_length=16000*3):
+    """Process audio file"""
+    try:
+        waveform, sr = sf.read(audio_path, dtype='float32')
+        waveform = torch.from_numpy(waveform)
+        
+        if len(waveform.shape) > 1:
+            waveform = torch.mean(waveform, dim=-1)
+        
+        if sr != 16000:
+            resampler = torchaudio.transforms.Resample(sr, 16000)
+            waveform = resampler(waveform)
+        
+        if len(waveform) > max_length:
+            start = (len(waveform) - max_length) // 2
+            waveform = waveform[start:start + max_length]
+        elif len(waveform) < max_length:
+            padding = max_length - len(waveform)
+            waveform = torch.nn.functional.pad(waveform, (0, padding))
+        
+        if waveform.abs().max() > 0:
+            waveform = waveform / waveform.abs().max()
+        
+        inputs = feature_extractor(
+            waveform.numpy(),
+            sampling_rate=16000,
+            return_tensors="pt"
+        )
+        
+        return inputs.input_values
     
-    model = Wav2Vec2ForSpeakerEmbedding(embedding_size=256).to(device)
-    checkpoint = torch.load('best_embedding_model.pth', map_location=device)
-    model.load_state_dict(checkpoint['model_state_dict'])
+    except Exception as e:
+        raise ValueError(f"Error processing audio: {e}")
+
+
+def get_embedding(audio_path):
+    """Extract embedding from audio"""
     model.eval()
-    
-    feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained("facebook/wav2vec2-base")
-    
-    return model, feature_extractor, device
+    with torch.no_grad():
+        inputs = process_audio(audio_path)
+        inputs = inputs.to(device)
+        embedding = model(inputs)
+    return embedding.cpu().numpy()
+
 
+# ============================================================
+# GRADIO FUNCTIONS
+# ============================================================
 
-def main():
-    st.set_page_config(
-        page_title="Voice Biometry Demo",
-        page_icon="🎤",
-        layout="wide"
-    )
+def enroll_user(name, audio, threshold):
+    """Enroll a new user"""
+    if not name or not name.strip():
+        return "❌ Veuillez entrer un nom.", get_user_list(), get_stats()
     
-    # Custom CSS
-    st.markdown("""
-        <style>
-        .big-font {
-            font-size:20px !important;
-            font-weight: bold;
-        }
-        .success-box {
-            padding: 20px;
-            border-radius: 10px;
-            background-color: #d4edda;
-            border: 2px solid #28a745;
-            color: #155724;
-        }
-        .failure-box {
-            padding: 20px;
-            border-radius: 10px;
-            background-color: #f8d7da;
-            border: 2px solid #dc3545;
-            color: #721c24;
-        }
-        .info-box {
-            padding: 20px;
-            border-radius: 10px;
-            background-color: #d1ecf1;
-            border: 2px solid #17a2b8;
-            color: #0c5460;
-        }
-        </style>
-    """, unsafe_allow_html=True)
+    if not audio:
+        return "❌ Veuillez uploader un enregistrement audio.", get_user_list(), get_stats()
     
-    # Header
-    st.title("Voice Biometry System - Proof of Concept")
-    st.markdown("### Finetuned Wav2Vec 2.0")
+    name = name.strip()
     
-    # Load model
-    with st.spinner("Loading model..."):
-        model, feature_extractor, device = load_model()
+    if name in db.get_all_users():
+        return f"⚠️ L'utilisateur '{name}' existe déjà.", get_user_list(), get_stats()
     
-    # Initialize database
-    db = EnrollmentDB()
+    try:
+        embedding = get_embedding(audio)
+        db.enroll(name, embedding)
+        return f"✅ Enregistrement réussi!\n\n👤 {name} a été enregistré dans le système.\n📊 Total utilisateurs: {db.get_user_count()}", get_user_list(), get_stats()
+    except Exception as e:
+        return f"❌ Erreur: {str(e)}", get_user_list(), get_stats()
+
+
+def verify_user(audio, threshold):
+    """Verify a user"""
+    if not audio:
+        return "❌ Veuillez uploader un enregistrement audio.", ""
     
-    # Sidebar - Configuration
-    st.sidebar.header("⚙️ Configuration")
-    threshold = st.sidebar.slider(
-        "Verification Threshold",
-        min_value=0.5,
-        max_value=0.95,
-        value=0.75,
-        step=0.05,
-        help="Higher = more strict verification"
-    )
+    if db.get_user_count() == 0:
+        return "⚠️ Aucun utilisateur enregistré. Veuillez d'abord enregistrer des utilisateurs.", ""
     
-    st.sidebar.markdown("---")
-    st.sidebar.header("📊 System Stats")
-    st.sidebar.metric("Enrolled Users", len(db.get_all_users()))
-    st.sidebar.metric("Model Accuracy", "76%")
-    st.sidebar.metric("AUC Score", "0.82")
+    try:
+        embedding = get_embedding(audio)
+        match_name, similarity, is_verified = db.verify(embedding, threshold)
+        
+        # Build detailed results
+        details = "📊 **Scores détaillés:**\n\n"
+        embedding_tensor = torch.from_numpy(embedding)
+        
+        scores = []
+        for name, enrolled_emb in db.enrollments.items():
+            enrolled_tensor = torch.from_numpy(enrolled_emb)
+            sim = F.cosine_similarity(embedding_tensor, enrolled_tensor, dim=1).item()
+            status = "✅" if sim >= threshold else "❌"
+            scores.append((name, sim, status))
+        
+        scores.sort(key=lambda x: x[1], reverse=True)
+        
+        for name, sim, status in scores:
+            details += f"{status} **{name}**: {sim:.1%}\n"
+        
+        if is_verified:
+            result = f"""
+# ✅ VÉRIFICATION RÉUSSIE
+
+## Identifié comme: **{match_name}**
+### Score de confiance: **{similarity:.1%}**
+
+---
+"""
+            return result + details, details
+        else:
+            result = f"""
+# ❌ VÉRIFICATION ÉCHOUÉE
+
+Meilleure correspondance: **{match_name}**
+Similarité: **{similarity:.1%}**
+Seuil requis: **{threshold:.1%}**
+
+*Cette voix n'est pas reconnue dans le système.*
+
+---
+"""
+            return result + details, details
+            
+    except Exception as e:
+        return f"❌ Erreur: {str(e)}", ""
+
+
+def get_user_list():
+    """Get list of enrolled users"""
+    users = db.get_all_users()
+    if not users:
+        return "Aucun utilisateur enregistré"
+    return "\n".join([f"• {user}" for user in sorted(users)])
+
+
+def get_stats():
+    """Get system statistics"""
+    return f"""
+**📊 Statistiques du système:**
+- Utilisateurs enregistrés: {db.get_user_count()}
+- Précision du modèle: 76%
+- Score AUC: 0.82
+- Architecture: Wav2Vec 2.0
+"""
+
+
+def delete_user(name):
+    """Delete a user"""
+    if not name or not name.strip():
+        return "❌ Veuillez sélectionner un utilisateur.", get_user_list(), get_stats()
     
-    # Enrolled users list
-    if db.get_all_users():
-        st.sidebar.markdown("---")
-        st.sidebar.header("👥 Enrolled Users")
-        for user in db.get_all_users():
-            col1, col2 = st.sidebar.columns([3, 1])
-            col1.write(f"• {user}")
-            if col2.button("🗑️", key=f"del_{user}"):
-                db.remove_user(user)
-                st.rerun()
+    if db.remove_user(name.strip()):
+        return f"✅ Utilisateur '{name}' supprimé.", get_user_list(), get_stats()
+    else:
+        return f"❌ Utilisateur '{name}' non trouvé.", get_user_list(), get_stats()
+
+
+# ============================================================
+# GRADIO INTERFACE
+# ============================================================
+
+with gr.Blocks(title="Biométrie Vocale - POC", theme=gr.themes.Soft()) as demo:
     
-    # Main tabs
-    tab1, tab2, tab3 = st.tabs(["📝 Enrollment", "✅ Verification", "ℹ️ About"])
+    gr.Markdown("""
+    # 🎤 Système de Biométrie Vocale
+    ### Proof of Concept - Wav2Vec 2.0 Fine-tuné
+    """)
     
-    # ============================================================
-    # TAB 1: ENROLLMENT
-    # ============================================================
-    with tab1:
-        st.header("Enroll a New User")
-        st.markdown("Upload a voice recording to register a new user in the system.")
-        
-        col1, col2 = st.columns([2, 1])
-        
-        with col1:
-            enroll_name = st.text_input(
-                "User Name",
-                placeholder="Enter name (e.g., Abdou Diop)",
-                help="This name will be used to identify the speaker"
+    with gr.Row():
+        with gr.Column(scale=2):
+            stats_display = gr.Markdown(get_stats())
+        with gr.Column(scale=1):
+            threshold = gr.Slider(
+                minimum=0.5,
+                maximum=0.95,
+                value=0.75,
+                step=0.05,
+                label="Seuil de vérification",
+                info="Plus élevé = vérification plus stricte"
             )
+    
+    with gr.Tabs():
+        # TAB 1: ENROLLMENT
+        with gr.Tab("📝 Enregistrement"):
+            gr.Markdown("### Enregistrer un nouvel utilisateur")
+            
+            with gr.Row():
+                with gr.Column():
+                    enroll_name_input = gr.Textbox(
+                        label="Nom de l'utilisateur",
+                        placeholder="Ex: Jean Dupont"
+                    )
+                    enroll_audio_input = gr.Audio(
+                        label="Enregistrement vocal",
+                        type="filepath",
+                        sources=["upload", "microphone"]
+                    )
+                    enroll_button = gr.Button("🎯 Enregistrer", variant="primary")
+                
+                with gr.Column():
+                    gr.Markdown("""
+                    **💡 Conseils:**
+                    - Audio clair et net
+                    - 3-20 secondes recommandées
+                    - Bruit de fond minimal
+                    - Voix normale
+                    """)
+                    enrolled_users = gr.Textbox(
+                        label="Utilisateurs enregistrés",
+                        value=get_user_list(),
+                        lines=8,
+                        interactive=False
+                    )
             
-            enroll_audio = st.file_uploader(
-                "Upload Voice Recording",
-                type=['wav', 'mp3', 'flac', 'ogg'],
-                help="Upload a clear voice recording (3-20 seconds recommended)",
-                key="enroll"
+            enroll_output = gr.Markdown()
+            
+            enroll_button.click(
+                fn=enroll_user,
+                inputs=[enroll_name_input, enroll_audio_input, threshold],
+                outputs=[enroll_output, enrolled_users, stats_display]
             )
         
-        with col2:
-            st.info("""
-            **Enrollment Tips:**
-            - Use clear audio
-            - 3-20 seconds long
-            - Minimal background noise
-            - Normal speaking voice
-            """)
-        
-        if st.button("🎯 Enroll User", type="primary", disabled=(not enroll_name or not enroll_audio)):
-            with st.spinner(f"Processing enrollment for {enroll_name}..."):
-                # Check if user already exists
-                if enroll_name in db.get_all_users():
-                    st.warning(f"⚠️ User '{enroll_name}' already exists. Please use a different name or remove the existing user first.")
-                else:
-                    # Get embedding
-                    embedding = get_embedding(model, enroll_audio, feature_extractor, device)
-                    
-                    if embedding is not None:
-                        # Save enrollment
-                        db.enroll(enroll_name, embedding)
-                        
-                        st.markdown(f"""
-                        <div class="success-box">
-                            <h3>✅ Enrollment Successful!</h3>
-                            <p><strong>{enroll_name}</strong> has been enrolled in the system.</p>
-                            <p>Total enrolled users: {len(db.get_all_users())}</p>
-                        </div>
-                        """, unsafe_allow_html=True)
-                        
-                        #st.balloons()
-                    else:
-                        st.error("❌ Failed to process audio. Please try again with a different recording.")
-    
-    # ============================================================
-    # TAB 2: VERIFICATION
-    # ============================================================
-    with tab2:
-        st.header("Verify User Identity")
-        st.markdown("Upload a voice recording to verify against enrolled users.")
-        
-        if not db.get_all_users():
-            st.warning("⚠️ No users enrolled yet. Please enroll at least one user first.")
-        else:
-            col1, col2 = st.columns([2, 1])
+        # TAB 2: VERIFICATION
+        with gr.Tab("✅ Vérification"):
+            gr.Markdown("### Vérifier l'identité d'un utilisateur")
             
-            with col1:
-                verify_audio = st.file_uploader(
-                    "Upload Voice Recording for Verification",
-                    type=['wav', 'mp3', 'flac', 'ogg'],
-                    help="Upload a voice recording from a speaker you want to verify",
-                    key="verify"
-                )
+            with gr.Row():
+                with gr.Column():
+                    verify_audio_input = gr.Audio(
+                        label="Enregistrement vocal à vérifier",
+                        type="filepath",
+                        sources=["upload", "microphone"]
+                    )
+                    verify_button = gr.Button("🔍 Vérifier", variant="primary")
+                
+                with gr.Column():
+                    gr.Markdown(f"""
+                    **ℹ️ Information:**
+                    - {db.get_user_count()} utilisateur(s) enregistré(s)
+                    - Seuil: ajustable dans le slider ci-dessus
+                    - Modèle: Wav2Vec 2.0
+                    """)
             
-            with col2:
-                st.info(f"""
-                **Verification Info:**
-                - {len(db.get_all_users())} users enrolled
-                - Threshold: {threshold:.2f}
-                - Model: Wav2Vec 2.0
-                """)
+            verify_output = gr.Markdown()
+            verify_details = gr.Markdown()
             
-            if st.button("🔍 Verify Identity", type="primary", disabled=(not verify_audio)):
-                with st.spinner("Analyzing voice..."):
-                    # Get embedding
-                    embedding = get_embedding(model, verify_audio, feature_extractor, device)
-                    
-                    if embedding is not None:
-                        # Verify
-                        match_name, similarity, is_verified = db.verify(embedding, threshold)
-                        
-                        # Display results
-                        st.markdown("---")
-                        
-                        if is_verified:
-                            st.markdown(f"""
-                            <div class="success-box">
-                                <h2>✅ VERIFICATION SUCCESSFUL</h2>
-                                <h3>Identified as: {match_name}</h3>
-                                <p style="font-size: 18px;">Confidence Score: <strong>{similarity:.1%}</strong></p>
-                            </div>
-                            """, unsafe_allow_html=True)
-                            
-                            st.success(f"🎉 Welcome back, {match_name}!")
-                            
-                        else:
-                            st.markdown(f"""
-                            <div class="failure-box">
-                                <h2>❌ VERIFICATION FAILED</h2>
-                                <p>Closest match: <strong>{match_name}</strong></p>
-                                <p>Similarity: <strong>{similarity:.1%}</strong></p>
-                                <p>Threshold required: <strong>{threshold:.1%}</strong></p>
-                                <p><em>This speaker is not recognized in the system.</em></p>
-                            </div>
-                            """, unsafe_allow_html=True)
-                        
-                        # Show all scores
-                        with st.expander("📊 See detailed scores for all enrolled users"):
-                            st.markdown("### Similarity Scores")
-                            
-                            scores = []
-                            embedding_tensor = torch.from_numpy(embedding)
-                            
-                            for name, enrolled_emb in db.enrollments.items():
-                                enrolled_tensor = torch.from_numpy(enrolled_emb)
-                                sim = F.cosine_similarity(embedding_tensor, enrolled_tensor, dim=1).item()
-                                scores.append({
-                                    'User': name,
-                                    'Similarity': f"{sim:.1%}",
-                                    'Status': '✅ Match' if sim >= threshold else '❌ No match'
-                                })
-                            
-                            # Sort by similarity
-                            scores.sort(key=lambda x: x['Similarity'], reverse=True)
-                            
-                            import pandas as pd
-                            df = pd.DataFrame(scores)
-                            st.dataframe(df, use_container_width=True, hide_index=True)
-                    
-                    else:
-                        st.error("❌ Failed to process audio. Please try again with a different recording.")
-    
-    # ============================================================
-    # TAB 3: ABOUT
-    # ============================================================
-    with tab3:
-        st.header("About This System")
+            verify_button.click(
+                fn=verify_user,
+                inputs=[verify_audio_input, threshold],
+                outputs=[verify_output, verify_details]
+            )
         
-        col1, col2 = st.columns(2)
+        # TAB 3: MANAGEMENT
+        with gr.Tab("⚙️ Gestion"):
+            gr.Markdown("### Gérer les utilisateurs enregistrés")
+            
+            with gr.Row():
+                with gr.Column():
+                    delete_name_input = gr.Textbox(
+                        label="Nom de l'utilisateur à supprimer",
+                        placeholder="Ex: Jean Dupont"
+                    )
+                    delete_button = gr.Button("🗑️ Supprimer", variant="stop")
+                
+                with gr.Column():
+                    delete_users_list = gr.Textbox(
+                        label="Utilisateurs enregistrés",
+                        value=get_user_list(),
+                        lines=8,
+                        interactive=False
+                    )
+            
+            delete_output = gr.Markdown()
+            
+            delete_button.click(
+                fn=delete_user,
+                inputs=[delete_name_input],
+                outputs=[delete_output, delete_users_list, stats_display]
+            )
         
-        with col1:
-            st.markdown("""
-            ### 🎯 Technology
+        # TAB 4: ABOUT
+        with gr.Tab("ℹ️ À propos"):
+            gr.Markdown("""
+            ## 🎯 Technologie
             
-            **Model Architecture:**
+            **Architecture du modèle:**
             - Base: Wav2Vec 2.0 (Facebook AI)
-            - Finetuned on 247 speakers
-            - 1035 voice samples (telephone quality, 8kHz)
-            - Embedding dimension: 256
+            - Fine-tuné sur 247 locuteurs
+            - 1035 échantillons vocaux (qualité téléphonique, 8kHz)
+            - Dimension d'embedding: 256
             
-            **Training Details:**
+            **Détails d'entraînement:**
             - Loss: Supervised Contrastive Learning
             - Framework: PyTorch + Transformers
-            - Training time: ~50 epochs
-            - Hardware: NVIDIA RTX 3050
-            """)
-        
-        with col2:
-            st.markdown("""
-            ### 📊 Performance Metrics
+            - Durée d'entraînement: ~50 epochs
+            - Matériel: NVIDIA RTX 3050
+            
+            ---
+            
+            ## 📊 Métriques de Performance
+            
+            **Résultats d'évaluation:**
+            - **Précision:** 76%
+            - **Score AUC:** 0.82
+            - **Taux de vrais positifs:** 79%
+            - **Taux de faux positifs:** 27%
+            
+            **Ensemble de test:**
+            - 1000 paires de vérification
+            - 500 paires même locuteur
+            - 500 paires locuteurs différents
+            
+            ---
+            
+            ## 🔧 Fonctionnement
+            
+            1. **Phase d'enregistrement:**
+               - L'utilisateur uploade un enregistrement vocal
+               - Le système extrait un embedding de dimension 256
+               - L'embedding est stocké dans la base de données
+            
+            2. **Phase de vérification:**
+               - Enregistrement vocal inconnu uploadé
+               - Le système extrait l'embedding
+               - Calcul de similarité cosinus avec tous les utilisateurs enregistrés
+               - Correspondance si similarité > seuil
             
-            **Evaluation Results:**
-            - **Accuracy:** 76%
-            - **AUC Score:** 0.82
-            - **True Positive Rate:** 79%
-            - **False Positive Rate:** 27%
+            3. **Algorithme de correspondance:**
+               - Similarité cosinus entre embeddings
+               - Plage: -1 (opposé) à +1 (identique)
+               - Même locuteur typique: 0.75-0.95
+               - Locuteurs différents typique: 0.30-0.70
             
-            **Test Set:**
-            - 1000 verification pairs
-            - 500 same-speaker pairs
-            - 500 different-speaker pairs
+            ---
+            
+            **Note:** Ceci est un système proof of concept. Pour un déploiement en production, considérer:
+            - Dataset plus large (10-20 échantillons par locuteur)
+            - Meilleur modèle de base (WavLM pour conditions bruitées)
+            - Mesures anti-spoofing
+            - Détection de vivacité
+            - Multi-enregistrement (moyenne de plusieurs enregistrements par utilisateur)
             """)
-        
-        st.markdown("---")
-        
-        st.markdown("""
-        ### 🔧 How It Works
-        
-        1. **Enrollment Phase:**
-           - User uploads voice recording
-           - System extracts 256-dimensional embedding
-           - Embedding stored in database with user name
-        
-        2. **Verification Phase:**
-           - Unknown voice recording uploaded
-           - System extracts embedding
-           - Computes cosine similarity with all enrolled users
-           - Returns match if similarity exceeds threshold
-        
-        3. **Matching Algorithm:**
-           - Cosine similarity between embeddings
-           - Range: -1 (opposite) to +1 (identical)
-           - Typical same-speaker: 0.75-0.95
-           - Typical different-speaker: 0.30-0.70
-        """)
-        
-        st.markdown("---")
-        
-        st.info("""
-        **Note:** This is a proof of concept system. For production deployment, consider:
-        - Larger training dataset (10-20 samples per speaker)
-        - Better base model (WavLM for noisy conditions)
-        - Anti-spoofing measures
-        - Liveness detection
-        - Multi-enrollment (average multiple recordings per user)
-        """)
-
-
-if __name__ == "__main__":
-    main()
+
+demo.launch(share=False)