Update app.py

app.py

@@ -1,46 +1,118 @@
 import gradio as gr
 from transformers import pipeline
+import librosa
+import numpy as np
 
-# Zero-shot Audio Classifier mit CLAP
+# Zero-shot Audio Classifier (CLAP)
 classifier = pipeline(
     task="zero-shot-audio-classification",
     model="laion/clap-htsat-unfused"
 )
 
-# Unsere interessanten Geräusch-Kategorien
-CANDIDATE_LABELS = [
-    "dog barking",
-    "dog growling",
-    "people talking",
-    "traffic noise",
-    "car passing",
-    "bird singing",
-    "music",
-    "wind",
-    "rain",
-    "silence"
-]
-
-def classify(audio_file_path):
-    """
-    audio_file_path ist ein Dateipfad, weil wir Gradio mit type='filepath' benutzen.
-    """
-    results = classifier(
-        audio_file_path,
-        candidate_labels=CANDIDATE_LABELS,
-        multi_label=True  # mehrere Geräusche gleichzeitig möglich
-    )
-
-    # In ein Dictionary Label -> Score umwandeln
-    return {r["label"]: float(r["score"]) for r in results}
+# Wir interessieren uns nur für "dog barking"
+DOG_LABEL = "dog barking"
+
+# 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 analyze_barking(audio_path):
+    # Audio laden (Mono, 16 kHz)
+    y, sr = librosa.load(audio_path, sr=16000, mono=True)
+    duration = len(y) / sr
+
+    if duration == 0:
+        return "Keine gültige Audiodatei."
+
+    bark_windows = []
+
+    # Überlappende Fenster über die gesamte Aufnahme schieben
+    t = 0.0
+    while t < duration:
+        start = t
+        end = min(t + WINDOW_SECONDS, duration)
+        start_idx = int(start * sr)
+        end_idx = int(end * sr)
+        segment = y[start_idx:end_idx]
+
+        # Leere / extrem leise Segmente ü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"
+
+        if score >= BARK_THRESHOLD:
+            # Dieses Fenster als "Bellen" markieren
+            bark_windows.append((start, end))
+
+        t += HOP_SECONDS
+
+    if not bark_windows:
+        return "Es wurde kein deutliches Hundebellen erkannt (über Schwellwert)."
+
+    # Fenster zu Episoden zusammenfassen:
+    # Wenn zwischen Fenstern > MAX_PAUSE_BETWEEN_BARKS Sekunden Pause ist,
+    # startet eine neue Bell-Episode.
+    episodes = []
+    current_start, current_end = bark_windows[0]
+
+    for start, end in bark_windows[1:]:
+        if start - current_end <= MAX_PAUSE_BETWEEN_BARKS:
+            # Gleiches Bell-Ereignis, wir verlängern das Ende
+            current_end = max(current_end, end)
+        else:
+            # Neues Bell-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("\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"
+        )
+
+    return "\n".join(lines)
+
 
 demo = gr.Interface(
-    fn=classify,
-    inputs=gr.Audio(type="filepath", label="Audio hochladen"),
-    outputs=gr.Label(num_top_classes=5, label="Erkannte Geräusche"),
-    title="Barking Detection (CLAP Zero-Shot)",
-    description="Lade eine Aufnahme hoch. Das Modell schätzt u.a., ob ein Hund bellt."
+    fn=analyze_barking,
+    inputs=gr.Audio(type="filepath", label="Audio hochladen (.wav, .mp3)"),
+    outputs=gr.Markdown(),
+    title="Barking Episode Analyzer",
+    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)."
+    ),
 )
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     demo.launch()