Update app.py

app.py

@@ -3,13 +3,15 @@ from transformers import pipeline
 import librosa
 import numpy as np
 
-# --------- MODELL: CLAP Zero-Shot Audio-Classification ----------
+# ---------------------------------------------------------
+# 1. AUDIO-MODELL LADEN
+# ---------------------------------------------------------
+
 classifier = pipeline(
     task="zero-shot-audio-classification",
     model="laion/clap-htsat-unfused"
 )
 
-# Labels, die uns interessieren
 CANDIDATE_LABELS = [
     "dog barking",
     "dog growling",
@@ -21,29 +23,26 @@ CANDIDATE_LABELS = [
     "silence",
 ]
 
-# --------- PARAMETER ----------
-ENERGY_FRAME_MS = 25       # Frame-Länge für Energie (ms)
-ENERGY_HOP_MS = 10         # Schrittweite (ms)
-ENERGY_QUANTILE = 0.80     # oberes 20%-Quantil als Schwellwert für "laut"
-MIN_EVENT_DURATION = 0.25  # minimale Dauer eines lauten Events (in Sekunden)
+# ---------------------------------------------------------
+# 2. FESTE PARAMETER FÜR ENERGIE-ANALYSE
+# ---------------------------------------------------------
 
-BARK_PROB_THRESHOLD = 0.35         # ab welcher CLAP-Wahrscheinlichkeit "dog barking" zählt
-MAX_PAUSE_BETWEEN_BARKS = 3.0      # >3 s Pause = neues Bell-Ereignis
+ENERGY_FRAME_MS = 25        # Frame-Länge für Energie (ms)
+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.)
 
+# ---------------------------------------------------------
+# 3. FUNKTION: LAUTE EVENTS FINDEN
+# ---------------------------------------------------------
 
 def find_loud_events(y, sr):
-    """
-    Findet laute Segmente anhand der Signalenergie.
-    Gibt eine Liste von (start_s, end_s) zurück.
-    """
     frame_length = int(sr * ENERGY_FRAME_MS / 1000)
     hop_length = int(sr * ENERGY_HOP_MS / 1000)
-    if frame_length <= 0:
-        frame_length = 512
-    if hop_length <= 0:
-        hop_length = 160
 
-    # RMS-Energie pro Frame
+    frame_length = max(frame_length, 512)
+    hop_length = max(hop_length, 128)
+
     rms = librosa.feature.rms(
         y=y,
         frame_length=frame_length,
@@ -56,7 +55,6 @@ def find_loud_events(y, sr):
         hop_length=hop_length
     )
 
-    # Dynamischer Schwellwert: oberes Quantil
     thr = np.quantile(rms, ENERGY_QUANTILE)
     mask = rms > thr
 
@@ -66,18 +64,16 @@ def find_loud_events(y, sr):
 
     for i, is_loud in enumerate(mask):
         t = times[i]
+
         if is_loud and not in_event:
-            # Start eines neuen lauten Events
             in_event = True
             start_t = t
         elif not is_loud and in_event:
-            # Event endet
             end_t = t
             if end_t - start_t >= MIN_EVENT_DURATION:
                 events.append((start_t, end_t))
             in_event = False
 
-    # Falls das letzte Event bis zum Ende durchläuft
     if in_event:
         end_t = times[-1]
         if end_t - start_t >= MIN_EVENT_DURATION:
@@ -85,118 +81,141 @@ def find_loud_events(y, sr):
 
     return events
 
+# ---------------------------------------------------------
+# 4. FUNKTION: BELL-PROBABILITÄT FÜR EIN EVENT
+# ---------------------------------------------------------
+
 def bark_probability_for_event(y, sr, start_s, end_s):
-    """
-    Berechnet nur für ein kurzes Segment die Wahrscheinlichkeit für 'dog barking'.
-    """
     start_idx = int(start_s * sr)
     end_idx = int(end_s * sr)
 
-    # Audiosegment (numpy.ndarray)
     segment = y[start_idx:end_idx]
 
-    # Zu kurze Segmente ignorieren
     if len(segment) < int(0.15 * sr):
         return 0.0
 
-    # WICHTIG: Pipeline direkt mit numpy-Array aufrufen, NICHT mit dict
     results = classifier(
         segment,
         candidate_labels=CANDIDATE_LABELS,
         multi_label=True,
     )
 
-    # 'dog barking'-Score herausziehen
     for r in results:
         if r["label"].lower() == "dog barking":
             return float(r["score"])
 
     return 0.0
 
+# ---------------------------------------------------------
+# 5. HAUPT-ANALYSEFUNKTION (mit UI-Parametern)
+# ---------------------------------------------------------
 
+def analyze_barking(audio_path, max_pause_sec, bark_prob_threshold):
+    # 0. Upload prüfen
+    if audio_path is None or audio_path == "":
+        return "Es wurde keine Audiodatei hochgeladen."
+
+    # 1. Audio laden
+    try:
+        y, sr = librosa.load(audio_path, sr=16000, mono=True)
+    except Exception as e:
+        return f"Fehler beim Laden der Audiodatei: {e}"
 
-def analyze_barking(audio_path):
-    # --------- Audio laden ----------
-    y, sr = librosa.load(audio_path, sr=16000, mono=True)
     duration = len(y) / sr
     if duration == 0:
-        return "Keine gültige Audiodatei."
+        return "Die Audiodatei ist leer."
 
-    # --------- 1. Schritt: laute Events finden (schnell) ----------
+    # 2. Laute Ereignisse finden
     loud_events = find_loud_events(y, sr)
-
     if not loud_events:
-        return "Es wurden keine ausreichend lauten Ereignisse erkannt."
+        return "Keine lauten Ereignisse gefunden – vermutlich kein Bellen."
 
-    # --------- 2. Schritt: nur diese Events mit CLAP auf 'dog barking' prüfen ----------
+    # 3. Nur laute Events mit Modell prüfen
     bark_windows = []
-    for (start_s, end_s) in loud_events:
-        bark_score = bark_probability_for_event(y, sr, start_s, end_s)
-        if bark_score >= BARK_PROB_THRESHOLD:
-            bark_windows.append((start_s, end_s, bark_score))
+    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))
 
     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})"
+            f"(Schwellwert für 'dog barking' = {bark_prob_threshold:.2f})"
         )
 
-    # --------- 3. Schritt: Bell-Fenster zu Episoden zusammenfassen ----------
-    bark_windows.sort(key=lambda x: x[0])  # nach Startzeit sortieren
+    # 4. Episoden aus Bell-Segmenten bilden
+    bark_windows.sort(key=lambda x: x[0])
 
     episodes = []
-    current_start, current_end, _ = bark_windows[0]
+    cur_start, cur_end, _ = bark_windows[0]
 
-    for start, end, _ in bark_windows[1:]:
-        if start - current_end <= MAX_PAUSE_BETWEEN_BARKS:
-            # gleiches Ereignis, Ende verlängern
-            current_end = max(current_end, end)
+    for s, e, _ in bark_windows[1:]:
+        if s - cur_end <= max_pause_sec:
+            cur_end = max(cur_end, e)
         else:
-            # neues Ereignis
-            episodes.append((current_start, current_end))
-            current_start, current_end = start, end
+            episodes.append((cur_start, cur_end))
+            cur_start, cur_end = s, e
 
-    episodes.append((current_start, current_end))
+    episodes.append((cur_start, cur_end))
 
-    # --------- Kennzahlen ----------
-    count_episodes = len(episodes)
-    total_bark_duration = sum(e_end - e_start for (e_start, e_end) in episodes)
+    # 5. Kennzahlen
+    count = len(episodes)
+    total_seconds = sum(e2 - e1 for (e1, e2) in episodes)
 
     lines = []
-    lines.append(f"**A: Anzahl der Bell-Ereignisse:** {count_episodes}")
-    lines.append(f"**B: Gesamtdauer des Bellens:** {total_bark_duration:.1f} Sekunden")
-    lines.append("")
+    lines.append(f"**A: Anzahl der Bell-Ereignisse:** {count}")
+    lines.append(f"**B: Gesamtdauer des Bellens:** {total_seconds:.1f} Sekunden\n")
     lines.append(
-        f"_Regel: > {MAX_PAUSE_BETWEEN_BARKS:.0f} Sekunden Pause zwischen Bellen = neues Ereignis._"
+        f"_Regel_: > {max_pause_sec:.1f} Sekunden Pause = neues Ereignis\n"
+        f"_Schwellwert 'dog barking'_: {bark_prob_threshold:.2f}\n"
     )
-    lines.append("\n**Details je Bell-Ereignis:**")
-
-    for i, (e_start, e_end) in enumerate(episodes, start=1):
-        dur = e_end - e_start
-        lines.append(
-            f"- Ereignis {i}: von {e_start:.1f}s bis {e_end:.1f}s "
-            f"(Dauer: {dur:.1f}s)"
-        )
+    lines.append("**Details:**")
+    for i, (s, e) in enumerate(episodes, start=1):
+        dur = e - s
+        lines.append(f"- Ereignis {i}: {s:.1f}s bis {e:.1f}s — Dauer: {dur:.1f}s")
 
     return "\n".join(lines)
 
+# ---------------------------------------------------------
+# 6. GRADIO UI – MIT SLIDERN
+# ---------------------------------------------------------
+
+audio_input = gr.Audio(type="filepath", label="Audio hochladen (.wav, .mp3)")
+
+pause_slider = gr.Slider(
+    minimum=1.0,
+    maximum=10.0,
+    value=3.0,
+    step=0.5,
+    label="Maximale Pause zwischen Bellen (Sekunden)",
+)
+
+threshold_slider = gr.Slider(
+    minimum=0.1,
+    maximum=0.9,
+    value=0.35,
+    step=0.05,
+    label="Schwellwert für 'dog barking' (0–1)",
+)
 
 demo = gr.Interface(
     fn=analyze_barking,
-    inputs=gr.Audio(type="filepath", label="Audio hochladen (.wav, .mp3)"),
+    inputs=[audio_input, pause_slider, threshold_slider],
     outputs=gr.Markdown(),
-    title="Barking Episode Analyzer (schnelle CLAP-Version)",
+    title="Barking Episode Analyzer (mit Parametern)",
     description=(
-        "Analysiert Hundebellen in einer Aufnahme.\n\n"
-        "Vorgehen:\n"
-        "- Zuerst werden nur laute Segmente über die Energie erkannt (sehr schnell).\n"
-        "- Nur diese Segmente werden mit einem CLAP-Audiomodell auf 'dog barking' geprüft.\n"
-        "- Bellen-Segmente, die weniger als 3 Sekunden auseinander liegen, zählen als ein Ereignis.\n"
-        "- Ausgabe:\n"
-        "  A) Anzahl der Bell-Ereignisse\n"
-        "  B) Gesamtdauer des Bellens"
+        "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."
     ),
 )
 
 if __name__ == "__main__":
     demo.launch()
+