Voice Safety Classifier v2

README.md

@@ -10,4 +10,59 @@ language:
 - ko
 - ja
 library_name: transformers
----
+---
+## Model Description
+We present a voice-safety classification model that can be used for voice-toxicity detection and classification.
+The model has been distilled into the [WavLM](https://arxiv.org/abs/2110.13900) architecture from a larger teacher model.
+All the model training has been conducted with Roblox internal voice chat datasets,
+using both machine and human-labeled data, with over 100k hours of training data in total.
+We have also published a blog post about this work.
+
+The model supports eight languages: English, Spanish, German, French, Portuguese, Italian, Korean, and Japanese.
+It classifies the input audio into six toxicity classes in a multilabel fashion. The class labels are as follows:
+`Discrimination`, `Harassment`, `Sexual`, `IllegalAndRegulated`, `DatingAndRomantic`, and `Profanity`.
+Please refer to [Roblox Community Standards](https://en.help.roblox.com/hc/en-us/articles/203313410-Roblox-Community-Standards)
+for a detailed explanation on the policy, which has been used for labeling the datasets.
+The model outputs have been calibrated for the Roblox voice chat environment,
+so that the class scores after a sigmoid can be interpreted as probabilities.
+
+The classifier expects 16kHz audio segments as input. Ideal segment length is 15 seconds,
+but the classifier can operate on shorter segments as well. The prediction accuracy may degrade
+for longer segments.
+
+The table below displays evaluation precision and recall for each of the supported languages,
+as calculated over internal language-specific held-out datasets, which resemble the Roblox voice chat traffic.
+The operating thresholds for each of the categories were kept equal per language, and optimized
+to achieve a false positive rate of 1%. The classifier was then evaluated as a binary classifier,
+tagging the audio as positive if any of the heads exceeded the threshold.
+
+|Language|Precision|Recall|
+|---|---|---|
+|English   |63.9%|58.2%|
+|Spanish   |76.1%|63.2%|
+|German    |69.9%|74.1%|
+|French    |70.3%|69.8%|
+|Portuguese|85.4%|58.0%|
+|Italian   |86.6%|52.4%|
+|Korean    |78.0%|64.6%|
+|Japanese  |56.7%|57.7%|
+
+Compared to the v1 voice safety classifier, the v2 model
+expands the support from English to 7 additional languages,
+as well as significantly improving the classification accuracy.
+With the 1% false positive rate as above, the binary recall for English is improved by 92%.
+
+
+## Usage
+The dependencies for the inference file can be installed as follows:
+```
+pip install -r requirements.txt
+```
+The provided Python file demonstrates how to use the classifier with arbitrary 16kHz audio input.
+To run the inference, please run the following command:
+```
+python inference.py --audio_file <your audio file path> --model_path <path to Huggingface model>
+```
+You can download the model weights from the model releases page [here](https://github.com/Roblox/voice-safety-classifier/releases/tag/vs-classifier-v2),
+or from HuggingFace under [`roblox/voice-safety-classifier-v2`](https://huggingface.co/Roblox/voice-safety-classifier-v2).
+If `model_path` isn’t specified, the model will be loaded directly from HuggingFace.

config.json

@@ -0,0 +1,141 @@
+{
+  "_name_or_path": "patrickvonplaten/wavlm-libri-clean-100h-base-plus",
+  "activation_dropout": 0.0,
+  "adapter_kernel_size": 3,
+  "adapter_stride": 2,
+  "add_adapter": false,
+  "apply_spec_augment": true,
+  "architectures": [
+    "WavLMForSequenceClassification"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "codevector_dim": 256,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": false,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2,
+    7
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "mean",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": false,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.0,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.0,
+  "freeze_feat_extract_train": true,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.0,
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2",
+    "3": "LABEL_3",
+    "4": "LABEL_4",
+    "5": "LABEL_5"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2,
+    "LABEL_3": 3,
+    "LABEL_4": 4,
+    "LABEL_5": 5
+  },
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.0,
+  "mask_channel_length": 10,
+  "mask_channel_min_space": 1,
+  "mask_channel_other": 0.0,
+  "mask_channel_prob": 0.0,
+  "mask_channel_selection": "static",
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_min_space": 1,
+  "mask_time_other": 0.0,
+  "mask_time_prob": 0.05,
+  "mask_time_selection": "static",
+  "max_bucket_distance": 800,
+  "model_type": "wavlm",
+  "no_mask_channel_overlap": false,
+  "no_mask_time_overlap": false,
+  "num_adapter_layers": 3,
+  "num_attention_heads": 16,
+  "num_buckets": 320,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_ctc_classes": 80,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 10,
+  "num_negatives": 100,
+  "output_hidden_size": 768,
+  "pad_token_id": 28,
+  "proj_codevector_dim": 256,
+  "replace_prob": 0.5,
+  "tdnn_dilation": [
+    1,
+    2,
+    3,
+    1,
+    1
+  ],
+  "tdnn_dim": [
+    512,
+    512,
+    512,
+    512,
+    1500
+  ],
+  "tdnn_kernel": [
+    5,
+    3,
+    3,
+    1,
+    1
+  ],
+  "tokenizer_class": "Wav2Vec2CTCTokenizer",
+  "torch_dtype": "float32",
+  "transformers_version": "4.38.2",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 31,
+  "xvector_output_dim": 512
+}

inference.py

@@ -0,0 +1,111 @@
+# Copyright © 2024 Roblox Corporation
+
+"""
+This file gives a sample demonstration of how to use the given functions in Python, for the Voice Safety Classifier model. 
+"""
+
+import torch
+import librosa
+import numpy as np
+import argparse
+from transformers import WavLMForSequenceClassification
+
+
+def feature_extract_simple(
+    wav,
+    sr=16_000,
+    win_len=15.0,
+    win_stride=15.0,
+    do_normalize=False,
+):
+    """simple feature extraction for wavLM
+    Parameters
+    ----------
+    wav : str or array-like
+        path to the wav file, or array-like
+    sr : int, optional
+        sample rate, by default 16_000
+    win_len : float, optional
+        window length, by default 15.0
+    win_stride : float, optional
+        window stride, by default 15.0
+    do_normalize: bool, optional
+        whether to normalize the input, by default False.
+    Returns
+    -------
+    np.ndarray
+        batched input to wavLM
+    """
+    if type(wav) == str:
+        signal, _ = librosa.core.load(wav, sr=sr)
+    else:
+        try:
+            signal = np.array(wav).squeeze()
+        except Exception as e:
+            print(e)
+            raise RuntimeError
+    batched_input = []
+    stride = int(win_stride * sr)
+    l = int(win_len * sr)
+    if len(signal) / sr > win_len:
+        for i in range(0, len(signal), stride):
+            if i + int(win_len * sr) > len(signal):
+                # padding the last chunk to make it the same length as others
+                chunked = np.pad(signal[i:], (0, l - len(signal[i:])))
+            else:
+                chunked = signal[i : i + l]
+            if do_normalize:
+                chunked = (chunked - np.mean(chunked)) / (np.std(chunked) + 1e-7)
+            batched_input.append(chunked)
+            if i + int(win_len * sr) > len(signal):
+                break
+    else:
+        if do_normalize:
+            signal = (signal - np.mean(signal)) / (np.std(signal) + 1e-7)
+        batched_input.append(signal)
+    return np.stack(batched_input)  # [N, T]
+
+
+def infer(model, inputs):
+    output = model(inputs)
+    probs = torch.sigmoid(torch.Tensor(output.logits))
+    return probs
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--audio_file",
+        type=str,
+        help="File to run inference",
+    )
+    parser.add_argument(
+        "--model_path",
+        type=str,
+        default="roblox/voice-safety-classifier",
+        help="checkpoint file of model",
+    )
+    args = parser.parse_args()
+    labels_name_list = [
+        "Discrimination",
+        "Harassment",
+        "Sexual",
+        "IllegalAndRegulated",
+        "DatingAndRomantic",
+        "Profanity",
+    ]
+
+    # Model is trained on only 16kHz audio
+    audio, _ = librosa.core.load(args.audio_file, sr=16000)
+    input_np = feature_extract_simple(audio, sr=16000)
+    input_pt = torch.Tensor(input_np)
+    model = WavLMForSequenceClassification.from_pretrained(
+        args.model_path, num_labels=len(labels_name_list)
+    )
+    probs = infer(model, input_pt)
+    probs = probs.reshape(-1, 6).detach().tolist()
+    print(f"Probabilities for {args.audio_file}:")
+    for chunk_idx in range(len(probs)):
+        print(f"\nSegment {chunk_idx}:")
+        for label_idx, label in enumerate(labels_name_list):
+            print(f"{label} : {probs[chunk_idx][label_idx]}")

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8311e17845ff80ca00973d0aca5e898c20a3e390f1fd2783a4c227d5b9aec559
+size 480863848

requirements.txt

@@ -0,0 +1,4 @@
+torch
+transformers
+librosa
+numpy