File size: 5,440 Bytes
ae77244
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
"""End-to-end sequential inference for one audio file or a directory of clips."""

import argparse
import os
import time
from pathlib import Path

import librosa
import torch
from transformers import AutoModelForSequenceClassification, AutoTokenizer
from transformers import WhisperForConditionalGeneration, WhisperProcessor


def transcribe_audio(audio_path, whisper_model, processor):
    print(f"Transcribing {audio_path}...")
    audio, sr = librosa.load(audio_path, sr=16000)
    input_features = processor(audio, sampling_rate=sr, return_tensors="pt").input_features
    
    # Generate token ids
    predicted_ids = whisper_model.generate(input_features)
    
    # Decode
    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
    return transcription

def classify_text(text, classifier_model, tokenizer, device="cpu"):
    print(f"Classifying text: '{text[:50]}...'")
    inputs = tokenizer(text, return_tensors="pt", max_length=512, truncation=True, padding="max_length")
    inputs = {k: v.to(device) for k, v in inputs.items()}
    
    with torch.no_grad():
        outputs = classifier_model(**inputs)
    
    logits = outputs.logits
    probs = torch.nn.functional.softmax(logits, dim=-1)
    
    # Class 0: Legit, Class 1: Scam
    scam_prob = probs[0][1].item()
    return scam_prob


def load_whisper_model(model_path):
    if os.path.isdir(model_path):
        print(f"Loading Whisper model from local directory: {model_path}")
        processor = WhisperProcessor.from_pretrained(model_path)
        whisper_model = WhisperForConditionalGeneration.from_pretrained(model_path)
        return whisper_model, processor

    if model_path.endswith((".pt", ".pth")) and os.path.exists(model_path):
        print(f"Loading Whisper model from quantized checkpoint: {model_path}")
        whisper_model = torch.load(model_path, map_location="cpu")
        processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
        return whisper_model, processor

    print(f"Loading Whisper model from Hugging Face: {model_path}")
    processor = WhisperProcessor.from_pretrained(model_path)
    whisper_model = WhisperForConditionalGeneration.from_pretrained(model_path)
    return whisper_model, processor


def load_classifier_model(model_path, device):
    if os.path.isdir(model_path):
        print(f"Loading classifier from local directory: {model_path}")
        tokenizer = AutoTokenizer.from_pretrained(model_path)
        model = AutoModelForSequenceClassification.from_pretrained(model_path)
        model.to(device)
        return model, tokenizer, device

    if model_path.endswith((".pt", ".pth")) and os.path.exists(model_path):
        print(f"Loading classifier from quantized checkpoint: {model_path}")
        tokenizer = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
        model = torch.load(model_path, map_location="cpu")
        return model, tokenizer, "cpu"

    print(f"Loading classifier from Hugging Face or registry-compatible path: {model_path}")
    tokenizer = AutoTokenizer.from_pretrained(model_path)
    model = AutoModelForSequenceClassification.from_pretrained(model_path)
    model.to(device)
    return model, tokenizer, device


def iter_audio_paths(audio_input):
    path = Path(audio_input)
    if path.is_dir():
        return sorted([str(p) for p in path.glob("*.wav")])
    return [str(path)]


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--audio_path", type=str, default="data/raw_audio/jNQXAC9IVRw.wav")
    parser.add_argument("--whisper_model_path", type=str, default="openai/whisper-tiny")
    parser.add_argument("--classifier_model_path", type=str, default="models/quantized_classifier/classifier_int8.pt")
    args = parser.parse_args()

    print("Initializing Sequential Inference Pipeline...")

    # Device routing
    device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
    print(f"Hardware Accelerator available: {device.upper()}")
    
    print("\nLoading Whisper Processor and Model...")
    whisper_model, processor = load_whisper_model(args.whisper_model_path)

    print("Loading Text Classifier...")
    classifier_model, tokenizer, active_device = load_classifier_model(args.classifier_model_path, device)
    classifier_model.eval()

    audio_paths = iter_audio_paths(args.audio_path)
    if not audio_paths:
        print(f"No audio files found under {args.audio_path}")
        return

    for audio_file in audio_paths:
        if not os.path.exists(audio_file):
            print(f"[WARNING] Audio file not found: {audio_file}")
            continue

        start = time.perf_counter()
        transcript = transcribe_audio(audio_file, whisper_model, processor)
        scam_prob = classify_text(transcript, classifier_model, tokenizer, device=active_device)
        elapsed_ms = (time.perf_counter() - start) * 1000

        print(f"  -> Extracted Text: {transcript}")
        print(f"\n=============================")
        print(f"FILE: {audio_file}")
        print(f"FINAL SCAM PROBABILITY: {scam_prob:.2%}")
        print(f"END-TO-END LATENCY: {elapsed_ms:.2f} ms")
        if scam_prob > 0.5:
            print(f"VERDICT: 🚨 SCAM ROBOCALL 🚨")
        else:
            print(f"VERDICT: ✅ LEGITIMATE CALL ✅")
        print(f"=============================\n")

if __name__ == "__main__":
    main()