Baby-Cry-Analysis Api

README.md

@@ -11,3 +11,167 @@ license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 👶 Baby Cry AI Service
+
+A Flask microservice that analyzes baby cry audio to identify the reason for crying using an ensemble of Hugging Face models.
+
+## 🎯 Features
+
+- **Ensemble Model Approach**: Combines supervised and zero-shot classification for improved accuracy
+- **Single Load Architecture**: Models loaded once at startup for optimal performance
+- **Docker Ready**: Production-ready containerized deployment
+- **REST API**: Simple POST endpoint for audio analysis
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Baby Cry AI Service                       │
+├─────────────────────────────────────────────────────────────┤
+│  app.py (Flask API)                                         │
+│    └── POST /analyze-cry                                    │
+│         └── inference.py                                    │
+│              ├── Supervised Model (Wiam/baby-cry-*)         │
+│              └── Zero-Shot Model (laion/clap-htsat-unfused) │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 🚀 Quick Start
+
+### Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the service
+python app.py
+```
+
+### Docker
+
+```bash
+# Build image
+docker build -t baby-cry-ai .
+
+# Run container
+docker run -p 5000:5000 baby-cry-ai
+```
+
+## 📡 API Reference
+
+### Health Check
+
+```http
+GET /health
+```
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "service": "baby-cry-ai"
+}
+```
+
+### Analyze Cry
+
+```http
+POST /analyze-cry
+Content-Type: multipart/form-data
+```
+
+**Request:**
+- `audio`: Audio file (WAV, MP3, OGG, FLAC, M4A, WebM)
+
+**Response:**
+```json
+{
+  "cry_detected": true,
+  "top_reason": "hunger",
+  "scores": {
+    "hunger": 0.45,
+    "belly_pain": 0.20,
+    "tired": 0.15,
+    "discomfort": 0.12,
+    "burping": 0.08
+  },
+  "disclaimer": "AI-generated suggestion, not a medical diagnosis. Please consult a healthcare professional for medical advice."
+}
+```
+
+### Example Usage
+
+```bash
+# Using curl
+curl -X POST http://localhost:5000/analyze-cry \
+  -F "audio=@baby_cry.wav"
+
+# Using Python requests
+import requests
+
+with open("baby_cry.wav", "rb") as f:
+    response = requests.post(
+        "http://localhost:5000/analyze-cry",
+        files={"audio": f}
+    )
+    print(response.json())
+```
+
+## 🏷️ Cry Categories
+
+| Label | Description |
+|-------|-------------|
+| `hunger` | Baby is hungry (rhythmic "neh" sound) |
+| `belly_pain` | Stomach discomfort (sharp, high-pitched) |
+| `tired` | Baby needs sleep (heavy, yawning cry) |
+| `discomfort` | General discomfort (fussy, whiny) |
+| `burping` | Needs to burp (repetitive sounds) |
+
+## 🧠 Models Used
+
+1. **Supervised Model**: `Wiam/baby-cry-classification-finetuned-babycry-v4`
+   - Fine-tuned specifically for baby cry classification
+   
+2. **Zero-Shot Model**: `laion/clap-htsat-unfused`
+   - CLAP model for audio-text matching
+   - Provides additional context via natural language prompts
+
+## 📁 Project Structure
+
+```
+baby-cry-ai-service/
+├── app.py              # Flask entry point
+├── inference.py        # Model loading & inference logic
+├── requirements.txt    # Python dependencies
+├── Dockerfile          # Container configuration
+├── .env.example        # Environment variables template
+└── README.md           # Documentation
+```
+
+## ⚙️ Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PORT` | `5000` | Server port |
+| `FLASK_DEBUG` | `false` | Enable debug mode |
+
+## 🔧 Production Deployment
+
+For production, the Docker image uses Gunicorn with:
+- Single worker (due to model memory requirements)
+- 120s timeout for large audio files
+- Health check endpoint
+
+```bash
+# Production run with custom port
+docker run -p 8080:5000 -e PORT=5000 baby-cry-ai
+```
+
+## ⚠️ Disclaimer
+
+This service provides AI-generated suggestions only and should **NOT** be used as a substitute for professional medical advice. Always consult with a healthcare professional for concerns about your baby's health.
+
+## 📄 License
+
+MIT License

app.py

@@ -0,0 +1,194 @@
+"""
+Baby Cry Analysis - Flask API for Hugging Face Spaces
+Exposes REST endpoint for audio-based baby cry classification.
+Wrapped with Gradio to keep the Space alive.
+"""
+
+from flask import Flask, request, jsonify
+import tempfile
+import os
+import logging
+import threading
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import inference module (model loads at import time)
+from inference import analyze_cry, preload_model
+
+# Preload model at startup
+preload_model()
+
+app = Flask(__name__)
+
+# Maximum file size: 16MB
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
+
+# Allowed audio extensions
+ALLOWED_EXTENSIONS = {'wav', 'mp3', 'ogg', 'flac', 'm4a', 'webm'}
+
+
+def allowed_file(filename: str) -> bool:
+    """Check if file extension is allowed."""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+@app.route("/health", methods=["GET"])
+def health():
+    """Health check endpoint."""
+    return jsonify({"status": "healthy", "service": "baby-cry-ai"})
+
+
+@app.route("/analyze-cry", methods=["POST"])
+def analyze():
+    """
+    Analyze baby cry audio file.
+    
+    Expects multipart/form-data with 'audio' file field.
+    
+    Returns:
+        JSON with cry analysis results:
+        - cry_detected: boolean
+        - top_reason: string (hunger, belly_pain, tired, discomfort, burping)
+        - scores: object with confidence scores per label
+        - disclaimer: legal disclaimer string
+    """
+    # Validate request has audio file
+    if "audio" not in request.files:
+        return jsonify({
+            "error": "No audio file provided",
+            "message": "Please upload an audio file with key 'audio'"
+        }), 400
+    
+    audio = request.files["audio"]
+    
+    # Validate filename exists
+    if audio.filename == '':
+        return jsonify({
+            "error": "Empty filename",
+            "message": "No file selected"
+        }), 400
+    
+    # Validate file extension
+    if not allowed_file(audio.filename):
+        return jsonify({
+            "error": "Invalid file type",
+            "message": f"Allowed types: {', '.join(ALLOWED_EXTENSIONS)}"
+        }), 400
+    
+    # Get original extension for temp file
+    ext = audio.filename.rsplit('.', 1)[1].lower()
+    
+    try:
+        # Save to temporary file for processing
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}") as tmp:
+            audio.save(tmp.name)
+            temp_path = tmp.name
+        
+        logger.info(f"Processing audio file: {temp_path}")
+        
+        # Run inference
+        result = analyze_cry(temp_path)
+        
+        # Add disclaimer
+        result["disclaimer"] = "AI-generated suggestion, not a medical diagnosis. Please consult a healthcare professional for medical advice."
+        
+        logger.info(f"Analysis successful: {result['top_reason']}")
+        return jsonify(result)
+    
+    except Exception as e:
+        logger.error(f"Analysis failed: {str(e)}", exc_info=True)
+        return jsonify({
+            "error": "Analysis failed",
+            "message": str(e)
+        }), 500
+    
+    finally:
+        # Clean up temp file
+        if 'temp_path' in locals() and os.path.exists(temp_path):
+            os.unlink(temp_path)
+
+
+@app.errorhandler(413)
+def too_large(e):
+    """Handle file too large error."""
+    return jsonify({
+        "error": "File too large",
+        "message": "Maximum file size is 16MB"
+    }), 413
+
+
+def run_flask():
+    """Run Flask app in background thread."""
+    app.run(host="0.0.0.0", port=7860, debug=False, use_reloader=False)
+
+
+# Start Flask in background thread
+flask_thread = threading.Thread(target=run_flask, daemon=True)
+flask_thread.start()
+
+# Gradio UI to keep the Space alive
+import gradio as gr
+
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    # 👶 Baby Cry Analysis API
+    
+    This Space hosts a REST API for analyzing baby cries using machine learning.
+    
+    ## 🔗 API Endpoints
+    
+    ### Health Check
+    ```
+    GET /health
+    ```
+    
+    ### Analyze Cry
+    ```
+    POST /analyze-cry
+    Content-Type: multipart/form-data
+    Body: audio=<file>
+    ```
+    
+    **Supported formats:** WAV, MP3, OGG, FLAC, M4A, WebM
+    
+    ## 📡 Example Usage
+    
+    ```python
+    import requests
+    
+    with open("baby_cry.wav", "rb") as f:
+        response = requests.post(
+            "https://YOUR-SPACE.hf.space/analyze-cry",
+            files={"audio": f}
+        )
+    print(response.json())
+    ```
+    
+    ## 📊 Response Format
+    
+    ```json
+    {
+      "cry_detected": true,
+      "top_reason": "hunger",
+      "scores": {
+        "hunger": 0.45,
+        "belly_pain": 0.20,
+        "tired": 0.15,
+        "discomfort": 0.12,
+        "burping": 0.08
+      },
+      "disclaimer": "AI-generated suggestion..."
+    }
+    ```
+    
+    ---
+    ⚠️ *This is an AI-generated suggestion, not a medical diagnosis.*
+    """)
+
+demo.launch(server_name="0.0.0.0", server_port=7861)
+
+
+

inference.py

@@ -0,0 +1,86 @@
+"""
+Baby Cry Analysis - Inference Module
+Optimized for Hugging Face Spaces with eager model loading.
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Model loaded at module level for single load
+_model = None
+
+# Supported cry reason labels
+LABELS = ["hunger", "belly_pain", "tired", "discomfort", "burping"]
+
+
+def preload_model():
+    """
+    Eagerly load the model at startup.
+    Called once when the app starts to avoid cold start delays.
+    """
+    global _model
+    if _model is None:
+        logger.info("🔄 Loading baby cry classification model at startup...")
+        from transformers import pipeline
+        _model = pipeline(
+            "audio-classification",
+            model="Wiam/baby-cry-classification-finetuned-babycry-v4"
+        )
+        logger.info("✅ Model loaded successfully!")
+    return _model
+
+
+def get_model():
+    """Get the loaded model instance."""
+    global _model
+    if _model is None:
+        return preload_model()
+    return _model
+
+
+def analyze_cry(audio_path: str) -> dict:
+    """
+    Analyze a baby cry audio file using the supervised classification model.
+    
+    Args:
+        audio_path: Path to the audio file (WAV format preferred)
+        
+    Returns:
+        Dictionary containing:
+        - cry_detected: boolean indicating if a cry was detected
+        - top_reason: the most likely reason for crying
+        - scores: confidence scores for each label
+    """
+    # Get preloaded model
+    model = get_model()
+    
+    # Get supervised model predictions
+    results = model(audio_path)
+    
+    # Build scores dictionary from model output
+    scores = {}
+    for r in results:
+        label = r["label"]
+        if label in LABELS:
+            scores[label] = round(r["score"], 4)
+    
+    # Ensure all labels have a score (default 0 if missing)
+    for label in LABELS:
+        if label not in scores:
+            scores[label] = 0.0
+    
+    # Determine top prediction
+    top_label = max(scores, key=scores.get)
+    top_confidence = scores[top_label]
+    
+    # Cry detection threshold
+    cry_detected = top_confidence >= 0.1
+    
+    return {
+        "cry_detected": cry_detected,
+        "top_reason": top_label if cry_detected else None,
+        "scores": scores
+    }
+
+

requirements.txt

@@ -0,0 +1,7 @@
+flask
+torch
+transformers
+librosa
+numpy
+soundfile
+gradio