Update app.py

app.py

@@ -3,20 +3,32 @@ from transformers import pipeline
 import librosa
 import numpy as np
 
-# Zero-shot Audio Classifier (CLAP)
+# Audio-Klassifikationsmodell (AudioSet, erkennt u.a. "Dog_bark")
 classifier = pipeline(
-    task="zero-shot-audio-classification",
-    model="laion/clap-htsat-unfused"
+    task="audio-classification",
+    model="MIT/ast-finetuned-audioset-10-10-0.4593"
 )
 
-# Wir interessieren uns nur für "dog barking"
-DOG_LABEL = "dog barking"
+# Parameter
+WINDOW_SECONDS = 1.5            # Länge eines Analysefensters
+HOP_SECONDS = 0.75              # Schrittweite zwischen Fenstern
+BARK_THRESHOLD = 0.5            # ab welchem Score gilt es als Bellen
+MAX_PAUSE_BETWEEN_BARKS = 3.0   # >3 s Pause = neues Ereignis
 
-# Parameter für die Analyse
-WINDOW_SECONDS = 1.5   # Länge eines Analysefensters
-HOP_SECONDS = 0.75     # Schrittweite zwischen Fenstern
-BARK_THRESHOLD = 0.5   # Ab welcher Wahrscheinlichkeit gilt das Fenster als "bellen"
-MAX_PAUSE_BETWEEN_BARKS = 3.0  # >3 s Pause = neues Bell-Ereignis
+
+def bark_score_for_segment(segment, sr):
+    """
+    Liefert den höchsten Score für ein Label, das "dog" und/oder "bark" enthält.
+    """
+    results = classifier({"array": segment, "sampling_rate": sr})
+
+    bark_score = 0.0
+    for r in results:
+        label = r["label"].lower()
+        if "dog" in label or "bark" in label:
+            if r["score"] > bark_score:
+                bark_score = float(r["score"])
+    return bark_score
 
 
 def analyze_barking(audio_path):
@@ -29,7 +41,7 @@ def analyze_barking(audio_path):
 
     bark_windows = []
 
-    # Überlappende Fenster über die gesamte Aufnahme schieben
+    # Überlappende Fenster
     t = 0.0
     while t < duration:
         start = t
@@ -38,62 +50,54 @@ def analyze_barking(audio_path):
         end_idx = int(end * sr)
         segment = y[start_idx:end_idx]
 
-        # Leere / extrem leise Segmente überspringen
+        # Sehr leise/leer überspringen
         if len(segment) == 0 or np.mean(np.abs(segment)) < 1e-4:
             t += HOP_SECONDS
             continue
 
-        # CLAP auf dieses Segment anwenden
-        result = classifier(
-            {"array": segment, "sampling_rate": sr},
-            candidate_labels=[DOG_LABEL],
-            multi_label=False
-        )
-
-        score = result[0]["score"]  # Wahrscheinlichkeit für "dog barking"
+        score = bark_score_for_segment(segment, sr)
 
         if score >= BARK_THRESHOLD:
-            # Dieses Fenster als "Bellen" markieren
-            bark_windows.append((start, end))
+            bark_windows.append((start, end, score))
 
         t += HOP_SECONDS
 
     if not bark_windows:
-        return "Es wurde kein deutliches Hundebellen erkannt (über Schwellwert)."
+        return (
+            "Es wurde kein Hundebellen mit ausreichend hoher Sicherheit erkannt.\n\n"
+            f"(Schwellwert BARK_THRESHOLD = {BARK_THRESHOLD})"
+        )
 
-    # Fenster zu Episoden zusammenfassen:
-    # Wenn zwischen Fenstern > MAX_PAUSE_BETWEEN_BARKS Sekunden Pause ist,
-    # startet eine neue Bell-Episode.
+    # Fenster zu Bell-Episoden zusammenfassen
     episodes = []
-    current_start, current_end = bark_windows[0]
+    current_start, current_end, _ = bark_windows[0]
 
-    for start, end in bark_windows[1:]:
+    for start, end, _ in bark_windows[1:]:
         if start - current_end <= MAX_PAUSE_BETWEEN_BARKS:
-            # Gleiches Bell-Ereignis, wir verlängern das Ende
+            # gleiches Ereignis, Ende verlängern
             current_end = max(current_end, end)
         else:
-            # Neues Bell-Ereignis
+            # neues Ereignis
             episodes.append((current_start, current_end))
             current_start, current_end = start, end
 
-    # Letzte Episode hinzufügen
     episodes.append((current_start, current_end))
 
-    # Kennzahlen berechnen
     count_episodes = len(episodes)
     total_bark_duration = sum(e_end - e_start for e_start, e_end in episodes)
 
-    # Schöne Textausgabe bauen
     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"_Regel: > {MAX_PAUSE_BETWEEN_BARKS:.0f} Sekunden Pause = neues Ereignis._")
     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"
+            f"(Dauer: {dur:.1f}s)"
         )
 
     return "\n".join(lines)
@@ -103,16 +107,19 @@ demo = gr.Interface(
     fn=analyze_barking,
     inputs=gr.Audio(type="filepath", label="Audio hochladen (.wav, .mp3)"),
     outputs=gr.Markdown(),
-    title="Barking Episode Analyzer",
+    title="Barking Episode Analyzer (AudioSet)",
     description=(
         "Analysiert Hundebellen in einer Aufnahme.\n\n"
-        "Regeln:\n"
-        "- Bellen wird in Zeitfenstern erkannt.\n"
-        "- Wenn länger als 3 Sekunden Pause zwischen Bell-Fenstern ist, "
-        "gilt das als neues Bell-Ereignis.\n"
-        "- Ausgabe: Anzahl der Ereignisse (A) und Gesamtdauer des Bellens (B)."
+        "Logik:\n"
+        "- Das Audio wird in überlappende Fenster geteilt.\n"
+        "- In jedem Fenster wird geprüft, ob ein Label mit 'dog'/'bark' hoch genug ist.\n"
+        "- Bellen-Fenster, die weniger als 3 Sekunden auseinander liegen, werden zu einem Ereignis zusammengefasst.\n"
+        "- Ausgabe:\n"
+        "  A) Anzahl der Bell-Ereignisse\n"
+        "  B) Gesamtdauer des Bellens"
     ),
 )
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     demo.launch()
+