Update app.py

app.py

@@ -4,7 +4,7 @@ import librosa
 import numpy as np
 
 # ---------------------------------------------------------
-# 1. AUDIO-MODELL LADEN
+# 1. AUDIO-MODELL LADEN (für genaue Erkennung)
 # ---------------------------------------------------------
 
 classifier = pipeline(
@@ -32,6 +32,8 @@ ENERGY_HOP_MS = 10          # Schrittweite (ms)
 ENERGY_QUANTILE = 0.80      # Lautheitsschwelle (oberes 20%-Quantil)
 MIN_EVENT_DURATION = 0.25   # min. Dauer eines lauten Events (Sek.)
 
+MIN_SEGMENT_FOR_CLAP = 0.15  # minimale Segmentlänge, damit CLAP Sinn macht (Sek.)
+
 # ---------------------------------------------------------
 # 3. FUNKTION: LAUTE EVENTS FINDEN
 # ---------------------------------------------------------
@@ -82,35 +84,64 @@ def find_loud_events(y, sr):
     return events
 
 # ---------------------------------------------------------
-# 4. FUNKTION: BELL-PROBABILITÄT FÜR EIN EVENT
+# 4. BELL-SEGMENTE ERKENNEN
+#    - entweder „fast mode“ (nur Energie)
+#    - oder CLAP-basiert, aber gebatcht
 # ---------------------------------------------------------
 
-def bark_probability_for_event(y, sr, start_s, end_s):
-    start_idx = int(start_s * sr)
-    end_idx = int(end_s * sr)
+def detect_bark_windows(y, sr, loud_events, bark_prob_threshold, use_clap):
+    """
+    Gibt eine Liste von (start_s, end_s) zurück, die als Bellen gewertet werden.
+    Wenn use_clap=False: jedes laute Event = Bellen (reine Lautstärke-Logik).
+    Wenn use_clap=True: CLAP bewertet die Events.
+    """
+    if not use_clap:
+        # Fast Mode: alles, was laut ist, wird als Bellen gezählt
+        return [(s, e, 1.0) for (s, e) in loud_events]
 
-    segment = y[start_idx:end_idx]
+    # CLAP-Mode: wir batchen die Events für die Pipeline
+    segments = []
+    meta = []  # (start_s, end_s) zu jedem Segment
 
-    if len(segment) < int(0.15 * sr):
-        return 0.0
+    for (s, e) in loud_events:
+        if e - s < MIN_SEGMENT_FOR_CLAP:
+            continue
+        start_idx = int(s * sr)
+        end_idx = int(e * sr)
+        seg = y[start_idx:end_idx]
+        if len(seg) == 0:
+            continue
+        segments.append(seg)
+        meta.append((s, e))
 
-    results = classifier(
-        segment,
+    if not segments:
+        return []
+
+    # Batch-Aufruf der Pipeline (deutlich schneller als Einzel-Aufrufe)
+    results_list = classifier(
+        segments,
         candidate_labels=CANDIDATE_LABELS,
         multi_label=True,
+        batch_size=4,
     )
 
-    for r in results:
-        if r["label"].lower() == "dog barking":
-            return float(r["score"])
+    bark_windows = []
+    for (s, e), results in zip(meta, results_list):
+        bark_score = 0.0
+        for r in results:
+            if r["label"].lower() == "dog barking":
+                bark_score = float(r["score"])
+                break
+        if bark_score >= bark_prob_threshold:
+            bark_windows.append((s, e, bark_score))
 
-    return 0.0
+    return bark_windows
 
 # ---------------------------------------------------------
-# 5. HAUPT-ANALYSEFUNKTION (mit UI-Parametern)
+# 5. HAUPT-ANALYSEFUNKTION
 # ---------------------------------------------------------
 
-def analyze_barking(audio_path, max_pause_sec, bark_prob_threshold):
+def analyze_barking(audio_path, max_pause_sec, bark_prob_threshold, fast_mode):
     # 0. Upload prüfen
     if audio_path is None or audio_path == "":
         return "Es wurde keine Audiodatei hochgeladen."
@@ -130,26 +161,29 @@ def analyze_barking(audio_path, max_pause_sec, bark_prob_threshold):
     if not loud_events:
         return "Keine lauten Ereignisse gefunden – vermutlich kein Bellen."
 
-    # 3. Nur laute Events mit Modell prüfen
-    bark_windows = []
-    for (s, e) in loud_events:
-        try:
-            score = bark_probability_for_event(y, sr, s, e)
-        except Exception as ex:
-            print(f"Fehler im Modellaufruf bei {s:.2f}-{e:.2f}s: {ex}")
-            continue
-
-        if score >= bark_prob_threshold:
-            bark_windows.append((s, e, score))
+    # 3. Bellen-Segmente finden
+    bark_windows = detect_bark_windows(
+        y,
+        sr,
+        loud_events,
+        bark_prob_threshold,
+        use_clap=not fast_mode
+    )
 
     if not bark_windows:
-        return (
-            "Es wurde kein Hundebellen mit ausreichend hoher Sicherheit erkannt.\n\n"
-            f"(Schwellwert für 'dog barking' = {bark_prob_threshold:.2f})"
-        )
+        if fast_mode:
+            return (
+                "Fast Mode (ohne KI): keine ausreichend lauten Ereignisse, "
+                "die als Bellen interpretiert wurden."
+            )
+        else:
+            return (
+                "Es wurde kein Hundebellen mit ausreichend hoher Sicherheit erkannt.\n\n"
+                f"(Schwellwert für 'dog barking' = {bark_prob_threshold:.2f})"
+            )
 
-    # 4. Episoden aus Bell-Segmenten bilden
-    bark_windows.sort(key=lambda x: x[0])
+    # 4. Bell-Segmente zu Episoden zusammenfassen
+    bark_windows.sort(key=lambda x: x[0])  # nach Startzeit
 
     episodes = []
     cur_start, cur_end, _ = bark_windows[0]
@@ -168,6 +202,8 @@ def analyze_barking(audio_path, max_pause_sec, bark_prob_threshold):
     total_seconds = sum(e2 - e1 for (e1, e2) in episodes)
 
     lines = []
+    mode_text = "Fast Mode (nur Energie)" if fast_mode else "CLAP-KI-Modus"
+    lines.append(f"**Modus:** {mode_text}")
     lines.append(f"**A: Anzahl der Bell-Ereignisse:** {count}")
     lines.append(f"**B: Gesamtdauer des Bellens:** {total_seconds:.1f} Sekunden\n")
     lines.append(
@@ -182,7 +218,7 @@ def analyze_barking(audio_path, max_pause_sec, bark_prob_threshold):
     return "\n".join(lines)
 
 # ---------------------------------------------------------
-# 6. GRADIO UI – MIT SLIDERN
+# 6. GRADIO UI – MIT SLIDERN & FAST-MODE
 # ---------------------------------------------------------
 
 audio_input = gr.Audio(type="filepath", label="Audio hochladen (.wav, .mp3)")
@@ -196,23 +232,29 @@ pause_slider = gr.Slider(
 )
 
 threshold_slider = gr.Slider(
-    minimum=0.1,
+    minimum=0.01,
     maximum=0.9,
     value=0.35,
-    step=0.05,
+    step=0.01,
     label="Schwellwert für 'dog barking' (0–1)",
 )
 
+fast_checkbox = gr.Checkbox(
+    value=False,
+    label="Fast Mode (nur Lautstärke, ohne KI-Modell – sehr schnell, aber ungenauer)",
+)
+
 demo = gr.Interface(
     fn=analyze_barking,
-    inputs=[audio_input, pause_slider, threshold_slider],
+    inputs=[audio_input, pause_slider, threshold_slider, fast_checkbox],
     outputs=gr.Markdown(),
-    title="Barking Episode Analyzer (mit Parametern)",
+    title="Barking Episode Analyzer (mit Parametern & Fast Mode)",
     description=(
         "Erkennt Hundebellen in Aufnahmen.\n\n"
-        "Stell unten ein:\n"
-        "- wie lang die Pause sein darf, bevor ein neues Ereignis gezählt wird,\n"
-        "- ab welchem Schwellwert das Modell 'dog barking' als Bellen zählt."
+        "Optionen:\n"
+        "- **Maximale Pause**: ab welcher Pause ein neues Bell-Ereignis gezählt wird.\n"
+        "- **Schwellwert**: ab welcher Wahrscheinlichkeit 'dog barking' gezählt wird.\n"
+        "- **Fast Mode**: nur Lautstärke-Analyse (schnell), ohne 'dog barking'-Modell."
     ),
 )