|
|
--- |
|
|
license: mit |
|
|
datasets: |
|
|
- LanceaKing/asvspoof2019 |
|
|
language: |
|
|
- en |
|
|
metrics: |
|
|
- accuracy |
|
|
--- |
|
|
# DeepVoiceGuard: Real-Time Audio Authenticity Detection |
|
|
|
|
|
**DeepVoiceGuard** is an advanced AI-powered tool for detecting whether an audio file is genuine or AI-generated. Built using RawNet-based architecture and trained on ASVspoof datasets, this model is optimized for real-time inference using ONNX format. |
|
|
--- |
|
|
## 🚀 Features |
|
|
- **Real-Time Detection:** Analyze audio files quickly and efficiently to determine authenticity. |
|
|
- **Sliding Window Processing:** Processes long audio files in segments for accurate classification. |
|
|
- **ONNX Optimized:** Faster inference compared to traditional formats. |
|
|
- **Interactive Demo:** Test the model using [our Streamlit application](https://huggingface.co/spaces/Mrkomiljon/DeepVoiceGuard). |
|
|
--- |
|
|
## 📚 Model Overview |
|
|
- **Architecture:** RawNet-based Neural Network |
|
|
- **Frameworks Used:** PyTorch, ONNX |
|
|
- **Dataset:** Trained on ASVspoof 2019 Challenge dataset(LA) |
|
|
- **Classes:** |
|
|
- **Real:** Genuine human speech |
|
|
- **Fake:** AI-generated or spoofed audio |
|
|
--- |
|
|
## 🛠 Installation |
|
|
Install the necessary dependencies: |
|
|
```bash |
|
|
pip install onnxruntime librosa numpy requests streamlit |
|
|
``` |
|
|
🔧 How to Use |
|
|
Using the ONNX Model |
|
|
``` |
|
|
import streamlit as st |
|
|
import librosa |
|
|
import numpy as np |
|
|
import onnxruntime as ort |
|
|
import os |
|
|
import requests |
|
|
|
|
|
# Audio padding function |
|
|
def pad(x, max_len=64600): |
|
|
""" |
|
|
Pad or trim an audio segment to a fixed length by repeating or slicing. |
|
|
""" |
|
|
x_len = x.shape[0] |
|
|
if x_len >= max_len: |
|
|
return x[:max_len] # Trim if longer |
|
|
# Repeat to fill max_len |
|
|
num_repeats = (max_len // x_len) + 1 |
|
|
padded_x = np.tile(x, (1, num_repeats))[:, :max_len][0] |
|
|
return padded_x |
|
|
# Preprocess audio for a single segment |
|
|
def preprocess_audio_segment(segment, cut=64600): |
|
|
""" |
|
|
Preprocess a single audio segment: pad or trim as required. |
|
|
""" |
|
|
segment = pad(segment, max_len=cut) |
|
|
return np.expand_dims(np.array(segment, dtype=np.float32), axis=0) # Add batch dimension |
|
|
|
|
|
# Download ONNX model from Hugging Face |
|
|
def download_model(url, local_path="RawNet_model.onnx"): |
|
|
""" |
|
|
Download the ONNX model from a URL if it doesn't already exist locally. |
|
|
""" |
|
|
if not os.path.exists(local_path): |
|
|
with st.spinner("Downloading ONNX model..."): |
|
|
response = requests.get(url) |
|
|
if response.status_code == 200: |
|
|
with open(local_path, "wb") as f: |
|
|
f.write(response.content) |
|
|
st.success("Model downloaded successfully!") |
|
|
else: |
|
|
raise Exception("Failed to download ONNX model") |
|
|
return local_path |
|
|
# Sliding window prediction function |
|
|
def predict_with_sliding_window(audio_path, onnx_model_path, window_size=64600, step_size=64600, sample_rate=16000): |
|
|
""" |
|
|
Use a sliding window to predict if the audio is real or fake over the entire audio. |
|
|
""" |
|
|
# Load ONNX runtime session |
|
|
ort_session = ort.InferenceSession(onnx_model_path) |
|
|
|
|
|
# Load audio file |
|
|
waveform, _ = librosa.load(audio_path, sr=sample_rate) |
|
|
total_segments = [] |
|
|
total_probabilities = [] |
|
|
|
|
|
# Sliding window processing |
|
|
for start in range(0, len(waveform), step_size): |
|
|
end = start + window_size |
|
|
segment = waveform[start:end] |
|
|
|
|
|
# Preprocess the segment |
|
|
audio_tensor = preprocess_audio_segment(segment) |
|
|
|
|
|
# Perform inference |
|
|
inputs = {ort_session.get_inputs()[0].name: audio_tensor} |
|
|
outputs = ort_session.run(None, inputs) |
|
|
probabilities = np.exp(outputs[0]) # Softmax probabilities |
|
|
prediction = np.argmax(probabilities) |
|
|
|
|
|
# Store the results |
|
|
predicted_class = "Real" if prediction == 1 else "Fake" |
|
|
total_segments.append(predicted_class) |
|
|
total_probabilities.append(probabilities[0][prediction]) |
|
|
|
|
|
# Final aggregation |
|
|
majority_class = max(set(total_segments), key=total_segments.count) # Majority voting |
|
|
avg_probability = np.mean(total_probabilities) * 100 # Average probability in percentage |
|
|
|
|
|
return majority_class, avg_probability |
|
|
|
|
|
# Example |
|
|
result = predict("example.wav") |
|
|
print(f"Prediction: {result}") |
|
|
``` |
|
|
📊 Performance Metrics |
|
|
Equal Error Rate (EER): 4.21% |
|
|
Accuracy: 95.8% |
|
|
ROC-AUC: 0.986 |
|
|
|
|
|
🛡 License |
|
|
This project is licensed under the MIT License. |
|
|
|
|
|
✉️ Contact |
|
|
For inquiries or support, please contact: |
|
|
|
|
|
- GitHub: [Mrkomiljon](https://github.com/Mrkomiljon/DeepVoiceGuard) |
|
|
- Hugging Face: [DeepVoiceGuard](https://huggingface.co/spaces/Mrkomiljon/DeepVoiceGuard) |
|
|
|
