FakeVoiceFinder: An Open-Source Framework for Synthetic and Deepfake Audio Detection

Abstract

AI-based audio generation has advanced rapidly, enabling deepfake audio to reach levels of naturalness that closely resemble real recordings and complicate the distinction between authentic and synthetic signals. While numerous CNN- and Transformer-based detection approaches have been proposed, most adopt a model-centric perspective in which the spectral representation remains fixed. Parallel data-centric efforts have explored alternative representations such as scalograms and CQT, yet the field still lacks a unified framework that jointly evaluates the influence of model architecture, its hyperparameters (e.g., learning rate, number of epochs), and the spectral representation along with its own parameters (e.g., representation type, window size). Moreover, there is no standardized approach for benchmarking custom architectures against established baselines under consistent experimental conditions. FakeVoiceFinder addresses this gap by providing a systematic framework that enables direct comparison of model-centric, data-centric, and hybrid evaluation strategies. It supports controlled experimentation, flexible configuration of models and representations, and comprehensive performance reporting tailored to the detection task. This framework enhances reproducibility and helps clarify how architectural and representational choices interact in synthetic audio detection.

1. Introduction

The rapid progress of AI-based speech synthesis technologies has enabled the creation of highly realistic synthetic audio, often referred to as deepfake audio. Techniques such as Text-to-Speech (TTS) and Voice Conversion (VC) have advanced considerably in recent years, producing speech that is becoming increasingly difficult to distinguish from natural human voices [1,2]. This growing naturalness creates challenges in areas such as impersonation, audio forensics, misuse for malicious purposes, fake news, and others [3,4].

In recent years, research on fake audio detection has intensified, leading to the development of multiple datasets, organized challenges, and both academic and commercial tools. Benchmarking initiatives, such as the ASVspoof challenge series, have played an important role in standardizing evaluation protocols and fostering the progress of countermeasure systems [5,6,7]. Additional datasets, including In the Wild corpora and language-specific resources, have further extended the scope of the evaluation to different acoustic and linguistic conditions [8]. At the same time, several open-source libraries and verification tools have been introduced, providing reproducible pipelines for synthetic speech detection and supporting the implementation of countermeasures in practical scenarios [9,10,11,12].

Most existing approaches can be categorized as model-centric, where the main effort is placed on the design and optimization of deep learning architectures. Convolutional Neural Networks (CNNs) and Vision Transformers are often used for their ability to capture local spectral patterns in time–frequency representations [13,14,15,16], while recurrent and attention-based models such as LSTMs, GRUs, and Transformers are applied to exploit temporal dependencies and long-range correlations in audio signals [17,18]. More recent work has examined hybrid CNN–Transformer architectures, residual networks, and self-supervised embeddings to improve robustness against unseen spoofing attacks [19,20]. To assess performance, researchers typically report accuracy, precision, recall, F1-score, Area Under the ROC Curve (AUC), and Equal Error Rate (EER). Beyond these metrics, recent studies highlight the importance of robustness evaluation, examining model generalization across datasets [21], languages [22], and real-world communication conditions such as compression and channel noise [23].

In parallel, data-centric approaches focus on the way audio input is represented before being processed by the models [24,25]. Instead of relying only on raw waveforms, which contain fine-grained temporal details but often require large datasets to generalize, researchers frequently adopt time–frequency transformations. mel-spectrograms are widely used to approximate human auditory perception, while log-spectrograms emphasize subtle energy variations across frequency bands [26,27,28]. More recently, scalograms derived from continuous and discrete wavelet transforms have been investigated to provide multi-resolution analysis, offering complementary insights beyond Fourier-based methods [29,30,31]. These representations, combined with CNNs, Transformers, or hybrid architectures, have shown a substantial impact on detection performance, sometimes even greater than improvements in model design. This line of research highlights the importance of representation learning, confirming that the choice of spectrograms at different scales, or wavelet-based representations, plays a central role in distinguishing synthetic from natural speech.

Despite these contributions, only a limited number of studies have systematically explored Hybrid-approaches that integrate both model-centric and data-centric perspectives. Moreover, the comparison of custom architectures with benchmark architectures under identical experimental conditions is critical to allowing a rigorous evaluation of whether a proposed solution exceeds existing models. Such tools also serve as a mechanism for resource-constrained researchers to validate their solutions beyond the scope of established challenges or benchmarking initiatives.

Based on the above, we present FakeVoiceFinder, a library that provides the following contributions:

• It enables comprehensive model-centric and data-centric experimentation by allowing the user to fix the architecture while varying the spectral representation, or to fix the representation while exploring multiple architectures. The library supports four transformations: mel-spectrogram, log-spectrogram, scalogram, and the Constant-Q Transform (CQT).
• It offers a hybrid search space in which custom architectures and benchmark models can be systematically combined with the four available spectral representations. This unified experimentation pipeline facilitates controlled comparisons that are rarely addressed explicitly in the audio deepfake detection literature.
• It allows rapid and reproducible comparison between custom solutions and benchmark architectures (e.g., evaluating a custom ConvNext model against ResNet, VGG, or EfficientNet-based baselines) under matched or varied transformation types and hyperparameter configurations. This design enables principled selection of optimal architecture–representation pairs for a given detection scenario.
• It includes an inference module in which a trained model estimates the probability that an input audio sample is synthetic or natural. This supports standalone audio evaluation by end-users and enables robustness testing under adversarial or intentionally altered audio conditions.

To better situate our contribution, the rest of the paper is organized as follows. Section 2 provides a background on synthetic audio generation, detection methods, and commonly used datasets and metrics. Section 3 outlines the main open gaps in the literature, such as the absence of unified evaluation frameworks and limited benchmarking of custom models, which directly motivate the design of FakeVoiceFinder. Section 4 introduces this open-source framework, structured into two complementary perspectives: a data-centric approach, focused on input processing and transformations, and a model-centric approach, centered on architectural choices and training hyperparameters. The results are presented in Section 5.

2. Background

This section first describes the main technologies for synthetic audio generation, and then introduces the key concepts of model-centric approaches (architectures, hyperparameter tuning, lighter architectures) and data-centric approaches (datasets, data transformation, and adversarial attacks). In addition, it presents a comparison between Convolutional Neural Networks, and Transformers, emphasizing their differences and relative advantages for detecting synthetic audio. This comparison provides a justification for including the three types of architecture in the FakeVoiceFinder framework, with the aim of supporting a fair and comprehensive evaluation framework.

2.1. Technologies of Synthetic Audio Generation (TTS and Voice/Voice-Conversion)

Text-to-Speech (TTS) and Voice Conversion (VC, also called V2V) are two main categories of methods for generating AI-based audio. In the case of TTS, a model maps text input (optionally enriched with style, prosody, or speaker embeddings) into an audio waveform. Modern approaches are usually end-to-end neural TTS systems, for instance, Tacotron [32,33], VITS [34], or FastSpeech [35], combined with high-quality neural vocoders such as HiFi-GAN or BigVGAN [36]. In VC, the objective is to transform the speech of a source speaker so that it resembles the voice of a target speaker, while preserving the linguistic content and modifying the speaker’s identity, accent or speaking style [37,38]. Recent surveys present different encoder–decoder and disentanglement pipelines, zero shot voice conversion strategies, and the use of latent representations in neural VC [39].

These technologies have improved markedly in naturalness, speaker similarity, and variability. Such improvements make synthetic audio harder to distinguish from real speech, even for human listeners, and pose growing challenges for automatic detection systems.

2.2. Data-Centric Solutions: Selection and Optimization of Spectral Representations

A fundamental component in audio deepfake detection is the transformation of the raw waveform into a spectral representation that can be processed by deep learning models. Data-centric approaches focus precisely on this step: selecting the most informative representation and tuning its hyperparameters to expose synthesis artifacts. Under this perspective, the architecture remains fixed, and performance gains arise from how the signal is represented rather than from modifications to the model itself.

Two core decisions define this approach:

• Selection of the spectral representation. The representation determines the structure of the time–frequency information provided to the classifier. Common options include:

  –

  STFT-based spectrograms: obtained using the Short-Time Fourier Transform, which decomposes the signal into frequency components across short temporal windows. Two widely adopted variants include

  ∗

  Mel-spectrograms, which apply a mel-scale filterbank to approximate human auditory perception, offering high resolution at low frequencies and lower resolution at high frequencies. They capture formants, harmonics, and speech-relevant cues, and have been extensively used in spoofing detection challenges [40].

  ∗

  Log-spectrograms, which emphasize spectral energy variations through log compression, highlighting subtle amplitude differences that may reveal artifacts introduced by vocoders or TTS systems [41].

  –

  Wavelet-based scalograms (DWT-based): Multi-resolution representations computed using the Discrete Wavelet Transform (DWT). Compared with CWT-based scalograms, the DWT is computationally efficient and enables explicit control over the resolution at each decomposition level. Mother wavelets such as Daubechies or Symlets provide sensitivity to transient and non-stationary artifacts that may not be well captured by Fourier-based methods. Wavelet packet variants and scalogram-like representations have also shown promise in spoofing detection [42].

  –

  CQT (Constant-Q Transform): A logarithmically spaced representation aligned with speech perception and harmonic structure. Its constant frequency-to-resolution ratio makes it suitable for capturing formant structure and harmonic distortions typical of synthetic audio [41].

• Selection of representation hyperparameters. Each representation requires choosing a set of hyperparameters that determine its ability to reveal synthesis artifacts:

  –

  STFT parameters: window size, hop length, FFT size, and window type (Hann, Hamming, Blackman).

  –

  mel-spectrogram parameters: number of mel filters, window size, hop length, and FFT size.

  –

  DWT-based scalogram parameters: mother wavelet (Daubechies, Symlet), number of decomposition levels, filter lengths, and dimensionality normalization rules per scale.

  –

  CQT parameters: bins per octave, minimum frequency, window overlap, and kernel selection.

Each representation has distinct strengths: mel-spectrograms are perceptually grounded, log-spectrograms highlight energy-based anomalies, CQT provides harmonic resolution, and DWT-based scalograms capture multi-scale transient behavior. For this reason, the FakeVoiceFinder framework incorporates all these transformations, enabling systematic evaluation of how the choice of representation and its hyperparameters impacts deepfake detection. This integration helps disentangle whether improvements stem from the model architecture or from the data representation itself.

2.3. Model-Centric Solutions: Architecture Design, Training Protocols, and Performance Optimization

Model-centric approaches focus on improving the model itself, assuming that architectural selection and hyperparameter tuning are the primary factors driving performance in synthetic audio detection. Under this perspective, the spectral representation is typically fixed, and performance gains arise from designing or selecting an appropriate architecture and refining its training configuration. Two main decisions define this category:

• Architecture selection. The choice of architecture determines how the model extracts discriminative patterns from time–frequency representations such as spectrograms or scalograms. Prior work has explored several families of convolutional and attention-based architectures, including the following:

  –

  Sequential CNNs (AlexNet, VGG): simple yet computationally heavy architectures that remain effective for capturing low- and mid-level spectral cues introduced by vocoder artifacts [43].

  –

  Residual CNNs (ResNet): introduce skip connections to enable deeper networks and alleviate vanishing gradients [44]. Their hierarchical representations help detect subtle synthesis distortions distributed across frequency bands.

  –

  Multi-branch CNNs (Inception): apply parallel convolutional kernels of different sizes, making them capable of capturing multi-scale spectral patterns relevant to detecting artifacts occurring at varying resolutions [45].

  –

  Lightweight CNNs (MobileNet, EfficientNet): architectures optimized for reduced parameter count and computational cost [46,47]. They facilitate real-time or resource-limited forensic deployments while maintaining competitive accuracy.

  –

  Modern CNNs (ConvNext): redesign traditional convolutional blocks by integrating concepts from Transformers—such as large kernels, depthwise convolutions, and layer normalization—achieving performance comparable to state-of-the-art attention-based models [48].

  –

  Transformers (ViT): use self-attention to model long-range dependencies across spectrogram patches. They are effective at capturing prosody, speaker consistency, and temporal correlations that extend beyond local convolutional filters, though they typically require larger datasets and more computational resources.

• Training hyperparameters. Once an architecture is selected, model-centric optimization focuses on tuning its training hyperparameters. Key factors include learning rate schedules, batch size, optimizer choice, number of epochs, regularization strategies, and transfer learning techniques such as partial layer freezing or full fine-tuning [49]. These choices directly influence model convergence, training stability, and generalization capacity.

Although model-centric approaches often achieve strong performance in controlled intra-dataset settings, their robustness tends to decline under cross-dataset evaluation, with audio generated by newer synthesis technologies, or under manipulated conditions. This highlights the need for frameworks such as FakeVoiceFinder that enable systematic comparison of architectural families and hyperparameter configurations under consistent experimental conditions.

3. Gaps and Motivation

Despite notable progress in the study of synthetic audio detection, several methodological and practical gaps remain:

• Absence of unified model-centric and data-centric comparison frameworks: Existing studies tend to emphasize either architectural improvements or the exploration of specific spectral representations, but seldom offer a structured environment to jointly analyze both dimensions. This lack of integration makes it difficult to disentangle how much of the detection performance is attributable to the model architecture versus the choice of data transformation, particularly now that four widely used representations (mel, log, scalogram, and CQT) coexist in modern pipelines.
• Lack of standardized benchmarking for custom architectures: Researchers frequently design custom models tailored to specific datasets or constraints, yet few platforms allow these models to be directly and fairly compared against established benchmarks such as ResNet, VGG, EfficientNet, or ConvNext. In the absence of such controlled environments, evaluating the true merit of new architectures becomes inconsistent and often irreproducible.
• Limited tools for robustness and adversarial vulnerability analysis: Although adversarial attacks on synthetic audio detectors are an emerging concern, current resources rarely provide mechanisms to expose trained models to intentional perturbations while monitoring probabilistic outputs. Without such tools, it remains challenging to assess the stability, vulnerability, and operational reliability of detectors under realistic threat conditions.
• Fragmentation of datasets, models, and evaluation pipelines: Most available resources address isolated components (e.g., datasets for training, pre-trained models for inference, or scripts for metric evaluation), but few combine these elements within a single unified workflow. This fragmentation complicates reproducibility, slows down systematic benchmarking across architectures and representations, and limits transparent reporting of probabilistic detection outcomes.

Based on these gaps, we introduce FakeVoiceFinder, a library designed to provide a flexible and unified environment for systematic analysis of deepfake detection models. The toolkit supports both model-centric and data-centric experimentation by allowing controlled variation of architectures and audio transformations, now including four spectral representations: mel-spectrogram, log-spectrogram, scalogram, and the Constant-Q Transform (CQT). It also enables hybrid analyses in which custom architectures can be combined with any of the four transformations, facilitating controlled comparative studies that are rarely addressed in the literature. Furthermore, FakeVoiceFinder allows rapid benchmarking of custom solutions against established models (e.g., comparing a custom ConvNext to ResNet-, VGG-, or EfficientNet-based baselines) under matched or varied transformation types. Finally, the library includes an inference module that estimates the probability that an audio sample is synthetic or natural, supporting both user-level evaluation of specific files and robustness assessment under intentional or adversarial manipulations for vulnerability analysis.

4. FakeVoiceFinder

FakeVoiceFinder possesses an architecture designed to streamline the entire pipeline of synthetic audio detection, from dataset preparation to model training and evaluation. The framework is organized into modular scripts that interact through a centralized configuration system (See Figure 1).

The process begins with the dataset preparation module (prepare_dataset.py), which takes as input the real and fake audio archives, the transformation parameters (e.g., mel-spectrograms, log-spectrograms, scalograms, and CQT), and user-defined options such as clipping duration or image size.

As part of this stage, the dataset is split into two subsets (training and validation) according to a user-defined ratio. To avoid methodological ambiguity, it is important to clarify that FakeVoiceFinder does not use these subsets for testing. The real.zip and fake.zip archives provided by the user are employed exclusively for training and validation under a stratified split, while all testing is performed on external and previously unseen audio samples through the inference module (Section 5.3). This design ensures a strict separation between training, validation, and test stages, supporting transparent and reproducible evaluation.

Then, the spectral representations are obtained for every audio using the selected type of transformation and its corresponding hyperparameters (see Figure 2).

Next, the model loader (model_loader.py) manages the selection of architectures (e.g., ResNet18, VGG16) and training modes (scratch, pretrained, or both). The trainer module (trainer.py) then executes the training procedure, handling hyperparameters such as learning rate, batch size, number of epochs, and optimizer type, as well as hardware configurations (CPU/GPU).

Finally, the experiment manager (experiment.py) orchestrates the overall workflow by linking dataset preparation, model loading, and training into a reproducible process. Performance is summarized through the metrics reporter (metrics.py), which generates reports in multiple formats (CSV, JSON, plots).

This modular architecture ensures reproducibility, flexibility, and scalability, enabling researchers to adapt the framework to different datasets, transformations, and model architectures while providing end users with a reliable tool for deepfake audio detection.

The inference stage is handled by the inference runner (inference.py), which integrates the necessary inputs to evaluate new audio samples See (Figure 3). The module receives the audio path of the sample under analysis, the model path pointing to the trained network, and the selected transformation parameters (e.g., mel filterbank size, hop length) associated with the chosen feature extraction method (e.g., mel-spectrograms). These elements are combined to preprocess the input, apply the trained model, and compute the final prediction. The output is expressed as an inference score, typically represented as class probabilities (e.g., {‘real’: 0.87, ‘fake’: 0.13}), which quantify the likelihood of the audio being authentic or synthetic. This design guarantees that once models are trained, they can be consistently deployed to evaluate unseen samples, ensuring both reproducibility and practical applicability.

In addition, it provides three comparative visualization modes: (1) model-oriented, (2) transformation-oriented, and (3) hybrid, which facilitate the analysis of the best model–transformation combinations. Finally, once the models are trained, the framework allows the estimation of the probability that an external audio sample belongs to the fake category.

The subsequent section outlines the functionalities provided by the library for each of the considered approaches.

4.1. Data-Centric Approach

In this approach, the user must provide two compressed folders: one named real.zip and the other fake.zip. These should contain, respectively, the natural audio samples and the AI-generated ones.

The first step is to define the audio duration, which can be either fixed (default: 3 s) or automatically set to the minimum duration among all audio samples in the dataset. This parameter is configured through cfg.clip_seconds, either by selecting "min_sec" or by specifying a constant value. In the latter case, if shorter audio files are encountered, they are zero-padded prior to the transformation stage.

Once the duration has been established, the user must select the type of transformation to be applied to the audio files. Four time–frequency representations are available: mel-spectrograms, log-spectrograms, scalograms, and CQT. These options are specified in cfg.transform_list using the identifiers "mel", "log", "DWT", and "CQT".

Each transformation type includes its own hyperparameters. For the mel representation, relevant hyperparameters include the number of mel filterbanks (n_mels), the size of the FFT window (n_fft), and the hop length between STFT frames (hop_length). For the log and mel representations, the last two hyperparameters are shared. For scalograms, the main parameters are the choice of mother wavelet (wavelet), the number of decomposition levels (level), and the analysis mode (mode). In the case of the CQT representation, the key hyperparameters include the hop length between frames (hop_length), the total number of frequency bins (n_bins), the number of bins per octave (bins_per_octave), and the scaling option applied to the filter responses (scale). See

Table 1. Hyperparameters for audio transformations.

Transformation	Hyperparameter	Description	Default Value
mel-scale	n_fft	Size of the FFT window.	2048
	hop_length	Number of samples between STFT frames.	512
	n_mels	Number of mel bands.	128
Log	n_fft	Size of the FFT window.	2048
	hop_length	Number of samples between STFT frames.	512
Scalogram (DWT)	wavelet	Type of mother wavelet.	db4
	level	Number of decomposition levels.	4
	mode	Boundary extension mode.	constant
CQT	hop_length	Number of samples between CQT frames.	256
	n_bins	Total number of CQT frequency bins.	96
	bins_per_octave	Resolution of frequency axis.	24
	scale	Scaling option producing a more stable spectral distribution.	True

for details.

It is important to note that within the framework, the generated spectrograms, scalograms, or CQT representations are not plotted. Instead, they are stored directly as tensors, which are then used as input to the selected model. This design choice significantly reduces the preprocessing time of this stage.

In summary, in the data-centric approach, the user can adjust three categories of hyperparameters:

• Clip duration: the fixed or minimum length applied to all audio samples.
• Time–frequency transformation: the selected representation (mel, log-spectrogram, scalogram, or CQT).
• Transformation hyperparameters: the specific parameters required to generate the chosen representation.

4.2. Model-Centric Approach

For the model-centric approach, FakeVoiceFinder provides a diverse set of benchmark architectures for image classification tasks, suitable for time-frequency representations of audio (e.g., spectrograms) rather than raw audio files. The architectures are organized into two groups, each with distinct characteristics.

• Convolutional Neural Networks (CNNs): Particularly effective at capturing local patterns in spectrograms. The selected architectures range from classic models (e.g., AlexNet, VGG) to more advanced networks (e.g., EfficientNet). A special case is the ConvNext family, which, while remaining convolutional, incorporates Transformer-inspired design principles such as larger kernel sizes, depthwise convolutions, and layer normalization. This makes ConvNext models an attractive option, as they combine the efficiency of CNNs with performance levels comparable to state-of-the-art Transformers.
• Transformers: Excel at modeling long-range dependencies through self-attention, enabling the capture of global relationships in spectrograms that CNNs may overlook. This makes them well-suited for complex audio signals with long-term temporal patterns.

Table 2. Available model architectures in FakeVoiceFinder.

Architecture Type	Available Options
CNN	AlexNet, ResNet18, ResNet34
	VGG16, VGG19, DenseNet121
	MobileNet_v2, EfficientNet_b0
	SqueezeNet1_0, Inception_v3
	ConvNext_tiny, ConvNext_small, ConvNext_base
Transformer	ViT_B_16

summarizes the available model architectures in FakeVoiceFinder, organized by type. This categorization highlights the diversity of architectures available for training in time-frequency representations of audio.

Next, a hyperparameter corresponding to the input image size has been included, since some models, such as ViT and ConvNext, may encounter issues if the input size does not exactly match the one they were originally designed for. This parameter is adjusted using cfg.image_size.

Finally, training hyperparameters have also been included, which allow the adjustment of experimental conditions, such as the number of epochs used to train each model. The list of these hyperparameters in FakeVoiceFinder, along with their corresponding type, description, and example, is presented in

Table 3. Hyperparameters for training.

Hyperparameter	Type	Description	Example
epochs	Integer	Number of training epochs.	50
lr	Float	Learning rate used by the optimizer.	0.001
bs	Integer	Batch size used during training.	32
optim_name	String	Optimizer to be used: sgd or adam.	adam
patience	Integer	Number of epochs without improvement before early stopping.	10
seed	Integer	Random seed for reproducibility of results.	42
type_train	String	Type of training: scratch, pretrained, or both.	pretrained

.

For the case of training_type, three options are available. The first, scratch, corresponds to using only the architecture without weight transfer. In this case, the model is trained from scratch. The second option, pretrained, applies transfer learning followed by fine-tuning. Finally, the both option combines both training strategies.

In summary, in the model-centric approach, the user can select from four types of model-related options:

• Architecture type: the category of the model, such as CNN and Transformer.
• Specific architecture: the particular model within the chosen category, e.g., ResNet18, ViT_B_16, ConvNext_base.
• Training hyperparameters: values used to configure the training of the selected model, such as learning rate, batch size, and number of epochs.
• Input image size: the dimensions of the input image expected by the model, which must match the architecture’s design to ensure proper functioning.

4.3. Custom Models

In addition to the benchmark architectures included in the framework, FakeVoiceFinder allows users to integrate custom models for experimentation and benchmarking purposes. This functionality provides flexibility for researchers who wish to evaluate novel architectures or lightweight designs under the same experimental conditions as standard CNN- or Transformer-based models.

A custom model must follow the standard structure of a PyTorch nn.Module, defining both the __init__() and forward() methods. Once implemented, the model can be placed in the designated models directory, where it will be automatically detected by the framework. Training is performed using the same configuration files and training pipeline employed by the predefined architectures, without requiring manual checkpoint handling or export steps.

The integration process, illustrated in Figure 4, enables users to incorporate their own architectures into FakeVoiceFinder in a straightforward manner. The user simply stores the Python definitions of the models in a dedicated folder (e.g., ../models) and specifies this path in the experiment configuration file. After executing the loader.prepare_user_models() function, all models in that directory are automatically loaded, validated, and registered as available architectures for experimentation. Once registered, custom models become fully compatible with the framework and can be used in any experimental configuration alongside the standard architectures (e.g., ResNet, ConvNext, or ViT). This procedure allows seamless integration of new architectures without modifying the internal structure of the library, ensuring reproducibility and comparability under identical experimental conditions.

As an example of this capability, Figure 5 presents the custom model used in this work: a lightweight convolutional neural network named SimpleCNN, designed specifically for binary classification of real and synthetic audio samples. The model includes three convolutional layers, each followed by a pooling operation, and a Global Average Pooling (GAP) layer that enables input-size agnosticism by aggregating spatial information before the final dense layer. The architecture is intentionally compact, allowing rapid experimentation and serving as a baseline for comparison with deeper or hybrid models. An example of creating and saving a custom CNN (TorchScript) compatible with FakeVoiceFinder is available in the following notebook: https://github.com/DEEP-CGPS/FakeVoiceFinder/blob/main/notebooks/Create_And_Save_Custom_CNN.ipynb (accessed on 5 October 2025).

Table 4. Intermediate tensor sizes for the custom SimpleCNN model for an input of $224\times 224\times 1$.

Layer (Custom Model)	Height	Width	Channels	Filter Height	Filter Width	Vector Length
Input	224	224	1	–	–	–
Conv1	224	224	32	3	3	–
MaxPool1	112	112	32	2	2	–
Conv2	112	112	64	3	3	–
MaxPool2	56	56	64	2	2	–
Conv3	56	56	128	3	3	–
GAP + Flatten	1	1	128	–	–	128
Linear (output)	–	–	–	–	–	2

summarizes the intermediate tensor dimensions for an input of $224\times 224\times 1$, corresponding to a single-channel time-frequency representation. The progressive reduction of spatial dimensions and expansion of feature channels can be observed through the convolutional and pooling layers, culminating in a 128-dimensional feature vector used for two-class classification.

This example demonstrates how FakeVoiceFinder allows users to include and evaluate their own architectures under controlled and comparable experimental conditions. By maintaining consistent preprocessing, transformation parameters, and evaluation metrics, the framework ensures that performance differences are attributable to architectural design rather than to variations in experimental configuration.

5. Results

This section is divided into three parts. The first presents the performance metrics obtained from the different models trained by selecting hyperparameters from both model-centric and data-centric approaches. Next, we provide comparative performance plots focused on the model, the data, and a hybrid combination of both. Finally, we report the prediction results on previously unseen audio samples, where the output corresponds to the probability of belonging to the fake category. A detailed breakdown of each of these subsections is presented below.

5.1. Metrics in FakeVoiceFinder

FakeVoiceFinder computes several performance metrics commonly used in classification models, for both balanced and imbalanced datasets. Specifically, it calculates the accuracy, which corresponds to the overall proportion of correct predictions; the precision, which measures the proportion of audios predicted as positive that truly belong to the positive class; the recall, which represents the proportion of positive audios that are correctly identified as positive; the F1, which is the harmonic mean between precision and recall; the F1_micro, which is especially useful for imbalanced datasets as it assigns weight proportional to the number of instances in each class; and the F1_macro, which evaluates the performance of the model equally across all classes, regardless of class imbalance.

These metrics are obtained from the following equations:

$$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}},$$

(1)

$$Precision={\displaystyle \frac{TP}{TP+FP}},$$

(2)

$$Recall={\displaystyle \frac{TP}{TP+FN}},$$

(3)

$$F1={\displaystyle \frac{2·Precision·Recall}{Precision+Recall}},$$

(4)

$$F{1}_{\mathrm{micro}}={\displaystyle \frac{2·(T{P}_0+T{P}_1)}{2·(T{P}_0+T{P}_1)+(F{P}_0+F{P}_1)+(F{N}_0+F{N}_1)}},$$

(5)

$$F{1}_{\mathrm{macro}}={\displaystyle \frac{F{1}_0+F{1}_1}{2}},$$

(6)

where $TP$, $TN$, $FP$, and $FN$ denote true positives, true negatives, false positives, and false negatives, respectively. When $T{P}_0$ is used, it means that class “0” is considered as the positive class; while $T{P}_1$ means that class “1” is taken as the positive class. Similarly, $F{1}_0$ and $F{1}_1$ denote the F1 scores obtained when class “0” and class “1” are considered as positive, respectively.

To exemplify the application of these metrics, we use the confusion matrix from

Table 5. Confusion matrix (class 1 = fake, class 0 = real). Accuracy = 0.8.

	Pred 0 (Real)	Pred 1 (Fake)
Actual 0 (real)	TN = 440	FP = 160
Actual 1 (fake)	FN = 80	TP = 520

as an example.

Based on the confusion matrix, the following values are derived by applying the equations presented in this section.

$$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}={\displaystyle \frac{520+440}{520+440+160+80}}=0.80$$

$$Precisio{n}_{\left(class1\right)}={\displaystyle \frac{TP}{TP+FP}}={\displaystyle \frac{520}{520+160}}=0.7647$$

$$Recal{l}_{\left(class1\right)}={\displaystyle \frac{TP}{TP+FN}}={\displaystyle \frac{520}{520+80}}=0.8667$$

$$F{1}_{\left(class1\right)}={\displaystyle \frac{2·Precision·Recall}{Precision+Recall}}={\displaystyle \frac{2·0.7647·0.8667}{0.7647+0.8667}}=0.8129$$

$$Precisio{n}_{\left(class0\right)}={\displaystyle \frac{TN}{TN+FN}}={\displaystyle \frac{440}{440+80}}=0.8462$$

$$Recal{l}_{\left(class0\right)}={\displaystyle \frac{TN}{TN+FP}}={\displaystyle \frac{440}{440+160}}=0.7333$$

$$F{1}_{\left(class0\right)}={\displaystyle \frac{2·0.8462·0.7333}{0.8462+0.7333}}=0.7861$$

$$F{1}_{\mathrm{micro}}=Accuracy=0.80$$

$$F{1}_{\mathrm{macro}}={\displaystyle \frac{F{1}_{\left(class0\right)}+F{1}_{\left(class1\right)}}{2}}={\displaystyle \frac{0.7861+0.8129}{2}}=0.7995$$

It should be emphasized that, in binary classification, F1 micro is equivalent to accuracy, irrespective of class balance.

In summary, the values are presented in

Table 6. Metrics for class 1 (fake) and global values computed from the confusion matrix in Table 5.

Metric	Value
Precision (class 1, fake)	0.7647
Recall (class 1, fake)	0.8667
F1 (class 1, fake)	0.8129
Accuracy (global)	0.8000
F1 Macro	0.7995
F1 Micro	0.8000

. A comparison of the metrics shows that, in this case, the model performs better at classifying fake audio samples (class = 1) than natural audio samples (class = 0), i.e., recall is higher than precision.

Thus, upon execution, the library generates a CSV file containing the results of each experiment. The file includes the following columns: model (architecture used), variant (pretrain or scratch), transform (DWT, mel, log, CQT), accuracy, f1, f1_macro, f1_micro, precision, and recall. An example is shown in Figure 6.

In addition, the FakeVoiceFinder library allows users to specify different random seed values to run multiple experimental repetitions when desired. In the basic example, a fixed seed is used to reduce the computational cost associated with training a large number of models simultaneously. For instance, selecting the four spectral representations for fifteen architectures in both pretrained and scratch configurations results in a total of 120 models, assuming fixed data-related and model-related hyperparameters. This capability enables users to estimate variability or confidence intervals when required, while the fixed-seed configuration in the example prioritizes computational efficiency. Users can modify the experiment seed using the instruction cfg.seed = value, as demonstrated in Section 3 of the experiment notebook available at https://github.com/DEEP-CGPS/FakeVoiceFinder/blob/main/notebooks/3-%20Experiment_All_models_and_transforms.ipynb (accessed on 5 October 2025).

From the obtained values, it can be inferred whether the model is biased and, if so, which class is classified more effectively. This is evidenced by the precision and recall values: the greater the difference between them, the higher the bias of the model. Conversely, similar values indicate that the performance across both classes is comparable.

5.2. Performance Plots: Hybrid-Approach

In this section, three modes of visualization of the performance results obtained by the different models are presented:

• Model-centric: In the first case, bar charts are used for a specific type of transformation for each of the different models obtained by combining architecture and training type (scratch/pretrain).
• data-centric: In the second case, bar charts are also used, but this time the model type (architecture + training type) is fixed across the four transformations (mel, log, DWT, CQT).
• Hybrid-approach: Finally, a heatmap is used, in which both the model (architecture + training type) and the transformation type (mel, log, DWT, CQT) are varied.

To illustrate the three types of visualization, a Basic Experiment has been created within the framework, which is available at https://github.com/DEEP-CGPS/FakeVoiceFinder/blob/main/notebooks/3-%20Experiment_All_models_and_transforms.ipynb (accessed on 5 October 2025). The experiments presented in this example were conducted using a dataset of 600 synthetic audios and 600 real audios. The synthetic audios were obtained from the Mendeley dataset entitled Fake Audio Dataset (ElevenLabs & Respeecher) [50], which was created during the first semester of 2025. On the other hand, the real audios were obtained from public repositories or social networks.

Table 7. Summary of the https://data.mendeley.com/datasets/79g59sp69z/1 (accessed on 5 October 2025).

Category	Detail	Count/Value
Generation Tool	ElevenLabs (V2V)	282
	ElevenLabs (TTS)	53
	Respeecher (V2V)	210
	Respeecher (TTS)	55
Total Audios	V2V	492
	TTS	108
Gender	Male	49%
	Female	51%
Other Characteristics	Duration	8–10 s
	Sampling rate	22,050 Hz

presents the metadata of the Fake Audio Dataset (ElevenLabs & Respeecher available at https://data.mendeley.com/datasets/79g59sp69z/1 (accessed on 5 October 2025)) [50]. This dataset was selected because it includes two widely used and publicly accessible synthetic audio generation tools, ElevenLabs and Respeecher, making it realistic for potential misuse scenarios. It contains both TTS and V2V audios, providing diversity and different artifacts that enrich the classification task and improve robustness. The inclusion of male and female voices helps mitigate gender bias, while the uniform sampling rate (22,050 Hz) ensures consistency without requiring additional preprocessing. Moreover, the audio duration (8–10 s) provides sufficient information for models to capture relevant patterns without incurring high computational costs, achieving a balance between effectiveness and efficiency.

On the other hand, the hyperparameters used for both the data-centric approach and the model-centric approach are presented in (Section 2) Experiment Configuration of the Basic Example. Specifically, the following architectures were used: alexnet, resnet18, vgg16, vit_b_16, and ConvNext_tiny, both with scratch/pretrain training choices.

Figure 7 shows the results of the model-centric approach, where the transformation is fixed to mel and the trained models are compared across the selected architectures and training variants. The objective of this figure is not to identify the best-performing architecture, but to illustrate how the framework enables systematic comparison between CNN- and Transformer-based models, both with and without transfer learning. As larger datasets are used, models become increasingly capable of distinguishing natural from synthetic audio under a fixed representation, highlighting the value of controlled comparisons. This demonstrates the usefulness of FakeVoiceFinder for researchers developing synthetic audio detection solutions, as it allows custom models to be evaluated alongside benchmark architectures under identical experimental conditions. The only requirement is that custom models be provided in .pt or .pth format, which the framework fully supports.

For this particular experiment, the best option was ConvNext_tiny with transfer learning, followed by ResNet18 also with transfer learning, and then the same type of architecture but trained from scratch. Additionally, a significant difference can be observed between using transfer learning in models such as ConvNext_tiny compared to training them from scratch.

Now, Figure 8 presents the data-centric results. In this case, the AlexNet architecture with transfer learning was evaluated across the four available spectral representations. For the same architecture and dataset, the results vary substantially depending on the selected transformation. In this particular example, the performance difference between the best and worst cases exceeds 20%, with the CQT transform achieving the highest number of correctly classified audio samples.

Analyzing results separately with only the model-centric or data-centric option makes it difficult to identify optimal classifier conditions. Therefore, FakeVoiceFinder includes a third form of visualization, corresponding to the Hybrid-approach. To facilitate this type of analysis, a heatmap is used, which allows both previous approaches to be examined simultaneously (See Figure 9).

Now, Figure 9 presents the hybrid analysis, where each spectral representation is evaluated jointly with all architectures. This view shows that performance emerges from the interaction between data representation and model design rather than from either component alone.

In terms of the data representation:

• The CQT representation favors pretrained convolutional models such as AlexNet, ConvNext Tiny, and ResNet18, all above 96%, while transformer architectures drop notably, indicating limited compatibility with this transform.
• With DWT, the pretrained and scratch variants of ResNet18 reach 90.8% and 89.6%, followed by VGG16 pretrained and AlexNet scratch near 89%, reflecting the advantage of strong mid level feature extraction.
• The log-spectrogram benefits classical convolutional models, with ResNet18 pretrained reaching 99.2% and VGG16 pretrained 98.8%, while SimpleCNN and ResNet18 scratch remain above 87%.
• The mel-spectrogram provides stable high performance, with ResNet18 reaching 97.9% and 97.5% for pretrained and scratch variants, and VGG16 pretrained reaching 97.1%.

In terms of the architecture:

• ResNet18 is the most robust architecture, consistently above 94% across all representations, indicating strong generalization.
• VGG16 pretrained performs best under log and mel, while presenting moderate decreases under CQT and DWT.
• AlexNet and ConvNext Tiny show competitive results when pretrained, particularly with CQT, but their scratch versions have more variable performance.
• ViT B 16 is highly sensitive to the representation, performing moderately with mel and DWT but degrading sharply with CQT and log.
• SimpleCNN remains stable between 85% and 88%, illustrating how lightweight custom models can also be systematically evaluated in the framework.

From the user’s perspective, the hybrid analysis demonstrates the importance of having both a broad set of architectures and multiple spectral representations. The library allows any custom model to be evaluated under identical conditions, making it possible to determine whether the observed performance variations originate from architectural choices, from the selected transform, or from their interaction. This systematic exploration is essential, since no representation and no architecture is universally superior, and only their combined assessment reveals the most suitable configuration for a given detection task.

5.3. Inference Module

The inference module of FakeVoiceFinder extends its applicability beyond academic research. Users can evaluate individual audio files with a pre-trained model, obtaining probabilistic scores for the classes real and fake. Starting from a checkpoint and configurable audio transformation (mel, log, or DWT), the system performs pre-processing, generates the input representation, and applies the model to compute softmax probabilities, reported as percentages. To improve interpretability, the module integrates a gauge-style visualization that highlights the probability of fake with qualitative bands (low, medium, high). This dual role, serving as both a research platform and a practical tool, makes the framework useful in contexts such as digital forensics, media verification, or robustness testing.

In the inference demo of the proposed framework, available at https://github.com/DEEP-CGPS/FakeVoiceFinder/blob/main/notebooks/4-%20inference_demo_all.ipynb (accessed on 5 October 2025), the process for performing inference on a single audio file with a pre-trained model is presented. The first step is to configure the input parameters, which include: the path to the pre-trained model, the type of transformation used during training (mel, log, DWT, or CQT), the sampling rate of the audio, the duration of the audio clip in seconds, the size of the input image, and the transformation-specific hyperparameters applied in the training process (See Figure 10).

Once the configuration is defined, the system executes preprocessing, generates the corresponding representation, and applies the model to obtain softmax probabilities for the classes real and fake, reported as percentages. To improve interpretability, the module integrates a gauge-style visualization that highlights the probability of fake with qualitative bands (low, medium, high). This makes the framework suitable not only for academic experiments but also for applied contexts such as digital forensics, media verification, or robustness testing.

For the evaluation of the inference module, the TTS/V2V Audio Deepfake Dataset, available at https://data.mendeley.com/datasets/h4zbs27tkr/2 (accessed on 5 October 2025) was used [51]. This dataset contains both text-to-speech (TTS) and voice-to-voice (V2V) synthetic speech samples. Specifically, 32 trained models were used to evaluate 60 natural and 60 fake audio files.

First, the result for a single audio sample is presented in Figure 11. Probabilities above 50% are interpreted as fake, while values below this threshold are considered real. In this example, the file 592.wav is correctly classified as fake by the ResNet18_pretrained model, with a probabilistic score of 97.58%, which corresponds to its true label.

Subsequently, the 120 selected audio samples from the TTS/V2V Audio Deepfake Dataset were evaluated, and the results of the 32 models for each of the four spectral representations are presented in Figure 12.

Figure 12 shows a wide dispersion in accuracy values across both model architectures and spectral representations, highlighting the importance of evaluating multiple configurations under identical training conditions. The heatmap reveals that certain architectures, such as ConvNext Tiny (pretrained), exhibit large performance fluctuations depending on the spectral representation used: high accuracy under CQT transform, but substantially lower performance under DWT. This variability demonstrates that architectural strength alone does not guarantee robust performance, and that the choice of spectral representation can dramatically alter a model’s effectiveness in detecting synthetic audio.

In contrast, some models display consistently poor performance regardless of the representation, such as ViT_B_16 (pretrained), which remains among the lowest-performing architectures across all transforms. These cases underscore the value of benchmarking many models simultaneously: the framework makes it possible to identify not only strong global performers, but also architectures that are highly sensitive to feature design or fundamentally unsuitable for the task. Overall, the figure illustrates how model architecture and spectral representation interact in complex ways, reinforcing the necessity of comparative, controlled experimentation in audio deepfake detection research.

As a next step, only synthetic audios generated using TTS technology (Figure 13) and V2V technology (Figure 14) were evaluated, with the aim of determining whether the models exhibited greater difficulty when the synthetic samples originated from either of these two types.

One of the main advantages of training a large set of models under identical experimental conditions is the ability to extract reliable comparative insights regarding how architectures and spectral representations behave when confronted with different types of synthetic audio. Since the 32 models were trained using a dataset in which approximately 82% of the synthetic samples were generated with V2V technology, the evaluation highlights the extent to which each model can generalize beyond the dominant manipulation type seen during training.

The comparison between the TTS-only and V2V-only evaluations reveals several consistent patterns. First, most architectures achieve considerably higher accuracy when detecting V2V-generated audio, suggesting that V2V artifacts are more easily captured by the models, especially under the CQT and DWT representations. In contrast, the TTS-generated audios produce more variability and lower accuracy, particularly in weaker architectures trained from scratch, which indicates that TTS manipulations introduce signal characteristics that are more challenging to model under limited training diversity.

Second, systematic cross-representation analysis shows that DWT and CQT provide the most stable performance across both scenarios, whereas log and mel are more sensitive to the choice of architecture.

Finally, the side-by-side comparison makes it possible to identify models that generalize well across both manipulation types, as well as those that perform strongly under V2V but degrade substantially under TTS. These findings demonstrate the analytical potential of the framework: by enforcing identical hyperparameters and preprocessing choices, it becomes possible to uncover nuanced interactions between model architecture, spectral representation, and the nature of the synthetic audio to be detected.

5.4. Comparison with Existing Frameworks

Several open-source initiatives have addressed the problem of synthetic audio and deepfake voice detection. While many focus on specific architectures or evaluation protocols, few provide an integrated environment comparable to FakeVoiceFinder, where both model-centric and data-centric analyses can be performed systematically. Below we summarize some of the most representative frameworks and repositories.

The ASVspoof challenge repositories (2019, 2021, 2025) [5,6] provide baseline systems, datasets, and standardized evaluation protocols for anti-spoofing. They are the de facto benchmark in the field, but they are primarily focused on fixed datasets and do not provide modular tools for user-defined experimentation.

The more recent VoiceWukong project emphasizes benchmarking under realistic threat models, integrating diverse attacks and evaluation settings. However, its focus is on standardized security evaluation rather than providing a flexible environment for hybrid analysis.

Another relevant initiative is Deep-O-Meter (University at Buffalo), accessible at https://zinc.cse.buffalo.edu/ubmdfl/deep-o-meter/home_login (accessed on 5 October 2025). It is designed as a multimodal platform for deepfake detection (image, video, audio), where users can upload content and receive classification scores. Unlike FakeVoiceFinder, which emphasizes reproducibility and experimentation with user-defined datasets and architectures, Deep-O-Meter operates mainly as an evaluation interface rather than a research framework.

Other research-oriented repositories include implementations of specific architectures or strategies, such as CNN-based pipelines for audio deepfake detection [43], end-to-end Transformers with knowledge distillation, and frameworks oriented towards adversarial robustness testing. These are valuable contributions, but they generally address one methodological dimension in isolation.

As seen in

Table 8. Comparison of open-source frameworks for synthetic audio detection.

Framework	Focus	Key Features
ASVspoof (2019–2025)	Benchmarking anti-spoofing	Fixed datasets, baselines (GMM, CNN, LCNN), standardized protocols
VoiceWukong (2025)	Security benchmarking	Multi-attack scenarios, robust evaluation
Deep-O-Meter (UB, 2024)	Multimodal deepfake detection	Online platform (image, video, audio); evaluation interface for uploaded content
Audio Deepfake Detection (2025 [43])	CNN-based architectures	Detection of TTS and VC audio
End-to-End Audio Transformer (2024 [52])	Transformer + distillation	End-to-end pipeline for deepfake detection
Adversarial Testing (2024 [53])	Robustness analysis	Evaluation under adversarial attacks
FakeVoiceFinder (2025, own)	Model- and data-centric hybrid analysis	Flexible benchmarking with user datasets, probabilistic inference, visualization modes

, most existing solutions provide either datasets, baselines, or evaluation protocols, but not an integrated environment that allows researchers to systematically explore the interaction between data representations and architectures. In contrast, FakeVoiceFinder is explicitly designed as a flexible framework where users can upload their own datasets, test standard or custom architectures, and obtain comparable results across multiple experimental conditions.

This unified view, where both the architectural dimension and the signal-representation dimension can be explored systematically under identical preprocessing, splits, and metrics, is not supported by any of the existing open-source frameworks reviewed.

6. Discussion

The primary aim of FakeVoiceFinder is not to establish the superiority of a particular model or spectral representation, but to offer a flexible and reproducible environment in which users can systematically evaluate their own datasets and architectures. The results presented in this article serve as illustrative examples of the types of metrics, visualizations, and inference outputs that the framework can generate. The main strength of the library lies in its capacity to adapt to diverse experimental configurations while ensuring methodological consistency.

A key contribution of the framework is its ability to benchmark custom architectures against well-established baselines under strictly controlled and comparable conditions. Users can evaluate models using identical datasets, fixed training schedules, unified hyperparameters, and a standardized set of spectral representations (mel, log, DWT, and CQT). This addresses a recurrent limitation in the deepfake-audio literature, where differences in preprocessing steps, model configurations, or evaluation methodologies often hinder direct comparison of results across studies. By enforcing uniform experimental conditions, FakeVoiceFinder enables a rigorous and unbiased assessment of whether specific architectural choices provide genuine performance improvements.

The framework also supports model-centric, data-centric, and hybrid evaluation strategies. This allows researchers to analyze whether improvements in detection performance stem from architectural innovations, from the choice of spectral representation, or from the interaction between both. Such a comprehensive perspective remains uncommon in current research, where studies typically focus on one of these dimensions in isolation. Additionally, the possibility of specifying custom random seeds (cfg.seed) allows for repeated experimental runs when desired, supporting the estimation of variability or confidence intervals and strengthening reproducibility.

The probabilistic inference module expands the practical applicability of the library. Users can train models with their own data and subsequently deploy them to evaluate individual audio samples across all supported spectral transformations, including mel, log, DWT, and CQT. The resulting probabilistic scores are useful not only for academic research but also for applied scenarios such as digital forensics, media verification, and robustness evaluation against adversarial or signal-level perturbations.

Overall, FakeVoiceFinder provides a solid foundation for advancing reproducibility, comparability, and transparency in synthetic-audio detection research. Its open-source nature, modular design, compatibility with custom datasets and models, and coherent experimental workflow position it as a versatile tool for both scientific inquiry and practical analysis.

7. Conclusions

This work introduced FakeVoiceFinder, an open-source framework that enables systematic analysis of synthetic audio detection from both model-centric and data-centric perspectives. The library integrates multiple audio transformations (mel, log, DWT, and CQT) with diverse deep learning architectures (CNNs and Transformers), providing a flexible environment for benchmarking under consistent and reproducible experimental conditions.

The results obtained from the Basic Example highlight three main findings. First, detection performance depends not only on the choice of architecture but also on the selected spectral representation, with differences reaching up to 40% in some cases (for example, the ConvNext_tiny pretrained configuration). Second, the hybrid approach shows that no single transformation or architecture consistently outperforms the others, underscoring the importance of combined and comparative evaluations. Third, the probabilistic inference module extends the applicability of the framework beyond academic research, enabling practitioners to evaluate individual audio samples and assess model robustness under adversarial or signal-level manipulations.

A distinctive feature of the framework is that users can upload their own custom models and directly compare them against well-established benchmark architectures under identical experimental conditions, including the type of spectral transformation. This functionality addresses a recurrent difficulty in the field, namely the challenge of producing fair and meaningful comparisons. Instead of relying on performance metrics reported across heterogeneous publications, often based on different datasets, preprocessing steps, or evaluation protocols, researchers can rigorously determine whether a proposed solution offers genuine improvements or whether it falls short of competitive performance.

By making this framework openly available, we aim to support reproducibility, comparability, and methodological transparency in the study of synthetic and deepfake audio detection.