Rules

Summary of the rules for systems participating in the challenge:

  • For building the system, it is allowed to use the training subset of MMCSG dataset and external data listed in the subsection Data and pre-trained models. If you believe there is some public dataset missing, you can propose it to be added until the deadline as specified in the schedule.
  • The development subset of MMCSG can be used for evaluating the system throughout the challenge period, but not for training or automatic tuning of the systems.
  • Pre-trained models are listed in the “Data and pre-trained models” subsection. Only those pre-trained models are allowed to be used. If you believe there is some model missing, you can propose it to be added until the deadline as specified in the schedule.
  • The submitted systems must be streaming, i.e. process its inputs sequentially in time and specify latency for each emitted word, as described in detail in the subsection Evaluation. It must not use any global information from a recording before processing it in temporal order. Such global information could include global normalizations, non-streaming speaker identification or diarization, etc. This requirement on streaming processing applies to all modalities (audio, visual, accelerometer, gyroscope, etc).
  • The details of the streaming nature of the system, including any lookahead, chunk-based processing, other details that would impact latency, and an explicit estimate of the average algorithmic and emission latency itself should be clearly described in a section of the submitted system description with the heading “Latency”.
  • For evaluation, each recording must be considered separately. The system should not be in any way fine-tuned on the entire evaluation set (e.g. by computing global statistics, gathering speaker information across multiple recordings). If your system does not comply with these rules (e.g. by using a private dataset or having only a partially streaming method), you may still submit your system, but we will not include it in the final rankings.

Evaluation

The submitted systems will be evaluated on speech recognition performance using multitalker word error rate for the latency thresholds: 1000ms, 350ms, 150ms. The average latency of correctly recognized words is computed for each system and then the system is classified into one of four categories based on these thresholds. Systems within the same category will be compared to one another using multitalker word error rate.

To do this, there are two main pieces of additional information that the systems need to provide in the hypotheses:

  • speaker attribution: each word in the hypothesis must be attributed to SELF or OTHER speaker
  • word time-stamps: each word must has a time-stamp corresponding to when the word was decoded (more details below)

Multitalker word error rate evaluates the transcription of SELF and OTHER speakers jointly and it expects the words to be correctly attributed to these two speakers. It breaks down the error into substitutions, insertions, deletions and speaker-attribution errors.
As an example, for the following conversation:

SELF: I had a beer OTHER: oh yes? how was it? SELF: good great!

with the hypothesis provided by the system including speaker attributions as:

SELF ehm i have a deer oh yeah OTHER how was it good

The alignment computed by the multitalker WER is as follows:

Alignment of the reference and hypothesis computed by multitalker WER containins sub, ins, del, attr errors.

Note that some words (‘yes’) are both substituted and mis-attributed. For these types of errors, we choose to include them into speaker-attribution errors. The final multitalker WER is then computed for SELF and OTHER as:

Definition of multitalker WER for SELF: ratio of sub + ins + del + attr and number of reference words

Definition of multitalker WER for OTHER: ratio of sub + ins + del + attr and number of reference words

where NREF is the number of reference words. ATTR_self denotes words of SELF that are attributed to OTHER, and vice versa. In the example above:

Multitalker WER for the example above, MWER for SELF is 0.83, MWER for OTHER is 0.4

Before computing multitalker WER, both reference and transcription are normalized, by removing punctuation, normalizing capitalization and performing permitted substitutions defined in this file. For evaluation of latency, we consider algorithmic and emission latency of the system, not computational latency. That is, we assume that the computation of the forward pass through the system is instant and we are not asking for actual measurements of the wall-clock time necessary to run the system (even though we encourage reporting that). Instead, we require the systems to provide the information of how much of the input signal the system used to emit each of the words. For example, in the hypothesis above, the word-timestamps (in seconds) could look as follows:

Example output of system with timestamp for each word

Here, timestamp 1.62 for word “ehm” means that the system had processed 1.62 seconds of the input recording when finished emitting the entire word “ehm”. The measurement of the word-timestamps needs to take into account the look-ahead of the model, as well as any emission latency that the model learned to have. The most simple way to obtain the timestamps reliably (which is also used in the baseline system) is to implement the inference chunk-by-chunk and use the end of the chunk as the timestamp for any words emitted during the processing of this chunk. Two examples of how the timestamps would be defined for different types of systems are here and here. Please contact us, if you are unsure how to derive the timestamps for your type of system.

To test whether the word-timestamps, which you provide with the hypothesis, are correctly reflecting the functioning of your system, you might try to pass a signal perturbed from certain time t onward. All words that originally had timestamps < t should remain the same as with the original signal.

Example of how to test whether provided timestamps are correct

We provide scripts to perform this test on a subset of recordings at our Github repo. As part of the submission, we will ask for the outputs of this test. We encourage the participants to perform this test during the development of their systems as it is easy to overlook some aspects that could make the system non-streaming (such as global normalizations, beam search leading to corrections in the past decoded words, etc).

The evaluation script accepts the hypothesis in the same format as the provided references, that is one TSV file per recording. More information on the format and on how to run the evaluation is provided in the Github README. During submission, the participants will provide the transcription files and the evaluated scores using the provided evaluation script. Furthermore, the participants are required to submit a system description. Publishing of scripts to reproduce the submitted systems is encouraged, but not required.

External data and pre-trained models

Besides the MMCSG dataset published with this challenge, the participants are allowed to use public datasets and pre-trained models listed below. In case you want to propose additional dataset or pre-trained model to be added to these lists, do so by contacting us at Slack until March 20th ‘24. If you want to use a private dataset or model, you may still submit your system to the challenge, but we will not include it in the final rankings.

Participants may use these publicly available datasets for building the systems:

  • LibriSpeech
  • MUSAN
  • RWCP Sound Scene Database
  • REVERB Challenge RIRs.
  • Aachen AIR dataset.
  • BUT Reverb database.
  • SLR28 RIR and Noise Database (contains Aachen AIR, MUSAN noise,
  • RWCP sound scene database and REVERB challenge RIRs, plus simulated ones).
  • VoxCeleb 1&2
  • FSD50k
  • WSJ0-2mix, WHAM, WHAMR, WSJ
  • SINS
  • Ego4D
  • Project Aria Datasets

In addition, following pre-trained models may be used:

  • Wav2vec:
    • S3PRL:
      • wav2vec-large
  • Wav2vec 2.0:
    • Fairseq :
      • All models including Wav2Vec 2.0 Large (LV-60 + CV + SWBD + FSH) and the multi-lingual XLSR-53 56k
    • Torchaudio:
      • WAV2VEC2_BASE
      • WAV2VEC2_LARGE
      • WAV2VEC2_LARGE_LV60K
      • WAV2VEC2_XLSR53
      • WAV2VEC2_ASR_LARGE_LV60K_960H
      • WAV2VEC2_ASR_BASE_960
    • Huggingface:
      • facebook/wav2vec2-base-960h
      • facebook/wav2vec2-large-960h
      • facebook/wav2vec2-large-960h-lv60-self
      • facebook/wav2vec2-base
      • facebook/wav2vec2-large-lv60
      • facebook/wav2vec2-large-xlsr-53
      • wav2vec2-large lv60 + speaker verification
      • Other models on Huggingface using the same weights as the Fairseq ones.
    • S3PRL
      • wav2vec2_base_960
      • wav2vec2_base_960
      • wav2vec2_large_960
      • wav2vec2_large_ll60k
      • wav2vec2_large_lv60_cv_swbd_fsh
      • wav2vec2_conformer_relpos
      • wav2vec2_conformer_rope
      • Xlsr_53
  • HuBERT
    • Torchaudio
      • HuBERT base
      • HuBERT large
      • HuBERT xlarge
      • HuBERT ASR large HuBERT ASR xlarge
    • Huggingface:
      • hubert-base-ls960
      • hubert-large-ll60k
      • hubert-xlarge-ll60k
      • hubert-large-ls960-ft
      • hubert-xlarge-ls960-ft
    • S3PRL:
      • hubert-base
      • hubert-large_ll60k
  • WavLM
    • Huggingface:
      • wavlm-base
      • wavlm-base-sv
      • wavlm-base-sd
      • wavlm-base-plus
      • wavlm-base-plus-sv
      • wavlm-base-plus-sd
      • wavlm-large
    • S3PRL:
      • wavlm-base
      • wavlm-base-plus
      • wavlm-large
  • Tacotron2
    • Torchaudio:
      • tacotron2-wavernn-phone-ljspeech
      • tacotron2-griffinlim-phone-ljspeech
      • tacotron2-wavernn-char-ljspeech
      • tacotron2-griffinlim-char-ljspeech
  • ECAPA-TDNN
    • Speechbrain
    • NeMo toolkit
  • X-vector extractor
    • VBx repo ResNet101 16kHz
    • Kaldi
    • Pyannote Audio
  • Pyannote Segmentation
  • Pyannote Diarization (Pyannote Segmentation+ECAPA-TDNN from SpeechBrain)
  • NeMo toolkit ASR pre-trained models:
    • Citrinet
    • Conformer-CTC
    • Conformer-Transducer
  • NeMo toolkit speaker ID embeddings models:
    • TitaNet
    • SpeakerNet
    • ECAPA-TDNN
  • NeMo toolkit VAD models:
    • MarbleNet VAD
  • NeMo toolkit diarization models:
    • Multi-Scale Diarization Decoder