Real-Time Voice Analyzer

What It Does

Installation

git clone https://github.com/your-repo/real_time_voice_analyzer.git
   cd real_time_voice_analyzer

pip install -r requirements.txt

Usage

python real_time_voice_analyzer.py --input path/to/audio/file.wav --threshold 0.85

python real_time_voice_analyzer.py --input sample.wav --threshold 0.9

Source Code

import argparse
import numpy as np
from pydub import AudioSegment
from pydub.playback import play
from scipy.io import wavfile
import torch
import os
import logging

def analyze_audio(audio_data, sample_rate, threshold):
    """
    Analyzes the audio data to detect AI-generated voices.

    Args:
        audio_data (numpy.ndarray): The audio data as a numpy array.
        sample_rate (int): The sample rate of the audio.
        threshold (float): The confidence threshold for flagging AI-generated audio.

    Returns:
        float: Confidence score for AI-generated content.
    """
    # Simulate a deep learning model for AI voice detection
    model = torch.nn.Sequential(
        torch.nn.Linear(audio_data.shape[0], 1),
        torch.nn.Sigmoid()
    )

    # Normalize audio data
    audio_data = audio_data / np.max(np.abs(audio_data))

    # Convert to tensor
    audio_tensor = torch.tensor(audio_data, dtype=torch.float32)

    # Simulate prediction
    with torch.no_grad():
        confidence_score = model(audio_tensor).item()

    return confidence_score

def process_audio_file(file_path, threshold):
    """
    Processes an audio file to detect AI-generated voices.

    Args:
        file_path (str): Path to the audio file.
        threshold (float): The confidence threshold for flagging AI-generated audio.

    Returns:
        dict: Analysis results including confidence score and flag.
    """
    try:
        # Load audio file
        audio = AudioSegment.from_file(file_path)
        samples = np.array(audio.get_array_of_samples())
        sample_rate = audio.frame_rate

        # Analyze audio
        confidence_score = analyze_audio(samples, sample_rate, threshold)
        is_suspicious = confidence_score >= threshold

        return {
            "file": file_path,
            "confidence_score": confidence_score,
            "is_suspicious": is_suspicious
        }
    except Exception as e:
        logging.error(f"Error processing file {file_path}: {e}")
        return {
            "file": file_path,
            "error": str(e)
        }

def main():
    parser = argparse.ArgumentParser(description="Real-Time Voice Analyzer")
    parser.add_argument("--input", type=str, required=True, help="Path to audio file or 'live' for live input")
    parser.add_argument("--threshold", type=float, default=0.85, help="Confidence threshold for AI detection")
    args = parser.parse_args()

    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

    if args.input == "live":
        logging.info("Live audio input is not yet supported.")
    else:
        if not os.path.exists(args.input):
            logging.error(f"File not found: {args.input}")
            return

        result = process_audio_file(args.input, args.threshold)
        if "error" in result:
            logging.error(f"Failed to process audio: {result['error']}")
        else:
            logging.info(f"File: {result['file']}")
            logging.info(f"Confidence Score: {result['confidence_score']:.2f}")
            if result['is_suspicious']:
                logging.warning("Suspicious audio detected!")
            else:
                logging.info("Audio appears to be human.")

if __name__ == "__main__":
    main()