Update

README.md

@@ -0,0 +1,161 @@
+# Voice Sentiment Analysis System
+
+<div align="center">
+  <img src="gradio_interface.jpg" alt="Voice Sentiment Analysis Banner" width="100%">
+</div>
+
+## Project Description
+
+This project is an automated solution for analyzing customer satisfaction from voice calls. Built using state-of-the-art machine learning models, it combines **Wav2Vec 2.0** for speech-to-text transcription with **BERT** for sentiment analysis to provide real-time feedback into customer emotions and satisfaction levels.
+
+### Key Features
+- **Automatic Speech Recognition**: Convert voice calls to text using Wav2Vec 2.0
+- **Sentiment Analysis**: Analyze emotional tone using multilingual BERT
+- **Customer Satisfaction Classification**: Categorize calls as Satisfied, Dissatisfied, or Neutral
+- **Batch Processing**: Handle multiple audio files simultaneously
+- **Web Interface**: User-friendly [Gradio](https://www.gradio.app/) interface for easy interaction
+- **CSV Export**: Detailed results export for further analysis and reporting
+
+## Models Used
+
+This project uses pre-trained models hosted on Hugging Face Hub:
+
+### Speech Recognition Model
+**Wav2Vec 2.0 - English**
+- **Model:** `facebook/wav2vec2-large-960h-lv60-self`
+- **Link:** [https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self)
+- **Description:** Large Wav2Vec 2.0 model trained on 960 hours of English LibriSpeech data
+- **Use:** Audio-to-text transcription
+
+### Sentiment Analysis Model
+**BERT - Multilingual Sentiment**
+- **Model:** `nlptown/bert-base-multilingual-uncased-sentiment`
+- **Link:** [https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment](https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment)
+- **Description:** Multilingual BERT model fine-tuned for sentiment analysis (1-5 stars)
+- **Use:** Text sentiment classification
+
+
+## Project Structure
+
+```
+voice-sentiment-project/
+├── requirements.txt           # Dependencies
+├── voice_sentiment.py         # Core analyzer class
+├── api.py                     # REST API Server
+├── app.py                     # Gradio web interface  
+├── main.py                    # CLI interface
+├── utils.py                   # Utility functions and CSS styling
+├── audios/                     # Your audio files
+│   ├── call1.wav
+│   ├── call2.mp3
+│   └── ...
+└── analysis_results.csv       # Generated results
+```
+## Language Support
+
+### Current Model: English Only
+This system is currently configured with an English-only Wav2Vec 2.0 model (`facebook/wav2vec2-large-960h-lv60-self`) for optimal English speech recognition performance.
+
+### For Other Languages
+To use this system with other languages, you need to change the Wav2Vec 2.0 model in `voice_sentiment.py`.
+
+## Quick Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### 1. Web Interface (Recommended)
+
+```bash
+python app.py
+```
+
+Opens a web browser interface at `http://localhost:7860`
+
+### 2. Command Line Interface
+
+```bash
+python main.py
+```
+
+### 3. Direct Code Usage
+
+```python
+from voice_sentiment import VoiceSentimentAnalyzer
+
+# Initialize
+analyzer = VoiceSentimentAnalyzer()
+
+# Analyze one call
+result = analyzer.analyze_call("call1.wav")
+print(result)
+
+# Analyze multiple calls
+results = analyzer.analyze_batch("audios/")
+```
+
+## Example Output
+
+```python
+{
+    'file': 'call1.wav',
+    'transcription': 'Hello I am very satisfied with your service',
+    'sentiment': 'POSITIVE', 
+    'score': 0.89,
+    'satisfaction': 'Satisfied'
+}
+```
+
+## Simple Workflow
+
+```
+Audio File → Transcription (Wav2Vec2) → Sentiment (BERT) → Classification
+```
+
+Perfect for analyzing customer call sentiment quickly and easily!
+
+## Supported Audio Formats
+
+### **Fully Supported**
+- **WAV** (.wav) - *Recommended for best quality*
+- **MP3** (.mp3) - *Most common format*
+- **M4A** (.m4a) - *Apple audio format*
+
+### **Audio Specifications**
+- **Sample Rate**: Automatically converted to 16kHz
+- **Channels**: Mono or Stereo (converted to mono)
+- **Duration**: 5 seconds to 10 minutes (optimal: 30 seconds - 2 minutes)
+- **Quality**: Clear speech, minimal background noise recommended
+
+### **Not Supported**
+- Video files (MP4, AVI, MOV, etc.)
+- Other audio formats (FLAC, OGG, etc.) - *may work but not guaranteed*
+- Extremely low quality or heavily distorted audio
+- Files with encryption or DRM protection
+
+### **Audio Quality Tips**
+- Use WAV format for highest accuracy
+- Ensure clear speech recording
+- Minimize background noise
+- Optimal recording: 16kHz, 16-bit, mono
+- Test with short samples first
+
+## CSV Output & Results
+
+### **Automatic CSV Generation**
+When using batch analysis (multiple files), the system automatically generates a detailed CSV file with all results.
+
+**File**: `analysis_results.csv`
+
+**Location**: Same folder as the project
+
+### **CSV Contents**
+```csv
+File,Transcription,Sentiment,Score,Satisfaction
+call1.wav,"Hello I am very satisfied with your service",POSITIVE,0.89,Satisfied
+call2.wav,"This is unacceptable I want a refund",NEGATIVE,0.92,Dissatisfied
+call3.wav,"Can you tell me about your pricing",NEUTRAL,0.65,Neutral
+```

analysis_results.csv

@@ -0,0 +1,2 @@
+File,Transcription,Sentiment,Score,Satisfaction
+satistaction_fr.m4a,HERO GISPE I THEACCUSETRES ATISFE DE VA SERVIC RAMAND GENEREETPAT DE MATRE BONE EFONICE THE MAYOR SE...,POSITIVE,0.34,Neutral

api.py

@@ -0,0 +1,563 @@
+#!/usr/bin/env python3
+"""
+REST API for Voice Sentiment Analysis System
+Provides endpoints for integrating the pipeline into other applications
+"""
+
+from flask import Flask, request, jsonify, render_template_string
+from flask_cors import CORS
+import os
+import tempfile
+import uuid
+from voice_sentiment import VoiceSentimentAnalyzer
+import logging
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app)  # Enable CORS for cross-origin requests
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize the analyzer (singleton)
+analyzer = None
+
+def get_analyzer():
+    """Get or create analyzer instance"""
+    global analyzer
+    if analyzer is None:
+        logger.info("Initializing Voice Sentiment Analyzer...")
+        analyzer = VoiceSentimentAnalyzer()
+        logger.info("Analyzer ready!")
+    return analyzer
+
+# API Documentation HTML Template
+API_DOCS_HTML = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Voice Sentiment Analysis API Documentation</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; line-height: 1.6; }
+        .header { background: #f4f4f4; padding: 20px; border-radius: 5px; margin-bottom: 30px; }
+        .endpoint { background: #f9f9f9; padding: 15px; margin: 20px 0; border-left: 4px solid #007cba; }
+        .method { background: #007cba; color: white; padding: 3px 8px; border-radius: 3px; font-size: 12px; }
+        .method.get { background: #28a745; }
+        .method.post { background: #007cba; }
+        pre { background: #f4f4f4; padding: 15px; border-radius: 5px; overflow-x: auto; }
+        code { background: #f4f4f4; padding: 2px 4px; border-radius: 3px; }
+        .example { margin: 10px 0; }
+        h1 { color: #333; }
+        h2 { color: #007cba; border-bottom: 2px solid #007cba; padding-bottom: 5px; }
+        h3 { color: #555; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>Voice Sentiment Analysis API</h1>
+        <p><strong>Version:</strong> 1.0.0</p>
+        <p><strong>Base URL:</strong> <code>{{ base_url }}</code></p>
+        <p>Analyze customer call sentiment using Wav2Vec 2.0 + BERT pipeline</p>
+    </div>
+
+    <h2>Authentication</h2>
+    <p>No authentication required for this API.</p>
+
+    <h2>Supported Audio Formats</h2>
+    <ul>
+        <li><strong>WAV</strong> (.wav) - Recommended</li>
+        <li><strong>MP3</strong> (.mp3)</li>
+        <li><strong>M4A</strong> (.m4a)</li>
+    </ul>
+
+    <h2>API Endpoints</h2>
+
+    <div class="endpoint">
+        <h3><span class="method get">GET</span> /docs</h3>
+        <p><strong>Description:</strong> This documentation page</p>
+        <p><strong>Response:</strong> HTML documentation</p>
+    </div>
+
+    <div class="endpoint">
+        <h3><span class="method get">GET</span> /health</h3>
+        <p><strong>Description:</strong> Health check endpoint</p>
+        <p><strong>Response:</strong></p>
+        <pre><code>{
+  "status": "healthy",
+  "service": "Voice Sentiment Analysis API",
+  "version": "1.0.0"
+}</code></pre>
+    </div>
+
+    <div class="endpoint">
+        <h3><span class="method post">POST</span> /analyze</h3>
+        <p><strong>Description:</strong> Analyze a single audio file for sentiment</p>
+        <p><strong>Content-Type:</strong> multipart/form-data</p>
+        <p><strong>Parameters:</strong></p>
+        <ul>
+            <li><code>audio</code> (file, required): Audio file to analyze</li>
+        </ul>
+        
+        <div class="example">
+            <p><strong>Example Request (cURL):</strong></p>
+            <pre><code>curl -X POST \\
+  -F "audio=@call1.wav" \\
+  {{ base_url }}/analyze</code></pre>
+        </div>
+
+        <div class="example">
+            <p><strong>Example Response:</strong></p>
+            <pre><code>{
+  "success": true,
+  "data": {
+    "filename": "call1.wav",
+    "transcription": "Hello I am very satisfied with your service",
+    "sentiment": "POSITIVE",
+    "confidence_score": 0.89,
+    "satisfaction": "Satisfied"
+  },
+  "processing_id": "uuid-string"
+}</code></pre>
+        </div>
+
+        <div class="example">
+            <p><strong>Error Response:</strong></p>
+            <pre><code>{
+  "error": "Unsupported file format",
+  "message": "Supported formats: .wav, .mp3, .m4a, .flac",
+  "received": ".txt"
+}</code></pre>
+        </div>
+    </div>
+
+    <div class="endpoint">
+        <h3><span class="method post">POST</span> /analyze/batch</h3>
+        <p><strong>Description:</strong> Analyze multiple audio files</p>
+        <p><strong>Content-Type:</strong> multipart/form-data</p>
+        <p><strong>Parameters:</strong></p>
+        <ul>
+            <li><code>audio</code> (files, required): Multiple audio files to analyze</li>
+        </ul>
+
+        <div class="example">
+            <p><strong>Example Request (cURL):</strong></p>
+            <pre><code>curl -X POST \\
+  -F "audio=@call1.wav" \\
+  -F "audio=@call2.mp3" \\
+  {{ base_url }}/analyze/batch</code></pre>
+        </div>
+
+        <div class="example">
+            <p><strong>Example Response:</strong></p>
+            <pre><code>{
+  "success": true,
+  "batch_id": "uuid-string",
+  "statistics": {
+    "total_files": 2,
+    "sentiment_distribution": {
+      "POSITIVE": {"count": 1, "percentage": 50.0},
+      "NEGATIVE": {"count": 1, "percentage": 50.0}
+    },
+    "satisfaction_distribution": {
+      "Satisfied": {"count": 1, "percentage": 50.0},
+      "Dissatisfied": {"count": 1, "percentage": 50.0}
+    }
+  },
+  "results": [
+    {
+      "filename": "call1.wav",
+      "transcription": "Hello I am satisfied",
+      "sentiment": "POSITIVE",
+      "confidence_score": 0.89,
+      "satisfaction": "Satisfied",
+      "success": true
+    },
+    {
+      "filename": "call2.mp3",
+      "transcription": "This is terrible service",
+      "sentiment": "NEGATIVE",
+      "confidence_score": 0.92,
+      "satisfaction": "Dissatisfied",
+      "success": true
+    }
+  ],
+  "processed_files": 2,
+  "total_uploaded": 2
+}</code></pre>
+        </div>
+    </div>
+
+    <div class="endpoint">
+        <h3><span class="method get">GET</span> /models/info</h3>
+        <p><strong>Description:</strong> Get information about loaded models</p>
+        <p><strong>Response:</strong></p>
+        <pre><code>{
+  "speech_recognition": {
+    "model": "facebook/wav2vec2-large-960h-lv60-self",
+    "type": "Wav2Vec 2.0",
+    "language": "English",
+    "description": "Large Wav2Vec 2.0 model for English speech recognition"
+  },
+  "sentiment_analysis": {
+    "model": "nlptown/bert-base-multilingual-uncased-sentiment",
+    "type": "BERT",
+    "language": "Multilingual",
+    "description": "Multilingual BERT for sentiment analysis"
+  },
+  "supported_formats": [".wav", ".mp3", ".m4a", ".flac"],
+  "classifications": {
+    "sentiments": ["POSITIVE", "NEGATIVE", "NEUTRAL"],
+    "satisfaction": ["Satisfied", "Dissatisfied", "Neutral"]
+  }
+}</code></pre>
+    </div>
+
+    <h2>Response Codes</h2>
+    <ul>
+        <li><strong>200</strong> - Success</li>
+        <li><strong>400</strong> - Bad Request (invalid file, missing parameters)</li>
+        <li><strong>404</strong> - Endpoint Not Found</li>
+        <li><strong>413</strong> - File Too Large (>16MB)</li>
+        <li><strong>500</strong> - Internal Server Error</li>
+    </ul>
+
+    <h2>Integration Examples</h2>
+    
+    <h3>Python</h3>
+    <pre><code>import requests
+
+# Single file analysis
+with open('audio.wav', 'rb') as f:
+    response = requests.post(
+        '{{ base_url }}/analyze',
+        files={'audio': f}
+    )
+    result = response.json()
+    print(f"Sentiment: {result['data']['sentiment']}")
+
+# Batch analysis
+files = [
+    ('audio', open('call1.wav', 'rb')),
+    ('audio', open('call2.mp3', 'rb'))
+]
+response = requests.post('{{ base_url }}/analyze/batch', files=files)
+result = response.json()
+print(f"Processed {result['processed_files']} files")</code></pre>
+
+    <h3>JavaScript</h3>
+    <pre><code>// Single file upload
+const formData = new FormData();
+formData.append('audio', fileInput.files[0]);
+
+fetch('{{ base_url }}/analyze', {
+    method: 'POST',
+    body: formData
+})
+.then(response => response.json())
+.then(data => {
+    console.log('Sentiment:', data.data.sentiment);
+});</code></pre>
+
+    <h3>Node.js</h3>
+    <pre><code>const fs = require('fs');
+const FormData = require('form-data');
+
+const form = new FormData();
+form.append('audio', fs.createReadStream('call.wav'));
+
+fetch('{{ base_url }}/analyze', {
+    method: 'POST',
+    body: form
+})
+.then(response => response.json())
+.then(data => console.log(data));</code></pre>
+
+    <h2>Rate Limits</h2>
+    <p>Currently no rate limits are enforced. For production use, consider implementing rate limiting.</p>
+
+    <h2>File Size Limits</h2>
+    <ul>
+        <li><strong>Maximum file size:</strong> 16MB per file</li>
+        <li><strong>Recommended:</strong> Keep files under 5MB for faster processing</li>
+        <li><strong>Optimal duration:</strong> 30 seconds to 2 minutes</li>
+    </ul>
+
+    <footer style="margin-top: 50px; padding-top: 20px; border-top: 1px solid #eee; color: #666;">
+        <p>Voice Sentiment Analysis API - Powered by Wav2Vec 2.0 + BERT</p>
+    </footer>
+</body>
+</html>
+"""
+
+@app.route('/docs', methods=['GET'])
+@app.route('/documentation', methods=['GET'])
+@app.route('/', methods=['GET'])
+def api_documentation():
+    """API Documentation page"""
+    base_url = request.url_root.rstrip('/')
+    return render_template_string(API_DOCS_HTML, base_url=base_url)
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        "status": "healthy",
+        "service": "Voice Sentiment Analysis API",
+        "version": "1.0.0"
+    })
+
+@app.route('/analyze', methods=['POST'])
+def analyze_audio():
+    """
+    Analyze a single audio file
+    
+    Expected: multipart/form-data with 'audio' file
+    Returns: JSON with analysis results
+    """
+    try:
+        # Check if file is present
+        if 'audio' not in request.files:
+            return jsonify({
+                "error": "No audio file provided",
+                "message": "Please upload an audio file using the 'audio' field"
+            }), 400
+        
+        audio_file = request.files['audio']
+        
+        # Check if file is selected
+        if audio_file.filename == '':
+            return jsonify({
+                "error": "No file selected",
+                "message": "Please select an audio file"
+            }), 400
+        
+        # Validate file extension
+        allowed_extensions = ['.wav', '.mp3', '.m4a', '.flac']
+        file_ext = os.path.splitext(audio_file.filename)[1].lower()
+        
+        if file_ext not in allowed_extensions:
+            return jsonify({
+                "error": "Unsupported file format",
+                "message": f"Supported formats: {', '.join(allowed_extensions)}",
+                "received": file_ext
+            }), 400
+        
+        # Save file temporarily
+        temp_id = str(uuid.uuid4())
+        temp_filename = f"temp_audio_{temp_id}{file_ext}"
+        temp_path = os.path.join(tempfile.gettempdir(), temp_filename)
+        
+        audio_file.save(temp_path)
+        
+        try:
+            # Analyze the audio
+            analyzer = get_analyzer()
+            result = analyzer.analyze_call(temp_path)
+            
+            # Clean up temporary file
+            os.remove(temp_path)
+            
+            # Return results
+            return jsonify({
+                "success": True,
+                "data": {
+                    "filename": audio_file.filename,
+                    "transcription": result['transcription'],
+                    "sentiment": result['sentiment'],
+                    "confidence_score": round(result['score'], 3),
+                    "satisfaction": result['satisfaction']
+                },
+                "processing_id": temp_id
+            })
+        
+        except Exception as e:
+            # Clean up on error
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+            raise e
+            
+    except Exception as e:
+        logger.error(f"Error processing audio: {str(e)}")
+        return jsonify({
+            "error": "Processing failed",
+            "message": str(e)
+        }), 500
+
+@app.route('/analyze/batch', methods=['POST'])
+def analyze_batch():
+    """
+    Analyze multiple audio files
+    
+    Expected: multipart/form-data with multiple 'audio' files
+    Returns: JSON with batch analysis results
+    """
+    try:
+        # Check if files are present
+        if 'audio' not in request.files:
+            return jsonify({
+                "error": "No audio files provided",
+                "message": "Please upload audio files using the 'audio' field"
+            }), 400
+        
+        audio_files = request.files.getlist('audio')
+        
+        if not audio_files or all(f.filename == '' for f in audio_files):
+            return jsonify({
+                "error": "No files selected",
+                "message": "Please select audio files"
+            }), 400
+        
+        results = []
+        temp_files = []
+        batch_id = str(uuid.uuid4())
+        
+        try:
+            # Process each file
+            for i, audio_file in enumerate(audio_files):
+                if audio_file.filename == '':
+                    continue
+                
+                # Validate file extension
+                allowed_extensions = ['.wav', '.mp3', '.m4a', '.flac']
+                file_ext = os.path.splitext(audio_file.filename)[1].lower()
+                
+                if file_ext not in allowed_extensions:
+                    results.append({
+                        "filename": audio_file.filename,
+                        "error": f"Unsupported format: {file_ext}",
+                        "success": False
+                    })
+                    continue
+                
+                # Save file temporarily
+                temp_filename = f"batch_{batch_id}_{i}{file_ext}"
+                temp_path = os.path.join(tempfile.gettempdir(), temp_filename)
+                temp_files.append(temp_path)
+                
+                audio_file.save(temp_path)
+                
+                # Analyze the audio
+                analyzer = get_analyzer()
+                result = analyzer.analyze_call(temp_path)
+                
+                results.append({
+                    "filename": audio_file.filename,
+                    "transcription": result['transcription'],
+                    "sentiment": result['sentiment'],
+                    "confidence_score": round(result['score'], 3),
+                    "satisfaction": result['satisfaction'],
+                    "success": True
+                })
+            
+            # Calculate statistics
+            successful_results = [r for r in results if r.get('success', False)]
+            total_files = len(successful_results)
+            
+            if total_files > 0:
+                sentiment_counts = {}
+                satisfaction_counts = {}
+                
+                for result in successful_results:
+                    sentiment = result['sentiment']
+                    satisfaction = result['satisfaction']
+                    
+                    sentiment_counts[sentiment] = sentiment_counts.get(sentiment, 0) + 1
+                    satisfaction_counts[satisfaction] = satisfaction_counts.get(satisfaction, 0) + 1
+                
+                statistics = {
+                    "total_files": total_files,
+                    "sentiment_distribution": {
+                        k: {"count": v, "percentage": round(v/total_files*100, 1)} 
+                        for k, v in sentiment_counts.items()
+                    },
+                    "satisfaction_distribution": {
+                        k: {"count": v, "percentage": round(v/total_files*100, 1)} 
+                        for k, v in satisfaction_counts.items()
+                    }
+                }
+            else:
+                statistics = {"total_files": 0, "message": "No files processed successfully"}
+            
+            return jsonify({
+                "success": True,
+                "batch_id": batch_id,
+                "statistics": statistics,
+                "results": results,
+                "processed_files": len(successful_results),
+                "total_uploaded": len([f for f in audio_files if f.filename != ''])
+            })
+        
+        finally:
+            # Clean up temporary files
+            for temp_path in temp_files:
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+                    
+    except Exception as e:
+        logger.error(f"Error processing batch: {str(e)}")
+        return jsonify({
+            "error": "Batch processing failed",
+            "message": str(e)
+        }), 500
+
+@app.route('/models/info', methods=['GET'])
+def model_info():
+    """Get information about loaded models"""
+    return jsonify({
+        "speech_recognition": {
+            "model": "facebook/wav2vec2-large-960h-lv60-self",
+            "type": "Wav2Vec 2.0",
+            "language": "English",
+            "description": "Large Wav2Vec 2.0 model for English speech recognition"
+        },
+        "sentiment_analysis": {
+            "model": "nlptown/bert-base-multilingual-uncased-sentiment",
+            "type": "BERT",
+            "language": "Multilingual",
+            "description": "Multilingual BERT for sentiment analysis (1-5 stars)"
+        },
+        "supported_formats": [".wav", ".mp3", ".m4a", ".flac"],
+        "classifications": {
+            "sentiments": ["POSITIVE", "NEGATIVE", "NEUTRAL"],
+            "satisfaction": ["Satisfied", "Dissatisfied", "Neutral"]
+        }
+    })
+
+@app.errorhandler(413)
+def file_too_large(error):
+    """Handle file too large error"""
+    return jsonify({
+        "error": "File too large",
+        "message": "Audio file exceeds maximum size limit"
+    }), 413
+
+@app.errorhandler(404)
+def not_found(error):
+    """Handle 404 errors"""
+    return jsonify({
+        "error": "Endpoint not found",
+        "message": "The requested endpoint does not exist",
+        "available_endpoints": [
+            "GET /health - Health check",
+            "POST /analyze - Analyze single audio file",
+            "POST /analyze/batch - Analyze multiple audio files",
+            "GET /models/info - Get model information"
+        ]
+    }), 404
+
+if __name__ == '__main__':
+    # Configuration
+    HOST = os.getenv('API_HOST', '0.0.0.0')
+    PORT = int(os.getenv('API_PORT', 8000))
+    DEBUG = os.getenv('API_DEBUG', 'False').lower() == 'true'
+    
+    # Set maximum file size (16MB)
+    app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
+    
+    print(f"Starting Voice Sentiment Analysis API...")
+    print(f"Server: http://{HOST}:{PORT}")
+    print(f"Health check: http://{HOST}:{PORT}/health")
+    print(f"Documentation: See README for API usage examples")
+    
+    app.run(host=HOST, port=PORT, debug=DEBUG)

app.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Gradio Interface for Voice Sentiment Analysis
+Wav2Vec 2.0 + BERT Pipeline
+"""
+
+import gradio as gr
+import pandas as pd
+import os
+from utils import custom_css
+from voice_sentiment import VoiceSentimentAnalyzer
+
+# Initialize model (once)
+print("Loading models...")
+analyzer = VoiceSentimentAnalyzer()
+print("Models ready!")
+
+def analyze_audio_file(audio_file):
+    """Analyze an uploaded audio file"""
+    if audio_file is None:
+        return "No audio file provided", "", "", ""
+    
+    try:
+        # Analyze the call
+        result = analyzer.analyze_call(audio_file)
+        
+        # Format results
+        transcription = result['transcription']
+        sentiment = result['sentiment']
+        score = f"{result['score']:.2f}"
+        satisfaction = result['satisfaction']
+        
+        # Emoji based on sentiment
+        emoji_map = {
+            "POSITIVE": "😊",
+            "NEGATIVE": "😠", 
+            "NEUTRAL": "😐"
+        }
+        emoji = emoji_map.get(sentiment, "❓")
+        
+        status = f"Analysis completed {emoji}"
+        
+        return status, transcription, sentiment, score, satisfaction
+        
+    except Exception as e:
+        error_msg = f"Analysis error: {str(e)}"
+        return error_msg, "", "", "", ""
+
+def analyze_batch_files(files):
+    """Analyze multiple audio files"""
+    if not files:
+        return "No files provided", None
+    
+    try:
+        results = []
+        
+        for file in files:
+            result = analyzer.analyze_call(file.name)
+            results.append({
+                "File": os.path.basename(file.name),
+                "Transcription": result['transcription'][:100] + "..." if len(result['transcription']) > 100 else result['transcription'],
+                "Sentiment": result['sentiment'],
+                "Score": round(result['score'], 2),
+                "Satisfaction": result['satisfaction']
+            })
+        
+        # Create DataFrame for display
+        df = pd.DataFrame(results)
+        csv_filename = "analysis_results.csv"
+
+        print(f"Saving {len(df)} rows to CSV...")
+        df.to_csv(csv_filename, index=False)
+        print(f"CSV saved successfully")  # 
+
+        # Verify CSV was created and has content
+        if os.path.exists(csv_filename):  # ← NEW DEBUG BLOCK
+            file_size = os.path.getsize(csv_filename)
+            print(f"CSV file exists, size: {file_size} bytes")
+        else:
+            print("CSV file was not created!")
+
+        
+        # Statistics
+        total = len(results)
+        positive = len([r for r in results if r['Sentiment'] == 'POSITIVE'])
+        negative = len([r for r in results if r['Sentiment'] == 'NEGATIVE'])
+        neutral = len([r for r in results if r['Sentiment'] == 'NEUTRAL'])
+        
+        stats = f"""📊 Statistics:
+• Total: {total} calls
+• Positive: {positive} ({positive/total*100:.1f}%)
+• Negative: {negative} ({negative/total*100:.1f}%)
+• Neutral: {neutral} ({neutral/total*100:.1f}%)"""
+        
+        return stats, df
+        
+    except Exception as e:
+        error_msg = f"Analysis error: {str(e)}"
+        return error_msg, None
+
+# Gradio Interface
+with gr.Blocks(title="Voice Sentiment Analysis", theme=gr.themes.Soft(), css=custom_css) as app:
+    
+    gr.Markdown("""
+    # Voice Sentiment Analysis System
+    ### Wav2Vec 2.0 + BERT Pipeline
+    
+    Automatically analyze customer call sentiment and classify satisfaction.
+    """)
+    
+    with gr.Tabs():
+        
+        # Tab 1: Single file analysis
+        with gr.Tab("Single File"):
+            gr.Markdown("### Analyze one voice call")
+            
+            with gr.Row():
+                with gr.Column():
+                    audio_input = gr.Audio(
+                        type="filepath",
+                        label="Upload your audio file"
+                    )
+                    
+                    analyze_btn = gr.Button(
+                        "Analyze", 
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column():
+                    status_output = gr.Textbox(
+                        label="📊 Status",
+                        interactive=False
+                    )
+                    
+                    transcription_output = gr.Textbox(
+                        label="📝 Transcription",
+                        lines=3,
+                        interactive=False
+                    )
+                    
+                    with gr.Row():
+                        sentiment_output = gr.Textbox(
+                            label="🎭 Sentiment",
+                            interactive=False
+                        )
+                        score_output = gr.Textbox(
+                            label="🎯 Confidence Score",
+                            interactive=False
+                        )
+                    
+                    satisfaction_output = gr.Textbox(
+                        label="😊 Customer Satisfaction",
+                        interactive=False
+                    )
+        
+        # Tab 2: Multiple files analysis
+        with gr.Tab("Multiple Files"):
+            gr.Markdown("### Analyze multiple calls in batch")
+            
+            files_input = gr.File(
+                file_count="multiple",
+                file_types=[".wav", ".mp3", ".m4a"],
+                label="Upload your audio files"
+            )
+            
+            batch_analyze_btn = gr.Button(
+                "Analyze All", 
+                variant="primary",
+                size="lg"
+            )
+            
+            batch_status = gr.Textbox(
+                label="Statistics",
+                lines=6,
+                interactive=False
+            )
+            
+            results_table = gr.Dataframe(
+                label="Detailed Results",
+                interactive=False
+            )
+    
+    # Tab 3: Information
+    with gr.Tab("Information"):
+        gr.Markdown("""
+        ### How it works?
+        
+        **3-step pipeline:**
+        1. **Audio → Text**: Transcription with Wav2Vec 2.0
+        2. **Text → Sentiment**: Analysis with multilingual BERT  
+        3. **Classification**: Customer satisfaction (Satisfied/Dissatisfied/Neutral)
+        
+        ### Supported formats
+        - WAV (recommended)
+        - MP3
+        - M4A
+        
+        ### Classifications
+        - **😊 Satisfied**: Positive sentiment with high confidence
+        - **😠 Dissatisfied**: Negative sentiment with high confidence
+        - **😐 Neutral**: Neutral sentiment or low confidence
+        
+        ### Tips
+        - Clear audio quality recommended
+        - Optimal duration: 10 seconds to 2 minutes
+        - Avoid excessive background noise
+        """)
+    
+    # Event connections
+    analyze_btn.click(
+        fn=analyze_audio_file,
+        inputs=[audio_input],
+        outputs=[status_output, transcription_output, sentiment_output, score_output, satisfaction_output]
+    )
+    
+    batch_analyze_btn.click(
+        fn=analyze_batch_files,
+        inputs=[files_input],
+        outputs=[batch_status, results_table]
+    )
+
+# Launch the application
+if __name__ == "__main__":
+    app.launch(
+        share=True,  # Creates a public link
+        server_name="0.0.0.0",  # Accessible from other machines
+        server_port=7860
+    )

main.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""
+Main script for voice sentiment analysis
+"""
+
+from voice_sentiment import VoiceSentimentAnalyzer
+import os
+
+def main():
+    """Main function"""
+    print("VOICE SENTIMENT ANALYSIS SYSTEM")
+    print("="*50)
+    
+    # Initialize the system
+    analyzer = VoiceSentimentAnalyzer()
+    
+    # Simple menu
+    while True:
+        print("\nOptions:")
+        print("1. Analyze an audio file")
+        print("2. Analyze a folder of calls")
+        print("3. Exit")
+        
+        choice = input("\nYour choice (1-3): ").strip()
+        
+        if choice == "1":
+            # Single file analysis
+            file_path = input("Audio file path: ").strip()
+            
+            if os.path.exists(file_path):
+                try:
+                    result = analyzer.analyze_call(file_path)
+                    print("\nAnalysis completed!")
+                except Exception as e:
+                    print(f"Error: {e}")
+            else:
+                print("File not found!")
+        
+        elif choice == "2":
+            # Folder analysis
+            folder_path = input("Folder path: ").strip()
+            
+            if os.path.exists(folder_path):
+                try:
+                    results = analyzer.analyze_batch(folder_path)
+                    print(f"\n{len(results)} files analyzed!")
+                except Exception as e:
+                    print(f"Error: {e}")
+            else:
+                print("Folder not found!")
+        
+        elif choice == "3":
+            print("Goodbye!")
+            break
+        
+        else:
+            print("Invalid choice!")
+
+if __name__ == "__main__":
+    main()

render.yaml

@@ -0,0 +1,9 @@
+services:
+  - type: web
+    name: voice-sentiment-api
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: gunicorn --bind 0.0.0.0:$PORT --timeout 300 api:app
+    envVars:
+      - key: PYTHON_VERSION
+        value: 3.9.18

requirements.txt

@@ -0,0 +1,12 @@
+torch>=1.9.0
+transformers>=4.20.0
+librosa>=0.9.0
+pandas>=1.3.0
+numpy>=1.21.0
+scipy>=1.7.0
+torchaudio>=0.9.0
+soundfile>=0.10.0
+gradio>=4.0.0
+flask>=2.0.0
+flask-cors>=3.0.0
+gunicorn>=20.0.0

utils.py

@@ -0,0 +1,18 @@
+# Custom CSS for Helvetica font
+custom_css = """
+* {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif !important;
+}
+
+.gradio-container {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif !important;
+}
+
+.gr-textbox, .gr-button, .gr-markdown, .gr-label {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif !important;
+}
+
+h1, h2, h3, h4, h5, h6 {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif !important;
+}
+"""

voice_sentiment.py

@@ -0,0 +1,128 @@
+"""
+Simple Voice Sentiment Analysis System
+Wav2Vec 2.0 + BERT Pipeline
+"""
+
+import torch
+import librosa
+import numpy as np
+from transformers import (
+    Wav2Vec2ForCTC, 
+    Wav2Vec2Tokenizer, 
+    pipeline
+)
+import pandas as pd
+import os
+
+class VoiceSentimentAnalyzer:
+    """Simple Pipeline: Audio → Transcription → Sentiment Analysis"""
+    
+    def __init__(self):
+        print("Loading models...")
+        
+        # ASR Model (Speech-to-Text)
+        self.asr_tokenizer = Wav2Vec2Tokenizer.from_pretrained("facebook/wav2vec2-large-960h-lv60-self")
+        self.asr_model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h-lv60-self")
+        
+        # Sentiment Model
+        self.sentiment_analyzer = pipeline(
+            "sentiment-analysis",
+            model="nlptown/bert-base-multilingual-uncased-sentiment"
+        )
+        
+        print("Models loaded!")
+    
+    def audio_to_text(self, audio_path):
+        """Convert audio to text"""
+        # Load and preprocess audio
+        audio, sr = librosa.load(audio_path, sr=16000)
+        
+        # Transcription with Wav2Vec2
+        input_values = self.asr_tokenizer(audio, return_tensors="pt", sampling_rate=16000).input_values
+        
+        with torch.no_grad():
+            logits = self.asr_model(input_values).logits
+        
+        predicted_ids = torch.argmax(logits, dim=-1)
+        transcription = self.asr_tokenizer.decode(predicted_ids[0])
+        
+        return transcription.strip()
+    
+    def text_to_sentiment(self, text):
+        """Analyze sentiment of the text"""
+        if not text:
+            return {"sentiment": "NEUTRAL", "score": 0.0}
+        
+        result = self.sentiment_analyzer(text)[0]
+        
+        # Convert labels to simple format
+        label_map = {
+            "1 star": "NEGATIVE", "2 stars": "NEGATIVE",
+            "3 stars": "NEUTRAL", 
+            "4 stars": "POSITIVE", "5 stars": "POSITIVE"
+        }
+        
+        sentiment = label_map.get(result['label'], result['label'])
+        
+        return {
+            "sentiment": sentiment,
+            "score": result['score']
+        }
+    
+    def classify_satisfaction(self, sentiment, score):
+        """Classify customer satisfaction"""
+        if sentiment == "POSITIVE" and score > 0.7:
+            return "Satisfied"
+        elif sentiment == "NEGATIVE" and score > 0.7:
+            return "Dissatisfied"
+        else:
+            return "Neutral"
+    
+    def analyze_call(self, audio_path):
+        """Complete pipeline: Audio → Sentiment → Classification"""
+        print(f"Analyzing: {audio_path}")
+        
+        # 1. Audio → Text
+        transcription = self.audio_to_text(audio_path)
+        print(f"Transcription: {transcription}")
+        
+        # 2. Text → Sentiment
+        sentiment_result = self.text_to_sentiment(transcription)
+        print(f"Sentiment: {sentiment_result['sentiment']} (score: {sentiment_result['score']:.2f})")
+        
+        # 3. Satisfaction classification
+        satisfaction = self.classify_satisfaction(sentiment_result['sentiment'], sentiment_result['score'])
+        print(f"Satisfaction: {satisfaction}")
+        
+        return {
+            "file": os.path.basename(audio_path),
+            "transcription": transcription,
+            "sentiment": sentiment_result['sentiment'],
+            "score": sentiment_result['score'],
+            "satisfaction": satisfaction
+        }
+    
+    def analyze_batch(self, audio_folder):
+        """Analyze a folder of calls"""
+        results = []
+        
+        for filename in os.listdir(audio_folder):
+            if filename.endswith(('.wav', '.mp3', '.m4a')):
+                audio_path = os.path.join(audio_folder, filename)
+                result = self.analyze_call(audio_path)
+                results.append(result)
+                print("-" * 50)
+        
+        # Save to CSV
+        df = pd.DataFrame(results)
+        df.to_csv("analysis_results.csv", index=False)
+        print(f"Results saved: analysis_results.csv")
+        
+        # Quick statistics
+        print("\nSTATISTICS:")
+        print(f"Total calls: {len(results)}")
+        sentiment_counts = df['sentiment'].value_counts()
+        for sentiment, count in sentiment_counts.items():
+            print(f"{sentiment}: {count}")
+        
+        return df