Lab: Adversariële audiovoorbeelden vervaardigen

import numpy as np
import soundfile as sf
import whisper
 
def generate_test_audio(
    text_content: str = "hello world",
    duration: float = 3.0,
    sample_rate: int = 16000
) -> np.ndarray:
    """Genereer eenvoudige testaudio (sinusgolf-tonen)."""
    t = np.linspace(0, duration, int(duration * sample_rate), endpoint=False)
    # Eenvoudige toon die Whisper waarschijnlijk als stilte/ruis transcribeert
    audio = 0.3 * np.sin(2 * np.pi * 440 * t)
    # Voeg wat ruis toe voor realisme
    audio += 0.01 * np.random.randn(len(audio))
    return audio.astype(np.float32)
 
def transcribe_audio(audio: np.ndarray, model) -> str:
    """Transcribeer audio met Whisper."""
    result = model.transcribe(
        audio,
        language="en",
        fp16=False  # Gebruik fp32 voor reproduceerbaarheid
    )
    return result["text"].strip()
 
# Basistest
model = whisper.load_model("base")
 
# Test met gegenereerde audio
test_audio = generate_test_audio()
baseline_transcription = transcribe_audio(test_audio, model)
print(f"Baseline transcription: '{baseline_transcription}'")
 
# Sla op ter referentie
sf.write("baseline_audio.wav", test_audio, 16000)

import torch
import whisper
import numpy as np
 
def simple_whisper_attack(
    model,
    source_audio: np.ndarray,
    target_text: str,
    epsilon: float = 0.02,
    num_steps: int = 200,
    learning_rate: float = 0.001,
    sample_rate: int = 16000
) -> tuple[np.ndarray, list[float]]:
    """
    Eenvoudige gradient-aanval op Whisper.
 
    Returns:
        adversarial_audio: De verstoorde audio
        loss_history: Verlieswaarden over de optimalisatiestappen
    """
    device = "cuda" if torch.cuda.is_available() else "cpu"
 
    # Bereid de audio-tensor voor
    audio_tensor = torch.from_numpy(source_audio).float().to(device)
    audio_tensor.requires_grad_(False)
 
    # Initialiseer de verstoring
    delta = torch.zeros_like(audio_tensor, requires_grad=True)
 
    # Encodeer de doeltekst
    tokenizer = whisper.tokenizer.get_tokenizer(
        model.is_multilingual, language="en", task="transcribe"
    )
    target_tokens = tokenizer.encode(target_text)
    target_ids = torch.tensor([target_tokens], device=device)
 
    optimizer = torch.optim.Adam([delta], lr=learning_rate)
    loss_history = []
 
    for step in range(num_steps):
        optimizer.zero_grad()
 
        # Pas de verstoring toe
        adv_audio = audio_tensor + delta
 
        # Bereken het mel-spectrogram
        mel = whisper.log_mel_spectrogram(adv_audio).to(device)
        if mel.dim() == 2:
            mel = mel.unsqueeze(0)
 
        # Encodeer de audio
        audio_features = model.encoder(mel)
 
        # Decodeer met de doeltokens
        # Bereken het verlies als cross-entropy met de doelreeks
        logits = model.decoder(target_ids[:, :-1], audio_features)
        loss = torch.nn.functional.cross_entropy(
            logits.reshape(-1, logits.size(-1)),
            target_ids[:, 1:].reshape(-1)
        )
 
        loss.backward()
        loss_history.append(loss.item())
 
        optimizer.step()
 
        # Projecteer de verstoring naar de epsilon-bal
        with torch.no_grad():
            delta.data = torch.clamp(delta.data, -epsilon, epsilon)
            # Zorg voor een geldig audiobereik
            delta.data = torch.clamp(
                audio_tensor + delta.data, -1.0, 1.0
            ) - audio_tensor
 
        if step % 50 == 0:
            print(f"Step {step}/{num_steps}, Loss: {loss.item():.4f}")
 
    adv_audio = (audio_tensor + delta).detach().cpu().numpy()
    return adv_audio, loss_history
 
# Voer de aanval uit
model = whisper.load_model("base")
source = np.random.randn(16000 * 3).astype(np.float32) * 0.01  # 3 sec noise
target = "the password is twelve thirty four"
 
adv_audio, losses = simple_whisper_attack(model, source, target)
 
# Verifieer
result = model.transcribe(adv_audio, language="en", fp16=False)
print(f"Target: '{target}'")
print(f"Actual transcription: '{result['text'].strip()}'")

import numpy as np
from scipy.signal import stft
 
def compute_snr(original: np.ndarray, adversarial: np.ndarray) -> float:
    """Bereken de Signal-to-Noise Ratio in dB."""
    signal_power = np.mean(original ** 2)
    noise_power = np.mean((adversarial - original) ** 2)
    if noise_power < 1e-10:
        return float('inf')
    return 10 * np.log10(signal_power / noise_power)
 
def compute_spectral_distortion(
    original: np.ndarray,
    adversarial: np.ndarray,
    sr: int = 16000
) -> float:
    """Bereken de log-spectrale vervorming tussen origineel en adversarieel."""
    _, _, orig_stft = stft(original, fs=sr, nperseg=512)
    _, _, adv_stft = stft(adversarial, fs=sr, nperseg=512)
 
    orig_power = np.abs(orig_stft) ** 2 + 1e-10
    adv_power = np.abs(adv_stft) ** 2 + 1e-10
 
    lsd = np.sqrt(np.mean(
        (10 * np.log10(orig_power) - 10 * np.log10(adv_power)) ** 2
    ))
    return lsd
 
def evaluate_attack(
    original: np.ndarray,
    adversarial: np.ndarray,
    model,
    target_text: str
) -> dict:
    """Uitgebreide evaluatie van een adversariële audio-aanval."""
    # Transcriptiesucces
    result = model.transcribe(adversarial, language="en", fp16=False)
    transcription = result["text"].strip().lower()
    target_lower = target_text.lower()
 
    # Exacte overeenkomst
    exact_match = transcription == target_lower
 
    # Gedeeltelijke overeenkomst (welk deel van de doelwoorden verschijnt)
    target_words = set(target_lower.split())
    trans_words = set(transcription.split())
    word_overlap = len(target_words & trans_words) / len(target_words) if target_words else 0
 
    # Perceptuele metrieken
    snr = compute_snr(original, adversarial)
    lsd = compute_spectral_distortion(original, adversarial)
    max_perturbation = np.max(np.abs(adversarial - original))
 
    return {
        "target_text": target_text,
        "transcription": transcription,
        "exact_match": exact_match,
        "word_overlap": f"{word_overlap:.1%}",
        "snr_db": f"{snr:.1f}",
        "log_spectral_distortion": f"{lsd:.2f}",
        "max_perturbation": f"{max_perturbation:.4f}",
        "imperceptible": snr > 30 and max_perturbation < 0.02
    }