updated

Dockerfile

@@ -13,6 +13,6 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-EXPOSE 8000
+EXPOSE 7860
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,148 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, HTMLResponse
+import sounddevice as sd
+import numpy as np
+import librosa
+import joblib
+import uvicorn
+import threading
+import asyncio
+import logging
+from typing import List
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+@app.get("/", response_class=HTMLResponse)
+async def get(request: Request):
+    logger.info("Saving the index page")
+    with open("templates/index.html") as f:
+        html_content = f.read()
+    return HTMLResponse(content=html_content, status_code=200)
+
+@app.get("/health")
+def health_check():
+    return {"status": "ok"}
+
+# @app.get("/")
+# def read_root():
+#     return {"status": "ok"}
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+duration = 2
+sample_rate = 16000
+
+is_detecting = False
+detection_thread = None
+
+model = joblib.load('models/xgb_test.pkl')
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.append(websocket)
+
+    def disconnect(self, websocket: WebSocket):
+        self.active_connections.remove(websocket)
+
+    async def send_message(self, message: str):
+        for connection in self.active_connections:
+            await connection.send_text(message)
+
+manager = ConnectionManager()
+
+def extract_features(audio):
+    sr = 16000
+
+    mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)
+    mfccs = np.mean(mfccs, axis=1)
+
+    chroma = librosa.feature.chroma_stft(y=audio, sr=sr)
+    chroma = np.mean(chroma, axis=1)
+
+    contrast = librosa.feature.spectral_contrast(y=audio, sr=sr)
+    contrast = np.mean(contrast, axis=1)
+
+    centroid = librosa.feature.spectral_centroid(y=audio, sr=sr)
+    centroid = np.mean(centroid, axis=1)
+
+    combined_features = np.hstack([mfccs, chroma, contrast, centroid])
+    return combined_features
+
+async def audio_callback(indata, frames, time, status):
+    if status:
+        print(status)
+
+    audio_data = indata[:, 0]
+    print(f"Audio data: {audio_data[:10]}... (length: {len(audio_data)})")
+    logger.info(f"Audio data: {audio_data[:10]}... (length: {len(audio_data)})")
+    
+    features = extract_features(audio_data)
+    features = features.reshape(1, -1)
+    prediction = model.predict(features)
+    is_fake = prediction[0]
+
+    print(f"Prediction: {is_fake}")
+    logger.info(f"Prediction: {is_fake}")
+
+    result = 'fake' if is_fake else 'real'
+    
+    print(f"Detected {result} audio")
+    logger.info(f"Detected {result} audio")
+
+    await manager.send_message(result)
+
+def detect_fake_audio():
+    global is_detecting
+    try:
+        with sd.InputStream(callback=lambda indata, frames, time, status: asyncio.run(audio_callback(indata, frames, time, status)), channels=1, samplerate=sample_rate, blocksize=int(sample_rate * duration)):
+            print("Listening...")
+            logger.info("Listening...")
+            while is_detecting:
+                sd.sleep(duration * 1000)
+    except Exception as e:
+        print(f"Exception: {str(e)}")
+        logger.info(f"Exception: {str(e)}")
+
+@app.post("/start_detection")
+async def start_detection():
+    global is_detecting, detection_thread
+
+    if not is_detecting:
+        is_detecting = True
+        detection_thread = threading.Thread(target=detect_fake_audio)
+        detection_thread.start()
+    return JSONResponse(content={'status': 'detection_started'})
+
+@app.post("/stop_detection")
+async def stop_detection():
+    global is_detecting, detection_thread
+    is_detecting = False
+    if detection_thread:
+        detection_thread.join()
+    return JSONResponse(content={'status': 'detection_stopped'})
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await manager.connect(websocket)
+    try:
+        while True:
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+
+if __name__ == '__main__':
+    uvicorn.run(app, host="0.0.0.0", port=7860)

models/xgb_test.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:606852a5fc31ad652bc03333af296a578a0c45cbec15a159e348045533805ab9
+size 113963

template/index.html

@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Fake Audio Detection</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+        }
+        #console {
+            border: 1px solid #ddd;
+            padding: 10px;
+            height: 200px;
+            overflow-y: scroll;
+        }
+        .log {
+            margin: 0;
+            padding: 5px;
+        }
+        .log.real {
+            color: green;
+        }
+        .log.fake {
+            color: red;
+        }
+    </style>
+</head>
+<body>
+    <h1>Fake Audio Detection</h1>
+    <button id="startButton">Start Detection</button>
+    <button id="stopButton" disabled>Stop Detection</button>
+    <div id="console"></div>
+
+    <script>
+        let isDetecting = false;
+        const startButton = document.getElementById('startButton');
+        const stopButton = document.getElementById('stopButton');
+        const consoleDiv = document.getElementById('console');
+        let websocket = null;
+
+        function logMessage(message, type) {
+            const log = document.createElement('p');
+            log.className = `log ${type}`;
+            log.textContent = message;
+            consoleDiv.appendChild(log);
+            consoleDiv.scrollTop = consoleDiv.scrollHeight;
+        }
+
+        async function startDetection() {
+            if (isDetecting) {
+                logMessage('Detection is already running...', 'info');
+                return;
+            }
+            isDetecting = true;
+            logMessage('Starting detection...', 'info');
+            startButton.disabled = true;
+            stopButton.disabled = false;
+
+            try {
+                const response = await fetch('http://localhost:7860/start_detection', {
+                    method: 'POST',
+                });
+
+                if (!response.ok) {
+                    throw new Error('Network response was not ok');
+                }
+
+                const result = await response.json();
+                logMessage(`Detection started: ${result.status}`, 'info');
+
+                websocket = new WebSocket('ws://localhost:7860/ws');
+                websocket.onmessage = function(event) {
+                    const data = event.data;
+                    logMessage(`Detected ${data} audio`, data);
+                };
+                websocket.onclose = function() {
+                    logMessage('WebSocket connection closed', 'info');
+                };
+            } catch (error) {
+                logMessage(`Error: ${error.message}`, 'error');
+            }
+        }
+
+        async function stopDetection() {
+            if (!isDetecting) {
+                logMessage('Detection is not running...', 'info');
+                return;
+            }
+            isDetecting = false;
+            logMessage('Stopping detection...', 'info');
+            startButton.disabled = false;
+            stopButton.disabled = true;
+
+            try {
+                const response = await fetch('http://localhost:7860/stop_detection', {
+                    method: 'POST',
+                });
+
+                if (!response.ok) {
+                    throw new Error('Network response was not ok');
+                }
+
+                const result = await response.json();
+                logMessage(`Detection stopped: ${result.status}`, 'info');
+
+                if (websocket) {
+                    websocket.close();
+                    websocket = null;
+                }
+            } catch (error) {
+                logMessage(`Error: ${error.message}`, 'error');
+            }
+        }
+
+        startButton.addEventListener('click', startDetection);
+        stopButton.addEventListener('click', stopDetection);
+    </script>
+</body>
+</html>