diff --git "a/huggingface_distil-whisper.txt" "b/huggingface_distil-whisper.txt"
new file mode 100644--- /dev/null
+++ "b/huggingface_distil-whisper.txt"
@@ -0,0 +1,6613 @@
+# File: distil-whisper-main/training/create_student_model.py
+""""""
+import argparse
+import copy
+import logging
+import numpy as np
+import torch
+from transformers import GenerationConfig, WhisperForConditionalGeneration, WhisperProcessor
+logger = logging.getLogger(__name__)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Initialise a student Whisper model from a teacher model, copying the relevant layer weights and adjusting the processor as necessary.')
+    parser.add_argument('--teacher_checkpoint', type=str, required=True, help='The HF Hub ID of the teacher checkpoint.')
+    parser.add_argument('--subfolder', type=str, default='', help='In case the relevant teacher weights are located inside a subfolder of the model repo on huggingface.co, you can specify the folder name here.')
+    parser.add_argument('--encoder_layers', type=int, default=None, help='Number of encoder layers to use in the student model. Defaults to all layers from the teacher.')
+    parser.add_argument('--decoder_layers', type=int, default=2, help='Number of decoder layers to use in the student model. Defaults to 2 layers.')
+    parser.add_argument('--decoder_layers_numbers', type=int, nargs='*', help='Layers numbers of the decoder teacher to use in the student model. Defaults to None, equivalent to taking first and last layer (and equivalent to `--decoder_layers_numbers 0 -1`).')
+    parser.add_argument('--save_dir', type=str, required=True, help='Where to save the student weights and processor.')
+    parser.add_argument('--push_to_hub', type=bool, required=False, default=False, help='Whether to push the student weights and processor to the Hub.')
+    parser.add_argument('--cache_dir', type=str, default=None, help='Where to store the pretrained models downloaded from huggingface.co')
+    args = parser.parse_args()
+    return args
+
+def init_student_model_from_teacher(teacher_checkpoint, encoder_layers=None, decoder_layers=2, decoder_layers_numbers=None, save_dir=None, push_to_hub=None, cache_dir=None, subfolder=''):
+    if decoder_layers_numbers is not None and len(decoder_layers_numbers) != decoder_layers:
+        raise ValueError(f'Got {len(decoder_layers_numbers)} layers number for {decoder_layers} decoder layers.')
+    teacher_model = WhisperForConditionalGeneration.from_pretrained(teacher_checkpoint, cache_dir=cache_dir, subfolder=subfolder, low_cpu_mem_usage=True)
+    processor = WhisperProcessor.from_pretrained(teacher_checkpoint)
+    generation_config = GenerationConfig.from_pretrained(teacher_checkpoint)
+    generation_config.forced_decoder_ids = None
+    teacher_config = teacher_model.config
+    teacher_encoder_layers = teacher_config.encoder_layers
+    teacher_decoder_layers = teacher_config.decoder_layers
+    student_config = copy.deepcopy(teacher_config)
+    student_config.update({'encoder_layers': encoder_layers if encoder_layers is not None else teacher_encoder_layers, 'decoder_layers': decoder_layers})
+    encoder_mapping = np.linspace(0, teacher_encoder_layers - 1, student_config.encoder_layers, dtype=int)
+    encoder_mapping[-1] = teacher_encoder_layers - 1
+    encoder_map = {}
+    for (student_layer, teacher_layer) in enumerate(encoder_mapping):
+        encoder_map[teacher_layer] = student_layer
+    if decoder_layers_numbers is None:
+        decoder_mapping = np.linspace(0, teacher_decoder_layers - 1, student_config.decoder_layers, dtype=int)
+        decoder_mapping[-1] = teacher_decoder_layers - 1
+    else:
+        decoder_mapping = decoder_layers_numbers
+    decoder_map = {}
+    for (student_layer, teacher_layer) in enumerate(decoder_mapping):
+        decoder_map[teacher_layer] = student_layer
+    student_model = WhisperForConditionalGeneration(student_config)
+    (missing_keys, unexpected_keys) = student_model.load_state_dict(teacher_model.state_dict(), strict=False)
+    if len(missing_keys) > 0:
+        raise RuntimeError(f'Error(s) in loading state_dict for WhisperForConditionalGeneration. \nMissing key(s) in state_dict: {missing_keys}')
+    if decoder_layers == teacher_decoder_layers:
+        decoder_keys = [key for key in unexpected_keys if 'model.decoder.layers' in key]
+        if len(decoder_keys) > 0:
+            raise RuntimeError(f'Error(s) in loading state_dict for WhisperForConditionalGeneration. \nUnexpected key(s) in state_dict: {decoder_keys}')
+    if encoder_layers == teacher_encoder_layers:
+        encoder_keys = [key for key in unexpected_keys if 'model.encoder.layers' in key]
+        if len(encoder_keys) > 0:
+            raise RuntimeError(f'Error(s) in loading state_dict for WhisperForConditionalGeneration. \nUnexpected key(s) in state_dict: {encoder_keys}')
+    for layer in range(teacher_decoder_layers):
+        if layer in decoder_map:
+            student_model.model.decoder.layers[decoder_map[layer]].load_state_dict(teacher_model.model.decoder.layers[layer].state_dict())
+    if encoder_layers is not None:
+        for layer in range(teacher_encoder_layers):
+            if layer in encoder_map:
+                student_model.model.encoder.layers[encoder_map[layer]].load_state_dict(teacher_model.model.encoder.layers[layer].state_dict())
+    del teacher_model
+    if save_dir is not None:
+        student_model.save_pretrained(save_dir)
+        processor.save_pretrained(save_dir)
+        generation_config.save_pretrained(save_dir)
+    logger.info('Checking we can load the saved model...')
+    student_model = WhisperForConditionalGeneration.from_pretrained(save_dir, low_cpu_mem_usage=True)
+    processor = WhisperProcessor.from_pretrained(save_dir)
+    input_features = processor(np.ones(16000), sampling_rate=16000, return_tensors='pt').input_features
+    decoder_start_token_id = student_model.config.decoder_start_token_id
+    decoder_input_ids = torch.ones((input_features.shape[0], 1), dtype=torch.long) * decoder_start_token_id
+    logger.info('Checking we can run the converted model forward...')
+    _ = student_model(input_features, decoder_input_ids=decoder_input_ids).logits
+    logger.info('Conversion successful!')
+    if push_to_hub:
+        student_model.push_to_hub(save_dir)
+        processor.push_to_hub(save_dir)
+        generation_config.push_to_hub(save_dir)
+if __name__ == '__main__':
+    args = parse_args()
+    init_student_model_from_teacher(teacher_checkpoint=args.teacher_checkpoint, encoder_layers=args.encoder_layers, decoder_layers=args.decoder_layers, decoder_layers_numbers=args.decoder_layers_numbers, save_dir=args.save_dir, push_to_hub=args.push_to_hub, cache_dir=args.cache_dir, subfolder=args.subfolder)
+
+# File: distil-whisper-main/training/flax/convert_train_state_to_hf.py
+""""""
+import logging
+import os
+import sys
+from dataclasses import field
+from pathlib import Path
+from typing import Callable, Optional
+import flax
+import jax
+import jax.numpy as jnp
+import optax
+from flax import jax_utils, traverse_util
+from flax.serialization import from_bytes
+from flax.training import train_state
+from flax.training.common_utils import shard_prng_key
+from huggingface_hub import Repository, create_repo
+from optax._src import linear_algebra
+from transformers import AutoConfig, HfArgumentParser, Seq2SeqTrainingArguments
+from transformers.file_utils import get_full_repo_name
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+from distil_whisper import FlaxWhisperForConditionalGeneration
+jax.distributed.initialize()
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: pip install -r examples/flax/speech-recogintion/requirements.txt')
+logger = logging.getLogger(__name__)
+
+@flax.struct.dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained student model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    use_auth_token: bool = field(default=False, metadata={'help': 'Will use the token generated when running `transformers-cli login` (necessary to use this script with private models).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'Floating-point format in which the model weights should be initialized and trained. Choose one of `[float32, float16, bfloat16]`.'})
+    load_with_scan_weights: bool = field(default=False, metadata={'help': 'Whether the pre-trained checkpoint has its weights stored in scan format. Set to True for scanned weights, defaults to False for non-scan (unrolled) weights.'})
+    use_scan: bool = field(default=True, metadata={'help': 'Whether or not to use `scan_with_axes` over the encoder and decoder blocks.'})
+
+def create_learning_rate_fn(num_train_steps: int, lr_scheduler_type: str, num_warmup_steps: int, learning_rate: float) -> Callable[[int], jnp.array]:
+    lr_scheduler_types = ('linear', 'constant_with_warmup')
+    if lr_scheduler_type not in lr_scheduler_types:
+        raise ValueError(f'lr_scheduler_type of type {lr_scheduler_type} not supported, choose from {lr_scheduler_types}.')
+    warmup_fn = optax.linear_schedule(init_value=0.0, end_value=learning_rate, transition_steps=num_warmup_steps)
+    decay_fn = optax.linear_schedule(init_value=learning_rate, end_value=0 if lr_scheduler_type == 'linear' else learning_rate, transition_steps=num_train_steps - num_warmup_steps)
+    schedule_fn = optax.join_schedules(schedules=[warmup_fn, decay_fn], boundaries=[num_warmup_steps])
+    return schedule_fn
+
+class TrainState(train_state.TrainState):
+    dropout_rng: jnp.ndarray
+    max_grad_norm: float
+
+    def apply_gradients(self, *, grads, **kwargs):
+        g_norm = linear_algebra.global_norm(grads)
+        g_norm = jnp.maximum(self.max_grad_norm, g_norm)
+        grads = jax.tree_map(lambda t: t / g_norm * self.max_grad_norm, grads)
+        (updates, new_opt_state) = self.tx.update(grads, self.opt_state, self.params)
+        new_params = optax.apply_updates(self.params, updates)
+        return self.replace(step=self.step + 1, params=new_params, opt_state=new_opt_state, **kwargs)
+
+    def replicate(self):
+        return jax_utils.replicate(self).replace(dropout_rng=shard_prng_key(self.dropout_rng))
+
+    def unreplicate(self):
+        return jax_utils.unreplicate(self)
+
+def main():
+    parser = HfArgumentParser((ModelArguments, Seq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, training_args) = parser.parse_args_into_dataclasses()
+    if training_args.push_to_hub:
+        if training_args.hub_model_id is None:
+            repo_name = get_full_repo_name(Path(training_args.output_dir).absolute().name, token=training_args.hub_token)
+        else:
+            repo_name = training_args.hub_model_id
+        create_repo(repo_name, exist_ok=True, token=training_args.hub_token)
+        repo = Repository(training_args.output_dir, clone_from=repo_name, token=training_args.hub_token)
+    config = AutoConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    (student_model, student_params) = FlaxWhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, dtype=getattr(jnp, model_args.dtype), cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None, _do_init=False, use_scan=model_args.load_with_scan_weights)
+    if model_args.use_scan:
+        student_model.enable_scan()
+        student_params = student_model.convert_unroll_to_scan(student_params)
+    rng = jax.random.PRNGKey(training_args.seed)
+    (rng, dropout_rng) = jax.random.split(rng)
+    total_train_steps = int(training_args.max_steps)
+    linear_decay_lr_schedule_fn = create_learning_rate_fn(total_train_steps, training_args.lr_scheduler_type, training_args.warmup_steps, training_args.learning_rate)
+
+    def decay_mask_fn(params):
+        flat_params = traverse_util.flatten_dict(params)
+        layer_norm_candidates = ['layer_norm', 'self_attn_layer_norm', 'final_layer_norm', 'encoder_attn_layer_norm']
+        layer_norm_named_params = {layer[-2:] for layer_norm_name in layer_norm_candidates for layer in flat_params.keys() if layer_norm_name in ''.join(layer).lower()}
+        flat_mask = {path: path[-1] != 'bias' and path[-2:] not in layer_norm_named_params for path in flat_params}
+        return traverse_util.unflatten_dict(flat_mask)
+    adamw = optax.adamw(learning_rate=linear_decay_lr_schedule_fn, b1=training_args.adam_beta1, b2=training_args.adam_beta2, eps=training_args.adam_epsilon, weight_decay=training_args.weight_decay, mask=decay_mask_fn)
+    student_state = TrainState.create(apply_fn=student_model.__call__, params=student_params, tx=adamw, dropout_rng=dropout_rng, max_grad_norm=training_args.max_grad_norm)
+    if training_args.resume_from_checkpoint is not None:
+        if os.path.isfile(os.path.join(training_args.resume_from_checkpoint, 'train_state.msgpack')):
+            logger.info(f'Checkpoint detected, resuming training at {training_args.resume_from_checkpoint}. To avoid this behavior, omit the resume_from_checkpoint argument.')
+            with Path(os.path.join(training_args.resume_from_checkpoint, 'train_state.msgpack')).open('rb') as f:
+                student_state = from_bytes(student_state, f.read())
+        else:
+            logger.warning(f'Checkpoint {training_args.resume_from_checkpoint} not detected, training from scratch. Ensure you pass the path to a folder with a valid checkpoint for your model.')
+    cur_step = int(jax.device_get(student_state.step))
+    if jax.process_index() == 0:
+        student_model.disable_scan()
+        student_state_params = student_model.convert_scan_to_unroll(student_state.params)
+        student_params = jax.device_get(student_state_params)
+        student_model.save_pretrained(os.path.join(training_args.output_dir, f'checkpoint-{cur_step}'), params=student_params)
+        if training_args.push_to_hub:
+            repo.push_to_hub(commit_message=f'Saving weights of step {cur_step}', blocking=False)
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/create_student_model.py
+""""""
+import argparse
+import copy
+import logging
+import jax
+import numpy as np
+from flax.core import freeze, unfreeze
+from transformers import GenerationConfig, WhisperFeatureExtractor, WhisperProcessor
+from distil_whisper import FlaxWhisperForConditionalGeneration
+logger = logging.getLogger(__name__)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Initialise a student Whisper model from a teacher model, copying the relevant layer weights and adjusting the processor as necessary.')
+    parser.add_argument('--teacher_checkpoint', type=str, required=True, help='The HF Hub ID of the teacher checkpoint.')
+    parser.add_argument('--subfolder', type=str, default='', help='In case the relevant teacher weights are located inside a subfolder of the model repo on huggingface.co, you can specify the folder name here.')
+    parser.add_argument('--encoder_layers', type=int, default=None, help='Number of encoder layers to use in the student model. Defaults to all layers from the teacher.')
+    parser.add_argument('--decoder_layers', type=int, default=2, help='Number of decoder layers to use in the student model. Defaults to 2 layers.')
+    parser.add_argument('--max_source_positions', type=int, default=None, help='The maximum sequence length of log-mel filter-bank features that this model might ever be used with. Can be used to create a student model with a shorter context length than the teacher model. Defaults to the number of source positions in the teacher model (1500).')
+    parser.add_argument('--save_dir', type=str, required=True, help='Where to save the student weights and processor.')
+    parser.add_argument('--push_to_hub', type=bool, required=False, default=False, help='Whether to push the student weights and processor to the Hub.')
+    parser.add_argument('--cache_dir', type=str, default=None, help='Where to store the pretrained models downloaded from huggingface.co')
+    args = parser.parse_args()
+    return args
+
+def init_student_model_from_teacher(teacher_checkpoint, encoder_layers=None, decoder_layers=2, max_source_positions=None, save_dir=None, push_to_hub=None, cache_dir=None, subfolder=''):
+    (teacher_model, teacher_params) = FlaxWhisperForConditionalGeneration.from_pretrained(teacher_checkpoint, _do_init=False, cache_dir=cache_dir, subfolder=subfolder)
+    processor = WhisperProcessor.from_pretrained(teacher_checkpoint)
+    generation_config = GenerationConfig.from_pretrained(teacher_checkpoint)
+    teacher_config = teacher_model.config
+    teacher_encoder_layers = teacher_config.encoder_layers
+    teacher_decoder_layers = teacher_config.decoder_layers
+    student_config = copy.deepcopy(teacher_config)
+    student_config.update({'encoder_layers': encoder_layers if encoder_layers is not None else teacher_encoder_layers, 'decoder_layers': decoder_layers, 'max_source_positions': max_source_positions if max_source_positions is not None else student_config.max_source_positions})
+    encoder_mapping = np.linspace(0, teacher_encoder_layers - 1, student_config.encoder_layers, dtype=int)
+    encoder_mapping[-1] = teacher_encoder_layers - 1
+    encoder_map = {}
+    for (student_layer, teacher_layer) in enumerate(encoder_mapping):
+        encoder_map[str(teacher_layer)] = str(student_layer)
+    decoder_mapping = np.linspace(0, teacher_decoder_layers - 1, student_config.decoder_layers, dtype=int)
+    decoder_mapping[-1] = teacher_decoder_layers - 1
+    decoder_map = {}
+    for (student_layer, teacher_layer) in enumerate(decoder_mapping):
+        decoder_map[str(teacher_layer)] = str(student_layer)
+    student_params = unfreeze(teacher_params)
+    student_params['model']['decoder']['layers'] = {}
+    for layer in teacher_params['model']['decoder']['layers']:
+        if layer in decoder_map:
+            student_params['model']['decoder']['layers'][decoder_map[layer]] = teacher_params['model']['decoder']['layers'][layer]
+    if encoder_layers is not None:
+        student_params['model']['encoder']['layers'] = {}
+        for layer in teacher_params['model']['encoder']['layers']:
+            if layer in encoder_map:
+                student_params['model']['encoder']['layers'][encoder_map[layer]] = teacher_params['model']['encoder']['layers'][layer]
+    if max_source_positions is not None:
+        student_params['model']['encoder']['embed_positions']['embedding'] = teacher_params['model']['encoder']['embed_positions']['embedding'][:student_config.max_source_positions, :]
+        chunk_length = int(student_config.max_source_positions * 2 / 100)
+        processor.feature_extractor = WhisperFeatureExtractor(chunk_length=chunk_length)
+    del teacher_params, teacher_model
+    student_params = freeze(student_params)
+    student_model = FlaxWhisperForConditionalGeneration(student_config, _do_init=False)
+    if save_dir is not None:
+        student_model.save_pretrained(save_dir, params=student_params)
+        processor.save_pretrained(save_dir)
+        generation_config.save_pretrained(save_dir)
+    logger.info('Checking we can load the saved model...')
+    (student_model, student_params) = FlaxWhisperForConditionalGeneration.from_pretrained(save_dir, _do_init=False)
+    processor = WhisperProcessor.from_pretrained(save_dir)
+    input_features = processor(np.ones(16000), sampling_rate=16000, return_tensors='np').input_features
+    decoder_start_token_id = student_model.config.decoder_start_token_id
+    decoder_input_ids = np.ones((input_features.shape[0], 1)) * decoder_start_token_id
+    logger.info('Checking we can run the converted model forward...')
+    _ = student_model(input_features, decoder_input_ids=decoder_input_ids, params=student_params).logits
+    logger.info('Conversion successful!')
+    if push_to_hub:
+        student_model.push_to_hub(save_dir, params=student_params)
+        processor.push_to_hub(save_dir)
+        generation_config.push_to_hub(save_dir)
+if __name__ == '__main__':
+    args = parse_args()
+    logger.setLevel(logging.INFO if jax.process_index() == 0 else logging.ERROR)
+    init_student_model_from_teacher(teacher_checkpoint=args.teacher_checkpoint, encoder_layers=args.encoder_layers, decoder_layers=args.decoder_layers, max_source_positions=args.max_source_positions, save_dir=args.save_dir, push_to_hub=args.push_to_hub, cache_dir=args.cache_dir, subfolder=args.subfolder)
+
+# File: distil-whisper-main/training/flax/distil_whisper/layers.py
+""""""
+import dataclasses
+import functools
+import operator
+from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union
+import jax
+import jax.numpy as jnp
+import numpy as np
+from flax import linen as nn
+from flax.linen import partitioning as nn_partitioning
+from flax.linen.dtypes import promote_dtype
+from jax import lax, random
+param_with_axes = nn_partitioning.param_with_axes
+with_sharding_constraint = nn_partitioning.with_sharding_constraint
+Array = jnp.ndarray
+DType = jnp.dtype
+PRNGKey = jnp.ndarray
+Shape = Iterable[int]
+Activation = Callable[..., Array]
+PrecisionLike = Union[None, str, lax.Precision, Tuple[str, str], Tuple[lax.Precision, lax.Precision]]
+DotGeneralT = Callable[..., Array]
+ConvGeneralDilatedT = Callable[..., Array]
+PaddingLike = Union[str, int, Sequence[Union[int, Tuple[int, int]]]]
+LaxPadding = Union[str, Sequence[Tuple[int, int]]]
+Initializer = Callable[[PRNGKey, Shape, DType], Array]
+InitializerAxis = Union[int, Tuple[int, ...]]
+NdInitializer = Callable[[PRNGKey, Shape, DType, InitializerAxis, InitializerAxis], Array]
+default_embed_init = nn.initializers.variance_scaling(1.0, 'fan_in', 'normal', out_axis=0)
+
+def _compute_fans(shape: jax.core.NamedShape, in_axis=-2, out_axis=-1):
+    if isinstance(in_axis, int):
+        in_size = shape[in_axis]
+    else:
+        in_size = int(np.prod([shape[i] for i in in_axis]))
+    if isinstance(out_axis, int):
+        out_size = shape[out_axis]
+    else:
+        out_size = int(np.prod([shape[i] for i in out_axis]))
+    receptive_field_size = shape.total / in_size / out_size
+    fan_in = in_size * receptive_field_size
+    fan_out = out_size * receptive_field_size
+    return (fan_in, fan_out)
+
+def variance_scaling(scale, mode, distribution, in_axis=-2, out_axis=-1, dtype=jnp.float_):
+
+    def init(key, shape, dtype=dtype):
+        return jnp.zeros(shape, dtype=dtype)
+        dtype = jax.dtypes.canonicalize_dtype(dtype)
+        shape = jax.core.as_named_shape(shape)
+        (fan_in, fan_out) = _compute_fans(shape, in_axis, out_axis)
+        if mode == 'fan_in':
+            denominator = fan_in
+        elif mode == 'fan_out':
+            denominator = fan_out
+        elif mode == 'fan_avg':
+            denominator = (fan_in + fan_out) / 2
+        else:
+            raise ValueError('invalid mode for variance scaling initializer: {}'.format(mode))
+        variance = jnp.array(scale / denominator, dtype=dtype)
+        if distribution == 'truncated_normal':
+            stddev = jnp.sqrt(variance) / jnp.array(0.8796256610342398, dtype)
+            return random.truncated_normal(key, -2, 2, shape, dtype) * stddev
+        elif distribution == 'normal':
+            return random.normal(key, shape, dtype) * jnp.sqrt(variance)
+        elif distribution == 'uniform':
+            return random.uniform(key, shape, dtype, -1) * jnp.sqrt(3 * variance)
+        else:
+            raise ValueError('invalid distribution for variance scaling initializer: {}'.format(distribution))
+    return init
+
+def nd_dense_init(scale, mode, distribution):
+
+    def init_fn(key, shape, dtype, in_axis, out_axis):
+        fn = variance_scaling(scale, mode, distribution, in_axis, out_axis)
+        return fn(key, shape, dtype)
+    return init_fn
+
+def dot_product_attention(query: Array, key: Array, value: Array, bias: Optional[Array]=None, dropout_rng: Optional[PRNGKey]=None, dropout_rate: float=0.0, deterministic: bool=False, dtype: DType=jnp.float32, float32_logits: bool=False):
+    assert key.ndim == query.ndim == value.ndim, 'q, k, v must have same rank.'
+    assert query.shape[:-3] == key.shape[:-3] == value.shape[:-3], 'q, k, v batch dims must match.'
+    assert query.shape[-2] == key.shape[-2] == value.shape[-2], 'q, k, v num_heads must match.'
+    assert key.shape[-3] == value.shape[-3], 'k, v lengths must match.'
+    assert query.shape[-1] == key.shape[-1], 'q, k depths must match.'
+    if float32_logits:
+        query = query.astype(jnp.float32)
+        key = key.astype(jnp.float32)
+    attn_weights = jnp.einsum('bqhd,bkhd->bhqk', query, key)
+    if bias is not None:
+        attn_weights = attn_weights + bias.astype(attn_weights.dtype)
+    attn_weights = jax.nn.softmax(attn_weights).astype(dtype)
+    if not deterministic and dropout_rate > 0.0:
+        keep_prob = 1.0 - dropout_rate
+        dropout_shape = list(attn_weights.shape)
+        dropout_shape[-2] = 1
+        keep = random.bernoulli(dropout_rng, keep_prob, dropout_shape)
+        keep = jnp.broadcast_to(keep, attn_weights.shape)
+        multiplier = keep.astype(attn_weights.dtype) / jnp.asarray(keep_prob, dtype=dtype)
+        attn_weights = attn_weights * multiplier
+    return jnp.einsum('bhqk,bkhd->bqhd', attn_weights, value)
+dynamic_vector_slice_in_dim = jax.vmap(lax.dynamic_slice_in_dim, in_axes=(None, 0, None, None))
+
+class MultiHeadDotProductAttention(nn.Module):
+    num_heads: int
+    head_dim: int
+    dtype: DType = jnp.float32
+    dropout_rate: float = 0.0
+    kernel_init: NdInitializer = nd_dense_init(1.0, 'fan_in', 'normal')
+    float32_logits: bool = False
+
+    @nn.compact
+    def __call__(self, inputs_q: Array, inputs_kv: Array, mask: Optional[Array]=None, bias: Optional[Array]=None, *, decode: bool=False, deterministic: bool=False) -> Array:
+        projection = functools.partial(DenseGeneral, axis=-1, features=(self.num_heads, self.head_dim), kernel_axes=('embed', 'heads', 'kv'), dtype=self.dtype)
+        depth_scaling = jnp.sqrt(self.head_dim).astype(self.dtype)
+
+        def query_init(*args):
+            return self.kernel_init(*args) / depth_scaling
+        query = projection(kernel_init=query_init, name='query')(inputs_q)
+        key = projection(kernel_init=self.kernel_init, name='key')(inputs_kv)
+        value = projection(kernel_init=self.kernel_init, name='value')(inputs_kv)
+        query = with_sharding_constraint(query, ('batch', 'length', 'heads', 'kv'))
+        key = with_sharding_constraint(key, ('batch', 'length', 'heads', 'kv'))
+        value = with_sharding_constraint(value, ('batch', 'length', 'heads', 'kv'))
+        if decode:
+            is_initialized = self.has_variable('cache', 'cached_key')
+
+            def swap_dims(x):
+                return x[:-3] + tuple((x[i] for i in [-2, -1, -3]))
+            cached_key = self.variable('cache', 'cached_key', jnp.zeros, swap_dims(key.shape), key.dtype)
+            cached_value = self.variable('cache', 'cached_value', jnp.zeros, swap_dims(value.shape), value.dtype)
+            cache_index = self.variable('cache', 'cache_index', lambda : jnp.array(0, dtype=jnp.int32))
+            if is_initialized:
+                (batch, num_heads, head_dim, length) = cached_key.value.shape
+                expected_shape = (batch, 1, num_heads, head_dim)
+                if expected_shape != query.shape:
+                    raise ValueError('Autoregressive cache shape error, expected query shape %s instead got %s.' % (expected_shape, query.shape))
+                cur_index = cache_index.value
+                one_hot_indices = jax.nn.one_hot(cur_index, length, dtype=key.dtype)
+                one_token_key = jnp.moveaxis(key, -3, -1)
+                one_token_value = jnp.moveaxis(value, -3, -1)
+                key = cached_key.value + one_token_key * one_hot_indices
+                value = cached_value.value + one_token_value * one_hot_indices
+                cached_key.value = key
+                cached_value.value = value
+                cache_index.value = cache_index.value + 1
+                key = jnp.moveaxis(key, -1, -3)
+                value = jnp.moveaxis(value, -1, -3)
+                mask = combine_masks(mask, jnp.broadcast_to(jnp.arange(length) <= cur_index, (batch, 1, 1, length)))
+                if bias is not None:
+                    bias = dynamic_vector_slice_in_dim(jnp.squeeze(bias, axis=0), jnp.reshape(cur_index, -1), 1, -2)
+        if mask is not None:
+            attention_bias = lax.select(mask > 0, jnp.full(mask.shape, 0.0).astype(self.dtype), jnp.full(mask.shape, -10000000000.0).astype(self.dtype))
+        else:
+            attention_bias = None
+        if bias is not None:
+            attention_bias = combine_biases(attention_bias, bias)
+        dropout_rng = None
+        if not deterministic and self.dropout_rate > 0.0:
+            dropout_rng = self.make_rng('dropout')
+        x = dot_product_attention(query, key, value, bias=attention_bias, dropout_rng=dropout_rng, dropout_rate=self.dropout_rate, deterministic=deterministic, dtype=self.dtype, float32_logits=self.float32_logits)
+        out = DenseGeneral(features=inputs_q.shape[-1], axis=(-2, -1), kernel_init=self.kernel_init, kernel_axes=('heads', 'kv', 'embed'), dtype=self.dtype, name='out')(x)
+        return out
+
+def _normalize_axes(axes: Iterable[int], ndim: int) -> Tuple[int]:
+    return tuple([ax if ax >= 0 else ndim + ax for ax in axes])
+
+def _canonicalize_tuple(x):
+    if isinstance(x, Iterable):
+        return tuple(x)
+    else:
+        return (x,)
+
+class DenseGeneral(nn.Module):
+    features: Union[Iterable[int], int]
+    axis: Union[Iterable[int], int] = -1
+    dtype: DType = jnp.float32
+    params_dtype: DType = jnp.float32
+    kernel_init: NdInitializer = nd_dense_init(1.0, 'fan_in', 'normal')
+    kernel_axes: Tuple[str, ...] = ()
+    use_bias: bool = True
+    bias_init: Any = nn.initializers.zeros
+
+    @nn.compact
+    def __call__(self, inputs: Array) -> Array:
+        features = _canonicalize_tuple(self.features)
+        axis = _canonicalize_tuple(self.axis)
+        inputs = jnp.asarray(inputs, self.dtype)
+        axis = _normalize_axes(axis, inputs.ndim)
+        kernel_shape = tuple([inputs.shape[ax] for ax in axis]) + features
+        kernel_in_axis = np.arange(len(axis))
+        kernel_out_axis = np.arange(len(axis), len(axis) + len(features))
+        kernel = param_with_axes('kernel', self.kernel_init, kernel_shape, self.params_dtype, kernel_in_axis, kernel_out_axis, axes=self.kernel_axes)
+        if self.use_bias:
+            bias = param_with_axes('bias', self.bias_init, features, self.params_dtype, axes=(self.kernel_axes[-1],))
+        kernel = jnp.asarray(kernel, self.dtype)
+        contract_ind = tuple(range(0, len(axis)))
+        y = lax.dot_general(inputs, kernel, ((axis, contract_ind), ((), ())))
+        if self.use_bias:
+            bias = jnp.asarray(bias, self.dtype)
+            y += jnp.reshape(bias, (1,) * (len(features) - y.ndim) + bias.shape[:])
+        return y
+
+def _convert_to_activation_function(fn_or_string: Union[str, Callable]) -> Callable:
+    if fn_or_string == 'linear':
+        return lambda x: x
+    elif isinstance(fn_or_string, str):
+        return getattr(nn, fn_or_string)
+    elif callable(fn_or_string):
+        return fn_or_string
+    else:
+        raise ValueError("don't know how to convert %s to an activation function" % (fn_or_string,))
+
+class MlpBlock(nn.Module):
+    intermediate_dim: int = 2048
+    activations: Sequence[Union[str, Callable]] = ('relu',)
+    kernel_init: NdInitializer = nd_dense_init(1.0, 'fan_in', 'truncated_normal')
+    intermediate_dropout_rate: float = 0.1
+    dtype: Any = jnp.float32
+
+    @nn.compact
+    def __call__(self, inputs, decode: bool=False, deterministic: bool=False):
+        activations = []
+        for (idx, act_fn) in enumerate(self.activations):
+            dense_name = 'wi' if len(self.activations) == 1 else f'wi_{idx}'
+            x = DenseGeneral(self.intermediate_dim, dtype=self.dtype, kernel_init=self.kernel_init, kernel_axes=('embed', 'mlp'), name=dense_name)(inputs)
+            x = _convert_to_activation_function(act_fn)(x)
+            activations.append(x)
+        x = functools.reduce(operator.mul, activations)
+        x = nn.Dropout(rate=self.intermediate_dropout_rate, broadcast_dims=(-2,))(x, deterministic=deterministic)
+        x = with_sharding_constraint(x, ('batch', 'length', 'mlp'))
+        output = DenseGeneral(inputs.shape[-1], dtype=self.dtype, kernel_init=self.kernel_init, kernel_axes=('mlp', 'embed'), name='wo')(x)
+        return output
+
+class Embed(nn.Module):
+    num_embeddings: int
+    features: int
+    cast_input_dtype: Optional[DType] = None
+    dtype: DType = jnp.float32
+    params_dtype: DType = jnp.float32
+    attend_dtype: Optional[DType] = None
+    embedding_init: Initializer = default_embed_init
+    one_hot: bool = True
+    embedding: Array = dataclasses.field(init=False)
+
+    def setup(self):
+        self.embedding = param_with_axes('embedding', self.embedding_init, (self.num_embeddings, self.features), self.params_dtype, axes=('vocab', 'embed'))
+
+    def __call__(self, inputs: Array) -> Array:
+        if self.cast_input_dtype:
+            inputs = inputs.astype(self.cast_input_dtype)
+        if not jnp.issubdtype(inputs.dtype, jnp.integer):
+            raise ValueError('Input type must be an integer or unsigned integer.')
+        if self.one_hot:
+            iota = lax.iota(jnp.int32, self.num_embeddings)
+            one_hot = jnp.array(inputs[..., jnp.newaxis] == iota, dtype=self.dtype)
+            output = jnp.dot(one_hot, jnp.asarray(self.embedding, self.dtype))
+        else:
+            output = jnp.asarray(self.embedding, self.dtype)[inputs]
+            output = with_sharding_constraint(output, ('batch', 'length', 'embed'))
+        return output
+
+    def attend(self, query: Array) -> Array:
+        dtype = self.attend_dtype if self.attend_dtype is not None else self.dtype
+        return jnp.dot(query, jnp.asarray(self.embedding, dtype).T)
+
+class RelativePositionBiases(nn.Module):
+    num_buckets: int
+    max_distance: int
+    num_heads: int
+    dtype: Any
+    embedding_init: Callable[..., Array] = nn.linear.default_embed_init
+
+    @staticmethod
+    def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
+        ret = 0
+        n = -relative_position
+        if bidirectional:
+            num_buckets //= 2
+            ret += (n < 0).astype(np.int32) * num_buckets
+            n = np.abs(n)
+        else:
+            n = np.maximum(n, 0)
+        max_exact = num_buckets // 2
+        is_small = n < max_exact
+        val_if_large = max_exact + (np.log(n.astype(np.float32) / max_exact + np.finfo(np.float32).eps) / np.log(max_distance / max_exact) * (num_buckets - max_exact)).astype(np.int32)
+        val_if_large = np.minimum(val_if_large, num_buckets - 1)
+        ret += np.where(is_small, n, val_if_large)
+        return ret
+
+    @nn.compact
+    def __call__(self, qlen, klen, bidirectional=True):
+        context_position = np.arange(qlen, dtype=jnp.int32)[:, None]
+        memory_position = np.arange(klen, dtype=jnp.int32)[None, :]
+        relative_position = memory_position - context_position
+        rp_bucket = self._relative_position_bucket(relative_position, bidirectional=bidirectional, num_buckets=self.num_buckets, max_distance=self.max_distance)
+        relative_attention_bias = param_with_axes('rel_embedding', self.embedding_init, (self.num_heads, self.num_buckets), jnp.float32, axes=('heads', 'relpos_buckets'))
+        relative_attention_bias = jnp.asarray(relative_attention_bias, self.dtype)
+        bcast_iota = lax.broadcasted_iota(jnp.int32, (self.num_buckets, 1, 1), 0)
+        rp_bucket_one_hot = jnp.array(rp_bucket[jnp.newaxis, ...] == bcast_iota, dtype=self.dtype)
+        values = lax.dot_general(relative_attention_bias, rp_bucket_one_hot, (((1,), (0,)), ((), ())))
+        return values[jnp.newaxis, ...]
+
+class LayerNorm(nn.Module):
+    epsilon: float = 1e-06
+    dtype: Any = jnp.float32
+    params_dtype: DType = jnp.float32
+    use_bias: bool = True
+    use_scale: bool = True
+    bias_init: Callable[[PRNGKey, Shape, Any], Array] = nn.initializers.zeros
+    scale_init: Callable[[PRNGKey, Shape, Any], Array] = nn.initializers.ones
+
+    @nn.compact
+    def __call__(self, x):
+        x = jnp.asarray(x, jnp.float32)
+        features = x.shape[-1]
+        mean = jnp.mean(x, axis=-1, keepdims=True)
+        mean2 = jnp.mean(lax.square(x), axis=-1, keepdims=True)
+        var = mean2 - lax.square(mean)
+        mul = lax.rsqrt(var + self.epsilon)
+        if self.use_scale:
+            scale = param_with_axes('scale', self.scale_init, (features,), self.params_dtype, axes=('embed',))
+            mul = mul * jnp.asarray(scale, self.dtype)
+        y = (x - mean) * mul
+        if self.use_bias:
+            bias = param_with_axes('bias', self.bias_init, (features,), self.params_dtype, axes=('embed',))
+            y = y + jnp.asarray(bias, self.dtype)
+        return jnp.asarray(y, self.dtype)
+
+def make_attention_mask(query_input: Array, key_input: Array, pairwise_fn: Callable=jnp.multiply, extra_batch_dims: int=0, dtype: DType=jnp.float32) -> Array:
+    mask = pairwise_fn(jnp.expand_dims(query_input, axis=-1), jnp.expand_dims(key_input, axis=-2))
+    mask = jnp.expand_dims(mask, axis=-3)
+    mask = jnp.expand_dims(mask, axis=tuple(range(extra_batch_dims)))
+    return mask.astype(dtype)
+
+def make_causal_mask(x: Array, extra_batch_dims: int=0, dtype: DType=jnp.float32) -> Array:
+    idxs = jnp.broadcast_to(jnp.arange(x.shape[-1], dtype=jnp.int32), x.shape)
+    return make_attention_mask(idxs, idxs, jnp.greater_equal, extra_batch_dims=extra_batch_dims, dtype=dtype)
+
+def combine_masks(*masks: Optional[Array], dtype: DType=jnp.float32):
+    masks = [m for m in masks if m is not None]
+    if not masks:
+        return None
+    assert all((x.ndim == masks[0].ndim for x in masks)), f'masks must have same rank: {tuple((x.ndim for x in masks))}'
+    (mask, *other_masks) = masks
+    for other_mask in other_masks:
+        mask = jnp.logical_and(mask, other_mask)
+    return mask.astype(dtype)
+
+def combine_biases(*masks: Optional[Array]):
+    masks = [m for m in masks if m is not None]
+    if not masks:
+        return None
+    assert all((x.ndim == masks[0].ndim for x in masks)), f'masks must have same rank: {tuple((x.ndim for x in masks))}'
+    (mask, *other_masks) = masks
+    for other_mask in other_masks:
+        mask = mask + other_mask
+    return mask
+
+def make_decoder_mask(decoder_target_tokens: Array, dtype: DType, decoder_causal_attention: Optional[Array]=None, decoder_segment_ids: Optional[Array]=None) -> Array:
+    masks = []
+    causal_mask = make_causal_mask(decoder_target_tokens, dtype=dtype)
+    if decoder_causal_attention is not None:
+        inputs_mask = make_attention_mask(decoder_causal_attention, decoder_causal_attention, jnp.logical_and, dtype=dtype)
+        masks.append(jnp.logical_or(causal_mask, inputs_mask).astype(dtype))
+    else:
+        masks.append(causal_mask)
+    masks.append(make_attention_mask(decoder_target_tokens > 0, decoder_target_tokens > 0, dtype=dtype))
+    if decoder_segment_ids is not None:
+        masks.append(make_attention_mask(decoder_segment_ids, decoder_segment_ids, jnp.equal, dtype=dtype))
+    return combine_masks(*masks, dtype=dtype)
+
+def canonicalize_padding(padding: PaddingLike, rank: int) -> LaxPadding:
+    if isinstance(padding, str):
+        return padding
+    if isinstance(padding, int):
+        return [(padding, padding)] * rank
+    if isinstance(padding, Sequence) and len(padding) == rank:
+        new_pad = []
+        for p in padding:
+            if isinstance(p, int):
+                new_pad.append((p, p))
+            elif isinstance(p, tuple) and len(p) == 2:
+                new_pad.append(p)
+            else:
+                break
+        if len(new_pad) == rank:
+            return new_pad
+    raise ValueError(f'Invalid padding format: {padding}, should be str, int, or a sequence of len {rank} where each element is an int or pair of ints.')
+
+def _conv_dimension_numbers(input_shape):
+    ndim = len(input_shape)
+    lhs_spec = (0, ndim - 1) + tuple(range(1, ndim - 1))
+    rhs_spec = (ndim - 1, ndim - 2) + tuple(range(0, ndim - 2))
+    out_spec = lhs_spec
+    return lax.ConvDimensionNumbers(lhs_spec, rhs_spec, out_spec)
+
+class _Conv(nn.Module):
+    features: int
+    kernel_size: Sequence[int]
+    strides: Union[None, int, Sequence[int]] = 1
+    padding: PaddingLike = 'SAME'
+    input_dilation: Union[None, int, Sequence[int]] = 1
+    kernel_dilation: Union[None, int, Sequence[int]] = 1
+    feature_group_count: int = 1
+    use_bias: bool = True
+    mask: Optional[Array] = None
+    dtype: Optional[DType] = None
+    params_dtype: DType = jnp.float32
+    precision: PrecisionLike = None
+    kernel_init: Callable[[PRNGKey, Shape, DType], Array] = nn.initializers.lecun_normal()
+    bias_init: Callable[[PRNGKey, Shape, DType], Array] = nn.initializers.zeros
+    conv_general_dilated: ConvGeneralDilatedT = lax.conv_general_dilated
+    kernel_axes: Tuple[str, ...] = ()
+
+    @property
+    def shared_weights(self) -> bool:
+        ...
+
+    @nn.compact
+    def __call__(self, inputs: Array) -> Array:
+        if isinstance(self.kernel_size, int):
+            raise TypeError(f'Expected Conv kernel_size to be a tuple/list of integers (eg.: [3, 3]) but got {self.kernel_size}.')
+        else:
+            kernel_size = tuple(self.kernel_size)
+
+        def maybe_broadcast(x: Optional[Union[int, Sequence[int]]]) -> Tuple[int, ...]:
+            if x is None:
+                x = 1
+            if isinstance(x, int):
+                return (x,) * len(kernel_size)
+            return tuple(x)
+        num_batch_dimensions = inputs.ndim - (len(kernel_size) + 1)
+        if num_batch_dimensions != 1:
+            input_batch_shape = inputs.shape[:num_batch_dimensions]
+            total_batch_size = int(np.prod(input_batch_shape))
+            flat_input_shape = (total_batch_size,) + inputs.shape[num_batch_dimensions:]
+            inputs = jnp.reshape(inputs, flat_input_shape)
+        strides = maybe_broadcast(self.strides)
+        input_dilation = maybe_broadcast(self.input_dilation)
+        kernel_dilation = maybe_broadcast(self.kernel_dilation)
+        padding_lax = canonicalize_padding(self.padding, len(kernel_size))
+        if padding_lax == 'CIRCULAR':
+            kernel_size_dilated = [(k - 1) * d + 1 for (k, d) in zip(kernel_size, kernel_dilation)]
+            zero_pad: List[Tuple[int, int]] = [(0, 0)]
+            pads = zero_pad + [((k - 1) // 2, k // 2) for k in kernel_size_dilated] + [(0, 0)]
+            inputs = jnp.pad(inputs, pads, mode='wrap')
+            padding_lax = 'VALID'
+        elif padding_lax == 'CAUSAL':
+            if len(kernel_size) != 1:
+                raise ValueError('Causal padding is only implemented for 1D convolutions.')
+            left_pad = kernel_dilation[0] * (kernel_size[0] - 1)
+            pads = [(0, 0), (left_pad, 0), (0, 0)]
+            inputs = jnp.pad(inputs, pads)
+            padding_lax = 'VALID'
+        dimension_numbers = _conv_dimension_numbers(inputs.shape)
+        in_features = jnp.shape(inputs)[-1]
+        if self.shared_weights:
+            assert in_features % self.feature_group_count == 0
+            kernel_shape = kernel_size + (in_features // self.feature_group_count, self.features)
+        else:
+            if self.feature_group_count != 1:
+                raise NotImplementedError(f'`lax.conv_general_dilated_local` does not support `feature_group_count != 1`, got `{self.feature_group_count}`.')
+            conv_output_shape = jax.eval_shape(lambda lhs, rhs: self.conv_general_dilated(lhs=lhs, rhs=rhs, window_strides=strides, padding=padding_lax, dimension_numbers=dimension_numbers, lhs_dilation=input_dilation, rhs_dilation=kernel_dilation), inputs, jax.ShapedArray(kernel_size + (in_features, self.features), inputs.dtype)).shape
+            kernel_shape = conv_output_shape[1:-1] + (np.prod(kernel_size) * in_features, self.features)
+        if self.mask is not None and self.mask.shape != kernel_shape:
+            raise ValueError(f'Mask needs to have the same shape as weights. Shapes are: {self.mask.shape}, {kernel_shape}')
+        kernel = param_with_axes('kernel', self.kernel_init, kernel_shape, self.params_dtype, axes=self.kernel_axes)
+        if self.mask is not None:
+            kernel *= self.mask
+        if self.use_bias:
+            if self.shared_weights:
+                bias_shape = (self.features,)
+            else:
+                bias_shape = conv_output_shape[1:]
+            bias = param_with_axes('bias', self.bias_init, bias_shape, self.params_dtype, axes=(self.kernel_axes[-1],))
+        else:
+            bias = None
+        (inputs, kernel, bias) = promote_dtype(inputs, kernel, bias, dtype=self.dtype)
+        if self.shared_weights:
+            y = self.conv_general_dilated(inputs, kernel, strides, padding_lax, lhs_dilation=input_dilation, rhs_dilation=kernel_dilation, dimension_numbers=dimension_numbers, feature_group_count=self.feature_group_count, precision=self.precision)
+        else:
+            y = lax.conv_general_dilated_local(lhs=inputs, rhs=kernel, window_strides=strides, padding=padding_lax, filter_shape=kernel_size, lhs_dilation=input_dilation, rhs_dilation=kernel_dilation, dimension_numbers=dimension_numbers, precision=self.precision)
+        if self.use_bias:
+            bias = bias.reshape((1,) * (y.ndim - bias.ndim) + bias.shape)
+            y += bias
+        if num_batch_dimensions != 1:
+            output_shape = input_batch_shape + y.shape[1:]
+            y = jnp.reshape(y, output_shape)
+        return y
+
+class Conv(_Conv):
+
+    @property
+    def shared_weights(self) -> bool:
+        return True
+
+# File: distil-whisper-main/training/flax/distil_whisper/modeling_flax_whisper.py
+""""""
+import random
+from functools import partial
+from typing import Dict, Optional, Tuple, Union
+import flax.linen as nn
+import jax
+import jax.numpy as jnp
+from flax.core.frozen_dict import FrozenDict, freeze, unfreeze
+from flax.linen import combine_masks, make_causal_mask
+from flax.linen.attention import dot_product_attention_weights
+from flax.linen.partitioning import remat, scan_with_axes
+from flax.traverse_util import flatten_dict, unflatten_dict
+from jax import lax
+from jax.random import PRNGKey
+from transformers import WhisperConfig
+from transformers.generation.flax_logits_process import FlaxLogitsProcessor, FlaxLogitsProcessorList, FlaxWhisperTimeStampLogitsProcessor
+from transformers.modeling_flax_outputs import FlaxBaseModelOutput, FlaxBaseModelOutputWithPastAndCrossAttentions, FlaxCausalLMOutputWithCrossAttentions, FlaxSeq2SeqLMOutput, FlaxSeq2SeqModelOutput
+from transformers.modeling_flax_utils import ACT2FN, FlaxPreTrainedModel, append_call_sample_docstring, append_replace_return_docstrings, overwrite_call_docstring
+from transformers.utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings
+from .layers import Conv, DenseGeneral, Embed, LayerNorm, with_sharding_constraint
+logger = logging.get_logger(__name__)
+_CHECKPOINT_FOR_DOC = 'openai/whisper-tiny'
+_CONFIG_FOR_DOC = 'WhisperConfig'
+WHISPER_START_DOCSTRING = '\n    This model inherits from [`FlaxPreTrainedModel`]. Check the superclass documentation for the generic methods the\n    library implements for all its models (such as downloading or saving, resizing the input embeddings, pruning heads\n    etc.) This model is also a Flax Linen\n    [flax.nn.Module](https://flax.readthedocs.io/en/latest/_autosummary/flax.nn.module.html) subclass. Use it as a\n    regular Flax Module and refer to the Flax documentation for all matter related to general usage and behavior.\n    Finally, this model supports inherent JAX features such as:\n    - [Just-In-Time (JIT) compilation](https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit)\n    - [Automatic Differentiation](https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation)\n    - [Vectorization](https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap)\n    - [Parallelization](https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap)\n\n    Parameters:\n        config ([`WhisperConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~FlaxPreTrainedModel.from_pretrained`] method to load the model weights.\n        dtype (`jax.numpy.dtype`, *optional*, defaults to `jax.numpy.float32`):\n            The data type of the computation. Can be one of `jax.numpy.float32`, `jax.numpy.float16` (on GPUs) and\n            `jax.numpy.bfloat16` (on TPUs). This can be used to enable mixed-precision training or half-precision\n            inference on GPUs or TPUs. If specified all the computation will be performed with the given `dtype`.\n            **Note that this only specifies the dtype of the computation and does not influence the dtype of model\n            parameters.** If you wish to change the dtype of the model parameters, see [`~FlaxPreTrainedModel.to_fp16`]\n            and [`~FlaxPreTrainedModel.to_bf16`].\n'
+WHISPER_INPUTS_DOCSTRING = "\n    Args:\n        input_features (`numpy.ndarray` of shape `(batch_size, feature_size, sequence_length)`):\n            Float values mel features extracted from the raw speech waveform. Raw speech waveform can be obtained by\n            loading a `.flac` or `.wav` audio file into an array of type `List[float]` or a `numpy.ndarray`, *e.g.* via\n            the soundfile library (`pip install soundfile`). To prepare the array into `input_features`, the\n            [`WhisperFeatureExtractor`] should be used for extracting the features, padding and conversion into a\n            tensor of type `numpy.ndarray`. See [`~WhisperFeatureExtractor.__call__`]\n        attention_mask (`numpy.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\n            Whisper does not support masking of the `input_features`, this argument is preserved for compatibility, but\n            is not used. By default the silence in the input log mel spectrogram are ignored.\n        decoder_input_ids (`numpy.ndarray` of shape `(batch_size, target_sequence_length)`, *optional*):\n            Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using\n            [`WhisperTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details.\n            [What are decoder input IDs?](../glossary#decoder-input-ids) Whisper uses the `decoder_start_token_id` as\n            the starting token for `decoder_input_ids` generation.\n        decoder_attention_mask (`numpy.ndarray` of shape `(batch_size, target_sequence_length)`, *optional*):\n            Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also\n            be used by default. If you want to change padding behavior, you should modify to your needs. See diagram 1\n            in [the paper](https://arxiv.org/abs/1910.13461) for more information on the default strategy.\n        position_ids (`numpy.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\n            Whisper does not use `position_ids` in the encoder as `input_features` is always the same size and doesn't\n            use masking, but this argument is preserved for compatibility. By default the silence in the input log mel\n            spectrogram are ignored.\n        decoder_position_ids (`numpy.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\n            Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the\n            range `[0, config.max_position_embeddings - 1]`.\n        output_attentions (`bool`, *optional*):\n            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned\n            tensors for more detail.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"
+WHISPER_ENCODE_INPUTS_DOCSTRING = '\n    Args:\n        input_features (`numpy.ndarray` of shape `(batch_size, feature_size, sequence_length)`):\n            Float values mel features extracted from the raw speech waveform. Raw speech waveform can be obtained by\n            loading a `.flac` or `.wav` audio file into an array of type `List[float]` or a `numpy.ndarray`, *e.g.* via\n            the soundfile library (`pip install soundfile`). To prepare the array into `input_features`, the\n            [`WhisperFeatureExtractor`] should be used for extracting the mel features, padding and conversion into a\n            tensor of type `numpy.ndarray`. See [`~WhisperFeatureExtractor.__call__`].\n        attention_mask (`numpy.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\n            Whisper does not support masking of the `input_features`, this argument is preserved for compatibility, but\n            is not used. By default the silence in the input log mel spectrogram are ignored.\n        output_attentions (`bool`, *optional*):\n            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned\n            tensors for more detail.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'
+WHISPER_DECODE_INPUTS_DOCSTRING = '\n    Args:\n        decoder_input_ids (`numpy.ndarray` of shape `(batch_size, target_sequence_length)`):\n            Indices of decoder input sequence tokens in the vocabulary. Indices can be obtained using\n            [`WhisperTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details.\n            [What are decoder input IDs?](../glossary#decoder-input-ids)\n        encoder_outputs (`tuple(tuple(numpy.ndarray)`):\n            Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`)\n            `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) is a sequence of\n            hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.\n        encoder_attention_mask (`numpy.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\n           Whisper does not support masking of the `input_features`, this argument is preserved for compatibility,\n            but it is not used. By default the silence in the input log mel spectrogram are ignored.\n        decoder_attention_mask (`numpy.ndarray` of shape `(batch_size, target_sequence_length)`, *optional*):\n            Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also\n            be used by default. If you want to change padding behavior, you should modify to your needs. See diagram 1\n            in [the paper](https://arxiv.org/abs/1910.13461) for more information on the default strategy.\n        decoder_position_ids (`numpy.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\n            Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the\n            range `[0, config.max_position_embeddings - 1]`.\n        past_key_values (`Dict[str, numpy.ndarray]`, *optional*, returned by `init_cache` or when passing previous `past_key_values`):\n            Dictionary of pre-computed hidden-states (key and values in the attention blocks) that can be used for fast\n            auto-regressive decoding. Pre-computed key and value hidden-states are of shape *[batch_size, max_length]*.\n        output_attentions (`bool`, *optional*):\n            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned\n            tensors for more detail.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'
+
+class FlaxStaticForceTokensLogitsProcessor(FlaxLogitsProcessor):
+
+    def __init__(self, force_token_map):
+        force_token_map = jnp.array(force_token_map)
+        force_token_array = jnp.ones(3, dtype=jnp.int32) * -1
+        for (index, token) in force_token_map:
+            force_token_array = force_token_array.at[index].set(token)
+        self.force_token_array = jnp.int32(force_token_array)
+
+    def __call__(self, input_ids: jnp.ndarray, scores: jnp.ndarray, cur_len: int) -> jnp.ndarray:
+
+        def _force_token(generation_idx):
+            batch_size = scores.shape[0]
+            current_token = self.force_token_array[generation_idx]
+            new_scores = jnp.ones_like(scores, dtype=scores.dtype) * -float('inf')
+            updates = jnp.zeros((batch_size, 1), dtype=scores.dtype)
+            new_scores = lax.dynamic_update_slice(new_scores, updates, (0, current_token))
+            return new_scores
+        scores = lax.cond(cur_len >= self.force_token_array.shape[0], lambda : scores, lambda : lax.cond(self.force_token_array[cur_len] >= 0, lambda : _force_token(cur_len), lambda : scores))
+        return scores
+
+class FlaxWhisperAttention(nn.Module):
+    config: WhisperConfig
+    embed_dim: int
+    num_heads: int
+    dropout: float = 0.0
+    causal: bool = False
+    bias: bool = True
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+
+    def setup(self) -> None:
+        self.head_dim = self.embed_dim // self.num_heads
+        if self.head_dim * self.num_heads != self.embed_dim:
+            raise ValueError(f'embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`: {self.num_heads}).')
+        dense = partial(DenseGeneral, self.embed_dim, axis=-1, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('embed', 'joined_kv'))
+        self.q_proj = dense(use_bias=self.bias)
+        self.k_proj = dense(use_bias=False)
+        self.v_proj = dense(use_bias=self.bias)
+        self.out_proj = DenseGeneral(self.embed_dim, axis=-1, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('joined_kv', 'embed'), use_bias=self.bias)
+        if self.causal:
+            self.causal_mask = make_causal_mask(jnp.ones((1, self.config.max_target_positions), dtype='bool'), dtype='bool')
+
+    def __call__(self, hidden_states: jnp.ndarray, key_value_states: Optional[jnp.ndarray]=None, attention_mask: Optional[jnp.ndarray]=None, init_cache: bool=False, deterministic: bool=True) -> Tuple[jnp.ndarray]:
+        is_cross_attention = key_value_states is not None
+        batch_size = hidden_states.shape[0]
+        query_states = self.q_proj(hidden_states)
+        if is_cross_attention:
+            key_states = self.k_proj(key_value_states)
+            value_states = self.v_proj(key_value_states)
+        else:
+            key_states = self.k_proj(hidden_states)
+            value_states = self.v_proj(hidden_states)
+        query_states = self._split_heads(query_states)
+        key_states = self._split_heads(key_states)
+        value_states = self._split_heads(value_states)
+        query_states = with_sharding_constraint(query_states, ('batch', 'length', 'heads', 'kv'))
+        key_states = with_sharding_constraint(key_states, ('batch', 'length', 'heads', 'kv'))
+        value_states = with_sharding_constraint(value_states, ('batch', 'length', 'heads', 'kv'))
+        if self.causal:
+            (query_length, key_length) = (query_states.shape[1], key_states.shape[1])
+            if self.has_variable('cache', 'cached_key'):
+                mask_shift = self.variables['cache']['cache_index']
+                max_decoder_length = self.variables['cache']['cached_key'].shape[-1]
+                causal_mask = lax.dynamic_slice(self.causal_mask, (0, 0, mask_shift, 0), (1, 1, query_length, max_decoder_length))
+            else:
+                causal_mask = self.causal_mask[:, :, :query_length, :key_length]
+            causal_mask = jnp.broadcast_to(causal_mask, (batch_size,) + causal_mask.shape[1:])
+        if attention_mask is not None and self.causal:
+            attention_mask = jnp.broadcast_to(jnp.expand_dims(attention_mask, axis=(-3, -2)), causal_mask.shape)
+            attention_mask = combine_masks(attention_mask, causal_mask)
+        elif self.causal:
+            attention_mask = causal_mask
+        elif attention_mask is not None:
+            attention_mask = jnp.expand_dims(attention_mask, axis=(-3, -2))
+        if self.causal and (self.has_variable('cache', 'cached_key') or init_cache):
+            (key_states, value_states, attention_mask) = self._concatenate_to_cache(key_states, value_states, query_states, attention_mask)
+        if attention_mask is not None:
+            attention_bias = lax.select(attention_mask > 0, jnp.full(attention_mask.shape, 0.0).astype(self.dtype), jnp.full(attention_mask.shape, jnp.finfo(self.dtype).min).astype(self.dtype))
+        else:
+            attention_bias = None
+        dropout_rng = None
+        if not deterministic and self.dropout > 0.0:
+            dropout_rng = self.make_rng('dropout')
+        attn_weights = dot_product_attention_weights(query_states, key_states, bias=attention_bias, dropout_rng=dropout_rng, dropout_rate=self.dropout, broadcast_dropout=True, deterministic=deterministic, dtype=self.dtype, precision=None)
+        attn_output = jnp.einsum('...hqk,...khd->...qhd', attn_weights, value_states)
+        attn_output = self._merge_heads(attn_output)
+        attn_output = self.out_proj(attn_output)
+        return (attn_output, attn_weights)
+
+    def _split_heads(self, hidden_state) -> jnp.ndarray:
+        return hidden_state.reshape(hidden_state.shape[:2] + (self.num_heads, self.head_dim))
+
+    def _merge_heads(self, hidden_state) -> jnp.ndarray:
+        return hidden_state.reshape(hidden_state.shape[:2] + (self.embed_dim,))
+
+    @nn.compact
+    def _concatenate_to_cache(self, key, value, query, attention_mask):
+        is_initialized = self.has_variable('cache', 'cached_key')
+
+        def swap_dims(x):
+            return x[:-3] + tuple((x[i] for i in [-2, -1, -3]))
+        cached_key = self.variable('cache', 'cached_key', jnp.zeros, swap_dims(key.shape), key.dtype)
+        cached_value = self.variable('cache', 'cached_value', jnp.zeros, swap_dims(value.shape), value.dtype)
+        cache_index = self.variable('cache', 'cache_index', lambda : jnp.array(0, dtype=jnp.int32))
+        if is_initialized:
+            (batch_size, num_heads, head_dim, seq_length) = cached_key.value.shape
+            num_updated_cache_vectors = query.shape[1]
+            expected_shape = (batch_size, 1, num_heads, head_dim)
+            if num_updated_cache_vectors == 1 and expected_shape != query.shape:
+                raise ValueError(f'Autoregressive cache shape error, expected query shape {expected_shape} instead got {query.shape}')
+            cur_index = cache_index.value
+            one_token_key = jnp.moveaxis(key, -3, -1)
+            one_token_value = jnp.moveaxis(value, -3, -1)
+            if num_updated_cache_vectors > 1:
+                indices = jnp.eye(num_updated_cache_vectors, seq_length)[None, None]
+                key = cached_key.value + jnp.matmul(one_token_key, indices)
+                value = cached_value.value + jnp.matmul(one_token_value, indices)
+            else:
+                one_hot_indices = jax.nn.one_hot(cur_index, seq_length, dtype=key.dtype)
+                key = cached_key.value + one_token_key * one_hot_indices
+                value = cached_value.value + one_token_value * one_hot_indices
+            cached_key.value = key
+            cached_value.value = value
+            cache_index.value = cache_index.value + num_updated_cache_vectors
+            key = jnp.moveaxis(key, -1, -3)
+            value = jnp.moveaxis(value, -1, -3)
+            pad_mask = jnp.broadcast_to(jnp.arange(seq_length) < cur_index + num_updated_cache_vectors, (batch_size,) + (1, num_updated_cache_vectors, seq_length))
+            attention_mask = combine_masks(pad_mask, attention_mask)
+        return (key, value, attention_mask)
+
+class FlaxWhisperEncoderLayer(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+
+    def setup(self) -> None:
+        self.embed_dim = self.config.d_model
+        self.self_attn = FlaxWhisperAttention(config=self.config, embed_dim=self.embed_dim, num_heads=self.config.encoder_attention_heads, dropout=self.config.attention_dropout, dtype=self.dtype, params_dtype=self.params_dtype)
+        self.self_attn_layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+        self.dropout_layer = nn.Dropout(rate=self.config.dropout)
+        self.activation_fn = ACT2FN[self.config.activation_function]
+        self.activation_dropout_layer = nn.Dropout(rate=self.config.activation_dropout)
+        self.fc1 = DenseGeneral(self.config.encoder_ffn_dim, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('embed', 'mlp'))
+        self.fc2 = DenseGeneral(self.embed_dim, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('mlp', 'embed'))
+        self.final_layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+
+    def __call__(self, hidden_states: jnp.ndarray, attention_mask: jnp.ndarray, output_attentions: bool=True, deterministic: bool=True, all_hidden_states=None) -> Tuple[jnp.ndarray]:
+        if self.use_scan:
+            hidden_states = hidden_states[0]
+        hidden_states = with_sharding_constraint(hidden_states, ('batch', 'length', 'embed'))
+        residual = hidden_states
+        layernorm_output = self.self_attn_layer_norm(hidden_states)
+        layernorm_output = with_sharding_constraint(layernorm_output, ('batch', 'length', 'embed'))
+        (attn_output, attn_weights) = self.self_attn(hidden_states=layernorm_output, attention_mask=attention_mask)
+        attn_output = self.dropout_layer(attn_output, deterministic=deterministic)
+        attn_output = residual + attn_output
+        attn_output = with_sharding_constraint(attn_output, ('batch', 'length', 'embed'))
+        residual = attn_output
+        post_layer_norm = self.final_layer_norm(attn_output)
+        post_layer_norm = with_sharding_constraint(post_layer_norm, ('batch', 'length', 'embed'))
+        fc1_output = self.activation_fn(self.fc1(post_layer_norm))
+        fc1_output = self.activation_dropout_layer(fc1_output, deterministic=deterministic)
+        fc1_output = with_sharding_constraint(fc1_output, ('batch', 'length', 'mlp'))
+        hidden_states = self.fc2(fc1_output)
+        hidden_states = self.dropout_layer(hidden_states, deterministic=deterministic)
+        hidden_states = residual + hidden_states
+        hidden_states = with_sharding_constraint(hidden_states, ('batch', 'length', 'embed'))
+        outputs = (hidden_states,)
+        if output_attentions:
+            outputs += (attn_weights,)
+        if self.use_scan:
+            if all_hidden_states is not None:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+            outputs = (outputs, all_hidden_states)
+        return outputs
+
+class FlaxWhisperEncoderLayerCollection(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+    gradient_checkpointing: bool = False
+
+    @nn.compact
+    def __call__(self, hidden_states, attention_mask, deterministic: bool=True, output_attentions: bool=False, output_hidden_states: bool=False, return_dict: bool=True):
+        all_attentions = () if output_attentions else None
+        all_hidden_states = () if output_hidden_states else None
+        FlaxWhisperEncoderCheckpointLayer = remat(FlaxWhisperEncoderLayer, static_argnums=(2, 3), prevent_cse=not self.use_scan) if self.gradient_checkpointing else FlaxWhisperEncoderLayer
+        if self.use_scan:
+            if output_attentions:
+                raise ValueError('Cannot use `scan` with `output_attentions` set to True')
+            input_hidden_states = hidden_states
+            hidden_states = (hidden_states,)
+            (hidden_states, all_hidden_states) = scan_with_axes(FlaxWhisperEncoderCheckpointLayer, variable_axes={'params': 0, 'cache': 0}, split_rngs={'params': True, 'dropout': True}, in_axes=(nn.broadcast, nn.broadcast, nn.broadcast, nn.broadcast), variable_carry='all_hidden_states', length=self.config.encoder_layers)(self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=True, name='FlaxEncoderScanLayers')(hidden_states, attention_mask, output_attentions, deterministic, all_hidden_states)
+            hidden_states = hidden_states[0]
+            if output_hidden_states:
+                all_hidden_states = jnp.vstack([input_hidden_states[None, ...], all_hidden_states[0]])
+        else:
+            for layer_idx in range(self.config.encoder_layers):
+                if output_hidden_states:
+                    all_hidden_states = all_hidden_states + (hidden_states,)
+                dropout_probability = random.uniform(0, 1)
+                if not deterministic and dropout_probability < self.config.encoder_layerdrop:
+                    layer_outputs = (None, None)
+                else:
+                    layer_outputs = FlaxWhisperEncoderCheckpointLayer(self.config, dtype=self.dtype, params_dtype=self.params_dtype, name=str(layer_idx))(hidden_states, attention_mask, output_attentions, deterministic)
+                hidden_states = layer_outputs[0]
+                if output_attentions:
+                    all_attentions = all_attentions + (layer_outputs[1],)
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+        outputs = (hidden_states, all_hidden_states, all_attentions)
+        if not return_dict:
+            return tuple((v for v in outputs if v is not None))
+        return FlaxBaseModelOutput(last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_attentions)
+
+class FlaxWhisperDecoderLayer(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+
+    def setup(self) -> None:
+        self.embed_dim = self.config.d_model
+        self.self_attn = FlaxWhisperAttention(config=self.config, embed_dim=self.embed_dim, num_heads=self.config.decoder_attention_heads, dropout=self.config.attention_dropout, causal=True, dtype=self.dtype, params_dtype=self.params_dtype)
+        self.dropout_layer = nn.Dropout(rate=self.config.dropout)
+        self.activation_fn = ACT2FN[self.config.activation_function]
+        self.activation_dropout_layer = nn.Dropout(rate=self.config.activation_dropout)
+        self.self_attn_layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+        self.encoder_attn = FlaxWhisperAttention(config=self.config, embed_dim=self.embed_dim, num_heads=self.config.decoder_attention_heads, dropout=self.config.attention_dropout, dtype=self.dtype, params_dtype=self.params_dtype)
+        self.encoder_attn_layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+        self.fc1 = DenseGeneral(self.config.decoder_ffn_dim, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('embed', 'mlp'))
+        self.fc2 = DenseGeneral(self.embed_dim, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('mlp', 'embed'))
+        self.final_layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+
+    def __call__(self, hidden_states: jnp.ndarray, attention_mask: jnp.ndarray, encoder_hidden_states: Optional[jnp.ndarray]=None, encoder_attention_mask: Optional[jnp.ndarray]=None, init_cache: bool=False, output_attentions: bool=True, deterministic: bool=True, all_hidden_states=None) -> Tuple[jnp.ndarray]:
+        if self.use_scan:
+            hidden_states = hidden_states[0]
+        hidden_states = with_sharding_constraint(hidden_states, ('batch', 'length', 'embed'))
+        residual = hidden_states
+        layer_norm_output = self.self_attn_layer_norm(hidden_states)
+        layer_norm_output = with_sharding_constraint(layer_norm_output, ('batch', 'length', 'embed'))
+        (self_attn_output, self_attn_weights) = self.self_attn(hidden_states=layer_norm_output, attention_mask=attention_mask, init_cache=init_cache)
+        self_attn_output = self.dropout_layer(self_attn_output, deterministic=deterministic)
+        self_attn_output = residual + self_attn_output
+        self_attn_output = with_sharding_constraint(self_attn_output, ('batch', 'length', 'embed'))
+        cross_attn_weights = None
+        if encoder_hidden_states is not None:
+            residual = self_attn_output
+            encoder_layer_norm_output = self.encoder_attn_layer_norm(self_attn_output)
+            encoder_layer_norm_output = with_sharding_constraint(encoder_layer_norm_output, ('batch', 'length', 'embed'))
+            (cross_attn_output, cross_attn_weights) = self.encoder_attn(hidden_states=encoder_layer_norm_output, key_value_states=encoder_hidden_states, attention_mask=encoder_attention_mask)
+            cross_attn_output = self.dropout_layer(cross_attn_output, deterministic=deterministic)
+            cross_attn_output = residual + cross_attn_output
+            cross_attn_output = with_sharding_constraint(cross_attn_output, ('batch', 'length', 'embed'))
+        residual = cross_attn_output
+        post_layer_norm = self.final_layer_norm(cross_attn_output)
+        post_layer_norm = with_sharding_constraint(post_layer_norm, ('batch', 'length', 'embed'))
+        fc1_output = self.activation_fn(self.fc1(post_layer_norm))
+        fc1_output = self.activation_dropout_layer(fc1_output, deterministic=deterministic)
+        fc1_output = with_sharding_constraint(fc1_output, ('batch', 'length', 'mlp'))
+        hidden_states = self.fc2(fc1_output)
+        hidden_states = self.dropout_layer(hidden_states, deterministic=deterministic)
+        hidden_states = residual + hidden_states
+        hidden_states = with_sharding_constraint(hidden_states, ('batch', 'length', 'embed'))
+        outputs = (hidden_states,)
+        if output_attentions:
+            outputs += (self_attn_weights, cross_attn_weights)
+        if self.use_scan:
+            if all_hidden_states is not None:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+            outputs = (outputs, all_hidden_states)
+        return outputs
+
+class FlaxWhisperDecoderLayerCollection(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+    gradient_checkpointing: bool = False
+
+    @nn.compact
+    def __call__(self, hidden_states, attention_mask, encoder_hidden_states: Optional[jnp.ndarray]=None, encoder_attention_mask: Optional[jnp.ndarray]=None, deterministic: bool=True, init_cache: bool=False, output_attentions: bool=False, output_hidden_states: bool=False, return_dict: bool=True):
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        all_cross_attentions = () if output_attentions and encoder_hidden_states is not None else None
+        FlaxWhisperDecoderCheckpointLayer = remat(FlaxWhisperDecoderLayer, static_argnums=(4, 5, 6), prevent_cse=not self.use_scan) if self.gradient_checkpointing else FlaxWhisperDecoderLayer
+        if self.use_scan:
+            if output_attentions:
+                raise ValueError('Cannot use `scan` with `output_attentions` set to True')
+            input_hidden_states = hidden_states
+            hidden_states = (hidden_states,)
+            (hidden_states, all_hidden_states) = scan_with_axes(FlaxWhisperDecoderCheckpointLayer, variable_axes={'params': 0, 'cache': 0}, split_rngs={'params': True, 'dropout': True}, in_axes=(nn.broadcast, nn.broadcast, nn.broadcast, nn.broadcast, nn.broadcast, nn.broadcast, nn.broadcast), variable_carry='all_hidden_states', length=self.config.decoder_layers)(self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=True, name='FlaxDecoderScanLayers')(hidden_states, attention_mask, encoder_hidden_states, encoder_attention_mask, init_cache, output_attentions, deterministic, all_hidden_states)
+            hidden_states = hidden_states[0]
+            if output_hidden_states:
+                all_hidden_states = jnp.vstack([input_hidden_states[None, ...], all_hidden_states[0]])
+        else:
+            for layer_idx in range(self.config.decoder_layers):
+                if output_hidden_states:
+                    all_hidden_states += (hidden_states,)
+                dropout_probability = random.uniform(0, 1)
+                if not deterministic and dropout_probability < self.config.decoder_layerdrop:
+                    layer_outputs = (None, None, None)
+                else:
+                    layer_outputs = FlaxWhisperDecoderCheckpointLayer(self.config, dtype=self.dtype, params_dtype=self.params_dtype, name=str(layer_idx))(hidden_states, attention_mask, encoder_hidden_states, encoder_attention_mask, init_cache, output_attentions, deterministic)
+                hidden_states = layer_outputs[0]
+                if output_attentions:
+                    all_self_attns += (layer_outputs[1],)
+                    if encoder_hidden_states is not None:
+                        all_cross_attentions += (layer_outputs[2],)
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+        outputs = [hidden_states, all_hidden_states, all_self_attns, all_cross_attentions]
+        if not return_dict:
+            return tuple((v for v in outputs if v is not None))
+        return FlaxBaseModelOutputWithPastAndCrossAttentions(last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attns, cross_attentions=all_cross_attentions)
+
+class FlaxWhisperEncoder(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+    gradient_checkpointing: bool = False
+
+    def setup(self) -> None:
+        self.conv1 = Conv(self.config.d_model, kernel_size=(3,), padding=1, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('channels', 'num_mel', 'embed'))
+        self.conv2 = Conv(self.config.d_model, kernel_size=(3,), strides=2, padding=1, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('channels', 'embed', 'num_mel'))
+        self.dropout_layer = nn.Dropout(rate=self.config.dropout)
+        self.layers = FlaxWhisperEncoderLayerCollection(self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+        self.embed_positions = Embed(self.config.max_source_positions, self.config.d_model, dtype=self.dtype, params_dtype=self.params_dtype)
+        self.layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+
+    def __call__(self, input_features: jnp.ndarray, output_attentions: bool=False, output_hidden_states: bool=False, return_dict: bool=True, deterministic: bool=True) -> Tuple[jnp.ndarray]:
+        if input_features.shape[1:] != (self.config.num_mel_bins, self.config.max_source_positions * 2):
+            raise ValueError(f'input_features.shape[1:], must be equal to (self.config.num_mel_bins, self.config.max_source_positions * 2) (got {input_features.shape[1:]}, but should be ({self.config.num_mel_bins}, {self.config.max_source_positions * 2}))')
+        input_features = input_features.transpose(0, 2, 1)
+        hidden_states = jax.nn.gelu(self.conv1(input_features), approximate=False)
+        hidden_states = with_sharding_constraint(hidden_states, ('batch', 'embed', 'num_mel'))
+        hidden_states = jax.nn.gelu(self.conv2(hidden_states), approximate=False)
+        hidden_states = with_sharding_constraint(hidden_states, ('batch', 'length', 'embed'))
+        embed_positions = self.embed_positions(jnp.arange(self.config.max_source_positions))
+        embed_positions = jax.lax.stop_gradient(embed_positions)
+        hidden_states = hidden_states + embed_positions
+        hidden_states = self.dropout_layer(hidden_states, deterministic=deterministic)
+        outputs = self.layers(hidden_states, attention_mask=None, deterministic=deterministic, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
+        last_hidden_states = outputs[0]
+        last_hidden_states = self.layer_norm(last_hidden_states)
+        hidden_states = None
+        if output_hidden_states:
+            hidden_states = outputs[1]
+            if self.use_scan:
+                hidden_states = jnp.vstack([hidden_states[:-1], last_hidden_states[None, ...]])
+            else:
+                hidden_states = hidden_states[:-1] + (last_hidden_states,)
+        if not return_dict:
+            outputs = (last_hidden_states, hidden_states) + (outputs[2:] if output_hidden_states else outputs[1:])
+            return tuple((v for v in outputs if v is not None))
+        return FlaxBaseModelOutput(last_hidden_state=last_hidden_states, hidden_states=hidden_states, attentions=outputs.attentions)
+
+class FlaxWhisperDecoder(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+    gradient_checkpointing: bool = False
+
+    def setup(self) -> None:
+        self.embed_tokens = Embed(self.config.vocab_size, self.config.d_model, dtype=self.dtype, params_dtype=self.params_dtype)
+        self.embed_positions = Embed(self.config.max_target_positions, self.config.d_model, dtype=self.dtype, params_dtype=self.params_dtype)
+        self.layers = FlaxWhisperDecoderLayerCollection(self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+        self.dropout_layer = nn.Dropout(rate=self.config.dropout)
+        self.layer_norm = LayerNorm(dtype=self.dtype, epsilon=1e-05, params_dtype=self.params_dtype)
+
+    def __call__(self, input_ids: jnp.ndarray, attention_mask: jnp.ndarray, position_ids: jnp.ndarray, encoder_hidden_states: Optional[jnp.ndarray]=None, init_cache: bool=False, output_attentions: bool=False, output_hidden_states: bool=False, return_dict: bool=True, deterministic: bool=True) -> Tuple[jnp.ndarray]:
+        input_embeds = self.embed_tokens(input_ids)
+        position_embeds = self.embed_positions(position_ids)
+        hidden_states = input_embeds + position_embeds
+        hidden_states = self.dropout_layer(hidden_states, deterministic=deterministic)
+        outputs = self.layers(hidden_states, attention_mask=attention_mask, encoder_hidden_states=encoder_hidden_states, deterministic=deterministic, init_cache=init_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict)
+        last_hidden_states = outputs[0]
+        last_hidden_states = self.layer_norm(last_hidden_states)
+        hidden_states = None
+        if output_hidden_states:
+            hidden_states = outputs[1]
+            if self.use_scan:
+                hidden_states = jnp.vstack([hidden_states[:-1], last_hidden_states[None, ...]])
+            else:
+                hidden_states = hidden_states[:-1] + (last_hidden_states,)
+        if not return_dict:
+            outputs = (last_hidden_states, hidden_states) + (outputs[2:] if output_hidden_states else outputs[1:])
+            return tuple((v for v in outputs if v is not None))
+        return FlaxBaseModelOutputWithPastAndCrossAttentions(last_hidden_state=last_hidden_states, hidden_states=hidden_states, attentions=outputs.attentions, cross_attentions=outputs.cross_attentions)
+
+class FlaxWhisperModule(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+    gradient_checkpointing: bool = False
+
+    def setup(self) -> None:
+        self.encoder = FlaxWhisperEncoder(self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+        self.decoder = FlaxWhisperDecoder(self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+
+    def __call__(self, input_features: jnp.ndarray, decoder_input_ids: jnp.ndarray, decoder_attention_mask: jnp.ndarray, decoder_position_ids: jnp.ndarray, output_attentions: bool=False, output_hidden_states: bool=False, freeze_encoder: bool=False, return_dict: bool=True, deterministic: bool=True):
+        encoder_outputs = self.encoder(input_features, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, deterministic=deterministic)
+        encoder_hidden_states = encoder_outputs[0]
+        if freeze_encoder:
+            encoder_hidden_states = jax.lax.stop_gradient(encoder_hidden_states)
+        decoder_outputs = self.decoder(input_ids=decoder_input_ids, attention_mask=decoder_attention_mask, position_ids=decoder_position_ids, encoder_hidden_states=encoder_hidden_states, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, deterministic=deterministic)
+        if not return_dict:
+            return decoder_outputs + encoder_outputs
+        return FlaxSeq2SeqModelOutput(last_hidden_state=decoder_outputs.last_hidden_state, decoder_hidden_states=decoder_outputs.hidden_states, decoder_attentions=decoder_outputs.attentions, cross_attentions=decoder_outputs.cross_attentions, encoder_last_hidden_state=encoder_outputs.last_hidden_state, encoder_hidden_states=encoder_outputs.hidden_states, encoder_attentions=encoder_outputs.attentions)
+
+    def _get_encoder_module(self):
+        return self.encoder
+
+    def _get_decoder_module(self):
+        return self.decoder
+
+class FlaxWhisperPreTrainedModel(FlaxPreTrainedModel):
+    config_class = WhisperConfig
+    base_model_prefix: str = 'model'
+    main_input_name = 'input_features'
+    module_class: nn.Module = None
+
+    def __init__(self, config: WhisperConfig, input_shape: Tuple[int, int, int]=None, seed: int=0, dtype: jnp.dtype=jnp.float32, params_dtype: jnp.dtype=jnp.float32, _do_init: bool=True, use_scan: bool=False, gradient_checkpointing: bool=False, **kwargs):
+        self.use_scan = use_scan
+        self.gradient_checkpointing = gradient_checkpointing
+        module = self.module_class(config=config, dtype=dtype, params_dtype=params_dtype, use_scan=use_scan, gradient_checkpointing=gradient_checkpointing, **kwargs)
+        if input_shape is None:
+            input_shape = (1, config.num_mel_bins, 2 * config.max_source_positions)
+        super().__init__(config, module, input_shape=input_shape, seed=seed, dtype=dtype, _do_init=_do_init)
+
+    def init_weights(self, rng: jax.random.PRNGKey, input_shape: Tuple, params: FrozenDict=None) -> FrozenDict:
+        input_features = jnp.zeros(input_shape, dtype='f4')
+        input_features = input_features.at[..., -1].set(self.config.eos_token_id)
+        decoder_input_ids = jnp.zeros((input_shape[0], 1), dtype='i4')
+        decoder_attention_mask = jnp.ones_like(decoder_input_ids)
+        (batch_size, sequence_length) = decoder_input_ids.shape
+        decoder_position_ids = jnp.broadcast_to(jnp.arange(sequence_length)[None, :], (batch_size, sequence_length))
+        (params_rng, dropout_rng) = jax.random.split(rng)
+        rngs = {'params': params_rng, 'dropout': dropout_rng}
+        random_params = self.module.init(rngs, input_features=input_features, decoder_input_ids=decoder_input_ids, decoder_attention_mask=decoder_attention_mask, decoder_position_ids=decoder_position_ids)['params']
+        if params is not None:
+            random_params = flatten_dict(unfreeze(random_params))
+            params = flatten_dict(unfreeze(params))
+            for missing_key in self._missing_keys:
+                params[missing_key] = random_params[missing_key]
+            self._missing_keys = set()
+            return freeze(unflatten_dict(params))
+        else:
+            return random_params
+
+    def enable_gradient_checkpointing(self):
+        self.gradient_checkpointing = True
+        self._module = self.module_class(config=self.config, dtype=self.dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+
+    def enable_scan(self):
+        self.use_scan = True
+        self._module = self.module_class(config=self.config, dtype=self.dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+        init_fn = partial(self.init_weights, input_shape=self.input_shape)
+        params_shape_tree = jax.eval_shape(init_fn, self.key)
+        self._params_shape_tree = params_shape_tree
+        self._required_params = set(flatten_dict(unfreeze(params_shape_tree)).keys())
+        if self._is_initialized:
+            self.params = self.convert_unroll_to_scan(self.params)
+
+    def disable_scan(self):
+        self.use_scan = False
+        self._module = self.module_class(config=self.config, dtype=self.dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+        init_fn = partial(self.init_weights, input_shape=self.input_shape)
+        params_shape_tree = jax.eval_shape(init_fn, self.key)
+        self._params_shape_tree = params_shape_tree
+        self._required_params = set(flatten_dict(unfreeze(params_shape_tree)).keys())
+        if self._is_initialized:
+            self.params = self.convert_scan_to_unroll(self.params)
+
+    def convert_unroll_to_scan(self, params: Union[Dict, FrozenDict]):
+        if isinstance(params, FrozenDict):
+            params = unfreeze(params)
+        params = flatten_dict(params, sep='/')
+        keys = list(params.keys())
+        for k in keys:
+            if 'layers/0' in k:
+                if 'decoder' in k:
+                    block_prefix = 'Decoder'
+                    num_hidden_layers = self.config.decoder_layers
+                else:
+                    block_prefix = 'Encoder'
+                    num_hidden_layers = self.config.encoder_layers
+                scan_key = k.replace('0', f'Flax{block_prefix}ScanLayers')
+                stacked_params = []
+                for i in range(num_hidden_layers):
+                    unrolled_layer = params.pop(k.replace('0', str(i)))
+                    stacked_params.append(unrolled_layer)
+                params[scan_key] = jnp.stack(stacked_params)
+        params = unflatten_dict(params, sep='/')
+        return params
+
+    def convert_scan_to_unroll(self, params: Union[Dict, FrozenDict]):
+        if isinstance(params, FrozenDict):
+            params = unfreeze(params)
+        params = flatten_dict(params, sep='/')
+        keys = list(params.keys())
+        for k in keys:
+            if 'FlaxEncoderScanLayers' in k:
+                scan_layer = params.pop(k)
+                for i in range(self.config.encoder_layers):
+                    unrolled_key = k.replace('FlaxEncoderScanLayers', str(i))
+                    (params[unrolled_key], scan_layer) = (scan_layer[0], scan_layer[1:])
+            elif 'FlaxDecoderScanLayers' in k:
+                scan_layer = params.pop(k)
+                for i in range(self.config.decoder_layers):
+                    unrolled_key = k.replace('FlaxDecoderScanLayers', str(i))
+                    (params[unrolled_key], scan_layer) = (scan_layer[0], scan_layer[1:])
+        params = unflatten_dict(params, sep='/')
+        return params
+
+    def init_cache(self, batch_size, max_length, encoder_outputs):
+        decoder_input_ids = jnp.ones((batch_size, max_length), dtype='i4')
+        decoder_attention_mask = jnp.ones_like(decoder_input_ids)
+        decoder_position_ids = jnp.broadcast_to(jnp.arange(jnp.atleast_2d(decoder_input_ids).shape[-1]), decoder_input_ids.shape)
+
+        def _decoder_forward(module, decoder_input_ids, decoder_attention_mask, decoder_position_ids, **kwargs):
+            decoder_module = module._get_decoder_module()
+            return decoder_module(decoder_input_ids, decoder_attention_mask, decoder_position_ids, **kwargs)
+        init_variables = self.module.init(jax.random.PRNGKey(0), decoder_input_ids=decoder_input_ids, decoder_attention_mask=decoder_attention_mask, decoder_position_ids=decoder_position_ids, encoder_hidden_states=encoder_outputs[0], init_cache=True, method=_decoder_forward)
+        return unfreeze(init_variables['cache'])
+
+    @add_start_docstrings(WHISPER_ENCODE_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=FlaxBaseModelOutput, config_class=WhisperConfig)
+    def encode(self, input_features: jnp.ndarray, attention_mask: Optional[jnp.ndarray]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, train: bool=False, params: dict=None, dropout_rng: PRNGKey=None, **kwargs):
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+        rngs = {}
+        if dropout_rng is not None:
+            rngs['dropout'] = dropout_rng
+
+        def _encoder_forward(module, input_features, **kwargs):
+            encode_module = module._get_encoder_module()
+            return encode_module(input_features, **kwargs)
+        return self.module.apply({'params': params or self.params}, input_features=jnp.array(input_features, dtype='f4'), output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, deterministic=not train, rngs=rngs, method=_encoder_forward)
+
+    @add_start_docstrings(WHISPER_DECODE_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=FlaxBaseModelOutputWithPastAndCrossAttentions, config_class=WhisperConfig)
+    def decode(self, decoder_input_ids, encoder_outputs, encoder_attention_mask: Optional[jnp.ndarray]=None, decoder_attention_mask: Optional[jnp.ndarray]=None, decoder_position_ids: Optional[jnp.ndarray]=None, past_key_values: dict=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, train: bool=False, params: dict=None, dropout_rng: PRNGKey=None):
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+        encoder_hidden_states = encoder_outputs[0]
+        (batch_size, sequence_length) = decoder_input_ids.shape
+        if decoder_position_ids is None:
+            if past_key_values is not None:
+                raise ValueError('Make sure to provide `decoder_position_ids` when passing `past_key_values`.')
+            if decoder_attention_mask is not None:
+                decoder_position_ids = decoder_attention_mask.cumsum(-1) * decoder_attention_mask - 1
+            else:
+                decoder_position_ids = jnp.broadcast_to(jnp.arange(sequence_length)[None, :], (batch_size, sequence_length))
+        if decoder_attention_mask is None:
+            decoder_attention_mask = jnp.ones((batch_size, sequence_length))
+        rngs = {}
+        if dropout_rng is not None:
+            rngs['dropout'] = dropout_rng
+        inputs = {'params': params or self.params}
+        if past_key_values:
+            inputs['cache'] = past_key_values
+            mutable = ['cache']
+        else:
+            mutable = False
+
+        def _decoder_forward(module, decoder_input_ids, decoder_attention_mask, decoder_position_ids, **kwargs):
+            decoder_module = module._get_decoder_module()
+            return decoder_module(input_ids=decoder_input_ids, attention_mask=decoder_attention_mask, position_ids=decoder_position_ids, **kwargs)
+        outputs = self.module.apply(inputs, decoder_input_ids=jnp.array(decoder_input_ids, dtype='i4'), decoder_attention_mask=jnp.array(decoder_attention_mask, dtype='i4'), decoder_position_ids=jnp.array(decoder_position_ids, dtype='i4'), encoder_hidden_states=encoder_hidden_states, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, deterministic=not train, rngs=rngs, mutable=mutable, method=_decoder_forward)
+        if past_key_values is not None and return_dict:
+            (outputs, past) = outputs
+            outputs['past_key_values'] = unfreeze(past['cache'])
+            return outputs
+        elif past_key_values is not None and (not return_dict):
+            (outputs, past) = outputs
+            outputs = outputs[:1] + (unfreeze(past['cache']),) + outputs[1:]
+        return outputs
+
+    @add_start_docstrings_to_model_forward(WHISPER_INPUTS_DOCSTRING)
+    def __call__(self, input_features: jnp.ndarray, decoder_input_ids: jnp.ndarray, attention_mask: Optional[jnp.ndarray]=None, decoder_attention_mask: Optional[jnp.ndarray]=None, position_ids: Optional[jnp.ndarray]=None, decoder_position_ids: Optional[jnp.ndarray]=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, freeze_encoder: Optional[bool]=None, return_dict: Optional[bool]=None, train: bool=False, params: dict=None, dropout_rng: PRNGKey=None):
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+        if decoder_position_ids is None:
+            if decoder_attention_mask is not None:
+                decoder_position_ids = decoder_attention_mask.cumsum(-1) * decoder_attention_mask - 1
+            else:
+                (batch_size, sequence_length) = decoder_input_ids.shape
+                decoder_position_ids = jnp.broadcast_to(jnp.arange(sequence_length)[None, :], (batch_size, sequence_length))
+        if decoder_attention_mask is None:
+            decoder_attention_mask = jnp.ones_like(decoder_input_ids)
+        rngs = {'dropout': dropout_rng} if dropout_rng is not None else {}
+        return self.module.apply({'params': params or self.params}, input_features=jnp.array(input_features, dtype='f4'), decoder_input_ids=jnp.array(decoder_input_ids, dtype='i4'), decoder_attention_mask=jnp.array(decoder_attention_mask, dtype='i4'), decoder_position_ids=jnp.array(decoder_position_ids, dtype='i4'), output_attentions=output_attentions, output_hidden_states=output_hidden_states, freeze_encoder=freeze_encoder, return_dict=return_dict, deterministic=not train, rngs=rngs)
+
+@add_start_docstrings('The bare Whisper Model transformer outputting raw hidden-states without any specific head on top.', WHISPER_START_DOCSTRING)
+class FlaxWhisperModel(FlaxWhisperPreTrainedModel):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    module_class = FlaxWhisperModule
+append_call_sample_docstring(FlaxWhisperModel, _CHECKPOINT_FOR_DOC, FlaxSeq2SeqModelOutput, _CONFIG_FOR_DOC)
+
+class FlaxWhisperForConditionalGenerationModule(nn.Module):
+    config: WhisperConfig
+    dtype: jnp.dtype = jnp.float32
+    params_dtype: jnp.dtype = jnp.float32
+    use_scan: bool = False
+    gradient_checkpointing: bool = False
+
+    def setup(self) -> None:
+        self.model = FlaxWhisperModule(config=self.config, dtype=self.dtype, params_dtype=self.params_dtype, use_scan=self.use_scan, gradient_checkpointing=self.gradient_checkpointing)
+        self.lm_head = DenseGeneral(self.config.vocab_size, use_bias=False, dtype=self.dtype, params_dtype=self.params_dtype, kernel_axes=('embed', 'vocab'))
+
+    def _get_encoder_module(self):
+        return self.model.encoder
+
+    def _get_decoder_module(self):
+        return self.model.decoder
+
+    def __call__(self, input_features, decoder_input_ids, decoder_attention_mask: jnp.ndarray=None, decoder_position_ids: jnp.ndarray=None, position_ids: jnp.ndarray=None, attention_mask: jnp.ndarray=None, output_attentions: bool=False, output_hidden_states: bool=False, freeze_encoder: bool=False, return_dict: bool=True, deterministic: bool=True):
+        outputs = self.model(input_features=input_features, decoder_input_ids=decoder_input_ids, decoder_attention_mask=decoder_attention_mask, decoder_position_ids=decoder_position_ids, output_attentions=output_attentions, output_hidden_states=output_hidden_states, freeze_encoder=freeze_encoder, return_dict=return_dict, deterministic=deterministic)
+        hidden_states = outputs[0]
+        if self.config.tie_word_embeddings:
+            shared_embedding = self.model.decoder.embed_tokens.variables['params']['embedding']
+            lm_logits = self.lm_head.apply({'params': {'kernel': shared_embedding.T}}, hidden_states)
+        else:
+            lm_logits = self.lm_head(hidden_states)
+        if not return_dict:
+            output = (lm_logits,) + outputs[1:]
+            return output
+        return FlaxSeq2SeqLMOutput(logits=lm_logits, decoder_hidden_states=outputs.decoder_hidden_states, decoder_attentions=outputs.decoder_attentions, cross_attentions=outputs.cross_attentions, encoder_last_hidden_state=outputs.encoder_last_hidden_state, encoder_hidden_states=outputs.encoder_hidden_states, encoder_attentions=outputs.encoder_attentions)
+
+@add_start_docstrings('The Whisper Model with a language modeling head.', WHISPER_START_DOCSTRING)
+class FlaxWhisperForConditionalGeneration(FlaxWhisperPreTrainedModel):
+    module_class = FlaxWhisperForConditionalGenerationModule
+
+    @add_start_docstrings(WHISPER_DECODE_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=FlaxCausalLMOutputWithCrossAttentions, config_class=WhisperConfig)
+    def decode(self, decoder_input_ids, encoder_outputs, encoder_attention_mask: Optional[jnp.ndarray]=None, decoder_attention_mask: Optional[jnp.ndarray]=None, decoder_position_ids: Optional[jnp.ndarray]=None, past_key_values: dict=None, output_attentions: Optional[bool]=None, output_hidden_states: Optional[bool]=None, return_dict: Optional[bool]=None, train: bool=False, params: dict=None, dropout_rng: PRNGKey=None):
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
+        encoder_hidden_states = encoder_outputs[0]
+        (batch_size, sequence_length) = decoder_input_ids.shape
+        if decoder_position_ids is None:
+            if past_key_values is not None:
+                raise ValueError('Make sure to provide `decoder_position_ids` when passing `past_key_values`.')
+            if decoder_attention_mask is not None:
+                decoder_position_ids = decoder_attention_mask.cumsum(-1) * decoder_attention_mask - 1
+            else:
+                decoder_position_ids = jnp.broadcast_to(jnp.arange(sequence_length)[None, :], (batch_size, sequence_length))
+        if decoder_attention_mask is None:
+            decoder_attention_mask = jnp.ones((batch_size, sequence_length), dtype='i4')
+        rngs = {}
+        if dropout_rng is not None:
+            rngs['dropout'] = dropout_rng
+        inputs = {'params': params or self.params}
+        if past_key_values:
+            inputs['cache'] = past_key_values
+            mutable = ['cache']
+        else:
+            mutable = False
+
+        def _decoder_forward(module, decoder_input_ids, decoder_attention_mask, decoder_position_ids, **kwargs):
+            decoder_module = module._get_decoder_module()
+            outputs = decoder_module(input_ids=decoder_input_ids, attention_mask=decoder_attention_mask, position_ids=decoder_position_ids, **kwargs)
+            hidden_states = outputs[0]
+            if self.config.tie_word_embeddings:
+                shared_embedding = module.model.decoder.embed_tokens.variables['params']['embedding']
+                lm_logits = module.lm_head.apply({'params': {'kernel': shared_embedding.T}}, hidden_states)
+            else:
+                lm_logits = module.lm_head(hidden_states)
+            return (lm_logits, outputs)
+        outputs = self.module.apply(inputs, decoder_input_ids=jnp.array(decoder_input_ids, dtype='i4'), decoder_attention_mask=jnp.array(decoder_attention_mask, dtype='i4'), decoder_position_ids=jnp.array(decoder_position_ids, dtype='i4'), encoder_hidden_states=encoder_hidden_states, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, deterministic=not train, rngs=rngs, mutable=mutable, method=_decoder_forward)
+        if past_key_values is None:
+            (lm_logits, decoder_outputs) = outputs
+        else:
+            ((lm_logits, decoder_outputs), past) = outputs
+        if return_dict:
+            outputs = FlaxCausalLMOutputWithCrossAttentions(logits=lm_logits, hidden_states=decoder_outputs.hidden_states, attentions=decoder_outputs.attentions, cross_attentions=decoder_outputs.cross_attentions)
+        else:
+            outputs = (lm_logits,) + decoder_outputs[1:]
+        if past_key_values is not None and return_dict:
+            outputs['past_key_values'] = unfreeze(past['cache'])
+            return outputs
+        elif past_key_values is not None and (not return_dict):
+            outputs = outputs[:1] + (unfreeze(past['cache']),) + outputs[1:]
+        return outputs
+
+    def generate(self, input_features, generation_config=None, logits_processor=None, return_timestamps=None, task=None, language=None, is_multilingual=None, **kwargs):
+        if generation_config is None:
+            generation_config = self.generation_config
+        if return_timestamps is not None:
+            generation_config.return_timestamps = return_timestamps
+        if task is not None:
+            generation_config.task = task
+        if is_multilingual is not None:
+            generation_config.is_multilingual = is_multilingual
+        if language is not None:
+            generation_config.language = language
+        if kwargs is not None and 'decoder_input_ids' in kwargs:
+            decoder_input_length = len(kwargs['decoder_input_ids'])
+        else:
+            decoder_input_length = 1
+        forced_decoder_ids = []
+        if hasattr(generation_config, 'is_multilingual') and generation_config.is_multilingual:
+            if hasattr(generation_config, 'language'):
+                forced_decoder_ids.append((1, generation_config.lang_to_id[generation_config.language]))
+            else:
+                forced_decoder_ids.append((1, None))
+            if hasattr(generation_config, 'task'):
+                forced_decoder_ids.append((2, generation_config.task_to_id[generation_config.task]))
+            else:
+                forced_decoder_ids.append((2, generation_config.task_to_id['transcribe']))
+        if hasattr(generation_config, 'return_timestamps') and generation_config.return_timestamps or return_timestamps:
+            logits_processor = [FlaxWhisperTimeStampLogitsProcessor(generation_config, self.config, decoder_input_length)]
+        elif forced_decoder_ids and forced_decoder_ids[-1][0] != generation_config.no_timestamps_token_id:
+            idx = forced_decoder_ids[-1][0] + 1 if forced_decoder_ids else 1
+            forced_decoder_ids.append((idx, generation_config.no_timestamps_token_id))
+        if len(forced_decoder_ids) > 0:
+            generation_config.forced_decoder_ids = forced_decoder_ids
+        return super().generate(input_features, generation_config, logits_processor=logits_processor, **kwargs)
+
+    def pipeline_generate(self, input_features, forced_decoder_ids, return_timestamps=False, generation_config=None, **kwargs):
+        if generation_config is None:
+            generation_config = self.generation_config
+        generation_config.forced_decoder_ids = None
+        logits_processor = FlaxLogitsProcessorList()
+        logits_processor.append(FlaxStaticForceTokensLogitsProcessor(forced_decoder_ids))
+        if hasattr(generation_config, 'return_timestamps') and return_timestamps:
+            logits_processor.append(FlaxWhisperTimeStampLogitsProcessor(generation_config, self.config, 1))
+        return super().generate(input_features, generation_config, logits_processor=logits_processor, **kwargs)
+
+    def prepare_inputs_for_generation(self, decoder_input_ids, max_length, attention_mask: Optional[jax.Array]=None, decoder_attention_mask: Optional[jax.Array]=None, encoder_outputs=None, **kwargs):
+        (batch_size, seq_length) = decoder_input_ids.shape
+        past_key_values = self.init_cache(batch_size, max_length, encoder_outputs)
+        extended_attention_mask = jnp.ones((batch_size, max_length), dtype='i4')
+        if decoder_attention_mask is not None:
+            position_ids = decoder_attention_mask.cumsum(-1) - 1
+            extended_attention_mask = lax.dynamic_update_slice(extended_attention_mask, decoder_attention_mask, (0, 0))
+        else:
+            position_ids = jnp.broadcast_to(jnp.arange(seq_length, dtype='i4')[None, :], (batch_size, seq_length))
+        return {'past_key_values': past_key_values, 'encoder_outputs': encoder_outputs, 'encoder_attention_mask': attention_mask, 'decoder_attention_mask': extended_attention_mask, 'decoder_position_ids': position_ids}
+
+    def update_inputs_for_generation(self, model_outputs, model_kwargs):
+        model_kwargs['past_key_values'] = model_outputs.past_key_values
+        model_kwargs['decoder_position_ids'] = model_kwargs['decoder_position_ids'][:, -1:] + 1
+        return model_kwargs
+FLAX_WHISPER_CONDITIONAL_GENERATION_DOCSTRING = '\n    Returns:\n\n    Transcription example:\n\n    ```python\n    >>> from transformers import WhisperProcessor, FlaxWhisperForConditionalGeneration\n    >>> from datasets import load_dataset\n\n    >>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")\n    >>> model = FlaxWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en", from_pt=True)\n    >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")\n    >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="np")\n    >>> input_features = inputs.input_features\n    >>> generated_ids = model.generate(input_ids=input_features)\n    >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]\n    >>> transcription\n    \' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.\'\n    ```\n'
+overwrite_call_docstring(FlaxWhisperForConditionalGeneration, WHISPER_INPUTS_DOCSTRING + FLAX_WHISPER_CONDITIONAL_GENERATION_DOCSTRING)
+append_replace_return_docstrings(FlaxWhisperForConditionalGeneration, output_type=FlaxSeq2SeqLMOutput, config_class=_CONFIG_FOR_DOC)
+
+# File: distil-whisper-main/training/flax/distil_whisper/partitioner.py
+""""""
+import abc
+import collections
+import dataclasses
+import typing
+from typing import Any, Callable, Optional, Sequence, Tuple, Union
+import cached_property
+import jax
+import numpy as np
+from absl import logging
+from flax import traverse_util
+from flax.linen import partitioning as flax_partitioning
+from jax import numpy as jnp
+from jax import random
+from jax.experimental import multihost_utils
+from jax.experimental.mesh_utils import create_hybrid_device_mesh
+from jax.experimental.pjit import pjit as jax_pjit
+from jax.sharding import Mesh, PartitionSpec
+JaxDevice = Any
+TpuMesh = Tuple[int, int, int, int]
+OtherMesh = Tuple[int, int]
+HardwareMesh = Union[TpuMesh, OtherMesh]
+PyTreeDef = type(jax.tree_util.tree_structure(None))
+TrainState = Any
+LogicalAxisRules = Sequence[Tuple[str, Optional[str]]]
+if typing.TYPE_CHECKING:
+    cached_property = property
+else:
+    cached_property = cached_property.cached_property
+
+class AxisNames(tuple):
+
+    def __new__(cls, *names):
+        return tuple.__new__(AxisNames, names)
+
+    def __repr__(self):
+        return 'AxisNames%s' % tuple.__repr__(self)
+
+def pjit(fun: Callable, in_axis_resources, out_axis_resources, static_argnums: Union[int, Sequence[int]]=(), donate_argnums: Union[int, Sequence[int]]=(), backend: Optional[str]=None):
+    del backend
+    return jax_pjit(fun, in_axis_resources, out_axis_resources, static_argnums=static_argnums, donate_argnums=donate_argnums)
+
+def pjit_with_cpu_fallback(fun: Callable, in_axis_resources, out_axis_resources, static_argnums: Union[int, Sequence[int]]=(), donate_argnums: Union[int, Sequence[int]]=(), backend: Optional[str]=None):
+    if jax.devices(backend)[0].platform == 'cpu':
+        return jax.jit(fun, static_argnums=static_argnums, donate_argnums=donate_argnums)
+    else:
+        return jax_pjit(fun, in_axis_resources, out_axis_resources, static_argnums=static_argnums, donate_argnums=donate_argnums)
+
+def with_sharding_constraint(x, axis_resources):
+    if jax.devices()[0].platform == 'cpu' or not global_mesh_defined():
+        return x
+    else:
+        return jax.experimental.pjit.with_sharding_constraint(x, axis_resources)
+
+def bounds_from_last_device(last_device: JaxDevice) -> HardwareMesh:
+    if hasattr(last_device, 'coords'):
+        (x, y, z) = last_device.coords
+        return (x + 1, y + 1, z + 1, last_device.core_on_chip + 1)
+    else:
+        return (jax.host_count(), jax.local_device_count())
+
+def get_coords(device: JaxDevice) -> HardwareMesh:
+    if hasattr(device, 'coords'):
+        return (*device.coords, device.core_on_chip)
+    return (device.process_index, device.id % jax.local_device_count())
+
+def global_mesh_defined():
+    maps_env = jax.experimental.maps.thread_resources.env
+    return maps_env.physical_mesh.devices.shape != ()
+
+def get_mesh(model_parallel_submesh: HardwareMesh, input_devices: Sequence[JaxDevice]=(), input_local_devices: Sequence[JaxDevice]=(), tile_by_host_if_needed: bool=True, backend: Optional[str]=None) -> Mesh:
+    input_devices = input_devices or jax.devices(backend)
+    input_local_devices = input_local_devices or jax.local_devices(0, backend)
+    last_device = sorted(input_devices, key=get_coords)[-1]
+    last_input_local_devices = sorted(input_local_devices, key=get_coords)[-1]
+    logging.info('last device coords : %r\nlast local device coords: %r', get_coords(last_device), get_coords(last_input_local_devices))
+    global_hardware_mesh = bounds_from_last_device(last_device)
+    mesh_ndim = len(global_hardware_mesh)
+    local_hardware_mesh = bounds_from_last_device(last_input_local_devices)
+    mesh_err = f'each dimension of the model parallel submesh {model_parallel_submesh} must be a factor of the corresponding dimension of the global device mesh {global_hardware_mesh}'
+    assert not any((g % m for (g, m) in zip(global_hardware_mesh, model_parallel_submesh))), mesh_err
+    assert not any((g % l for (g, l) in zip(global_hardware_mesh, local_hardware_mesh)))
+    devices = np.empty(global_hardware_mesh, dtype=object)
+    for device in input_devices:
+        device_coords = get_coords(device)
+        devices[device_coords] = device
+    tile_by_host = tile_by_host_if_needed
+    if len(global_hardware_mesh) == 4:
+        global_hardware_mesh = typing.cast(Tuple[int, int, int, int], global_hardware_mesh)
+        model_parallel_submesh = typing.cast(Tuple[int, int, int, int], model_parallel_submesh)
+        (gx, gy, gz, gc) = global_hardware_mesh
+        (mx, my, mz, mc) = model_parallel_submesh
+        if mx == gx > 1 and my == mz == 1 or (mx == 1 and my == gy > 1 and (mz == gz > 1)):
+            logging.info('ensuring YZ plane has a Z-major device order')
+            assert mc == gc, (mc, gc)
+            global_hardware_mesh = (gx, gz, gy, gc)
+            model_parallel_submesh = (mx, mz, my, mc)
+            devices = devices.swapaxes(1, 2)
+            tile_by_host = False
+        if my == gy > 1 and mx == mz == 1 or (my == 1 and mx == gx > 1 and (mz == gz > 1)):
+            logging.info('ensuring XZ plane has a Z-major device order')
+            assert mc == gc, (mc, gc)
+            global_hardware_mesh = (gz, gy, gx, gc)
+            model_parallel_submesh = (mz, my, mx, mc)
+            devices = devices.swapaxes(0, 2)
+            tile_by_host = False
+    if tile_by_host:
+        logging.warning('Tiling device assignment mesh by hosts, which may lead to reduced XLA collective performance. To avoid this, modify the model parallel submesh or run with more tasks per host.')
+        tile_err = 'to tile the mesh by hosts, each dimension of the model parallel submesh must be either a factor or a multiple of the corresponding dimension of the per-host submesh'
+
+        def dh_dd_mh_md(g: int, m: int, l: int) -> Tuple[int, int, int, int]:
+            d = g // m
+            if m >= l:
+                assert not m % l, tile_err
+                return (d, 1, m // l, l)
+            else:
+                assert not l % m, tile_err
+                return (d // (l // m), l // m, 1, m)
+        dh_dd_mh_md_tups = map(dh_dd_mh_md, global_hardware_mesh, model_parallel_submesh, local_hardware_mesh)
+        devices = devices.reshape(*(s for t in dh_dd_mh_md_tups for s in t))
+        devices = devices.transpose(*(4 * i for i in range(mesh_ndim)), *(4 * i + 1 for i in range(mesh_ndim)), *(4 * i + 2 for i in range(mesh_ndim)), *(4 * i + 3 for i in range(mesh_ndim)))
+    else:
+        model_data_tups = [(g // m, m) for (g, m) in zip(global_hardware_mesh, model_parallel_submesh)]
+        devices = devices.reshape(*(s for t in model_data_tups for s in t))
+        devices = devices.transpose(*(2 * i for i in range(mesh_ndim)), *(2 * i + 1 for i in range(mesh_ndim)))
+    devices = devices.reshape(-1, np.prod(model_parallel_submesh))
+    global_mesh = Mesh(devices, ['data', 'model'])
+    logging.info('global_mesh axis_names: %s', global_mesh.axis_names)
+    logging.info('global_mesh devices: %s', global_mesh.devices)
+    logging.info('global_mesh devices shape: %s', global_mesh.devices.shape)
+    return global_mesh
+
+def get_cpu_mesh() -> Mesh:
+    devices = np.empty((jax.host_count(), jax.local_device_count()), dtype=object)
+    for device in jax.devices():
+        devices[device.process_index, device.id % jax.local_device_count()] = device
+    return Mesh(devices, ['data', 'model'])
+
+def get_gpu_mesh(num_partitions: int) -> Mesh:
+    nvlink_size = jax.local_device_count()
+    dcn_size = jax.process_count()
+    nvlink_mp = min(num_partitions, nvlink_size)
+    (nvlink_dp, extra1) = divmod(nvlink_size, nvlink_mp)
+    (dcn_mp, extra2) = divmod(num_partitions, nvlink_mp)
+    assert not (extra1 or extra2), 'number of partitions on GPU must be a factor or multiple of the number of local devices'
+    dcn_dp = dcn_size // dcn_mp
+    devices = create_hybrid_device_mesh(mesh_shape=[nvlink_dp, nvlink_mp], dcn_mesh_shape=[dcn_dp, dcn_mp], process_is_granule=True)
+    global_mesh = Mesh(devices, ['data', 'model'])
+    logging.info('global_mesh axis_names: %s', global_mesh.axis_names)
+    logging.info('global_mesh devices: %s', global_mesh.devices)
+    return global_mesh
+
+def default_mesh(num_partitions: int, model_parallel_submesh: Optional[HardwareMesh]=None, backend: Optional[str]=None) -> Mesh:
+    last_device = jax.devices(backend)[-1]
+    platform = last_device.platform
+    device_kind = last_device.device_kind
+    bounds = bounds_from_last_device(last_device)
+    if model_parallel_submesh:
+        return get_mesh(model_parallel_submesh, backend=backend)
+    if platform == 'cpu':
+        return get_cpu_mesh()
+    elif platform == 'gpu':
+        return get_gpu_mesh(num_partitions)
+    mps = None
+    if device_kind in ('TPU v2', 'TPU v3'):
+        if num_partitions == 1:
+            mps = (1, 1, 1, 1)
+        elif num_partitions == 2:
+            mps = (1, 1, 1, 2)
+        elif num_partitions == 4:
+            mps = (2, 1, 1, 2)
+        elif num_partitions == 8:
+            mps = (2, 2, 1, 2)
+        elif num_partitions == 16:
+            mps = (4, 2, 1, 2)
+    elif (device_kind == 'TPU v4' or device_kind == 'TPU v4 lite') and bounds[3] == 1:
+        if num_partitions == 1:
+            mps = (1, 1, 1, 1)
+        elif num_partitions == 2:
+            mps = (1, 2, 1, 1)
+        elif num_partitions == 4:
+            if bounds[0] >= 4:
+                mps = (4, 1, 1, 1)
+            else:
+                mps = (2, 2, 1, 1)
+        elif num_partitions == 8:
+            if bounds[2] >= 8:
+                mps = (1, 1, 8, 1)
+            else:
+                mps = (4, 2, 1, 1)
+        elif num_partitions == 16:
+            if bounds[2] >= 16:
+                mps = (1, 1, 16, 1)
+            elif bounds[0] >= 8:
+                mps = (8, 2, 1, 1)
+            elif bounds[0] >= 4:
+                mps = (4, 4, 1, 1)
+            else:
+                mps = (2, 2, 4, 1)
+    if mps is None:
+        raise ValueError('No default mesh for this configuration: specify config.model_parallel_submesh explicitly.')
+    return get_mesh(mps, backend=backend)
+
+@dataclasses.dataclass
+class LocalChunkInfo:
+    slice: Tuple[slice, ...]
+    replica_id: int
+
+class LocalChunker:
+
+    def __init__(self, global_mesh: Mesh):
+        self.global_mesh = global_mesh
+        local_mesh = global_mesh.local_mesh
+        first_local_device = local_mesh.devices.reshape(-1)[0]
+        host_location = collections.OrderedDict(zip(global_mesh.shape.keys(), list(zip(*np.nonzero(global_mesh.devices == first_local_device)))[0]))
+        self.num_chunks = collections.OrderedDict()
+        self.chunk_ids = collections.OrderedDict()
+        self.mesh_axes = list(global_mesh.shape.keys())
+        for mesh_axis in self.mesh_axes:
+            num_devices_per_chunk = local_mesh.shape[mesh_axis]
+            self.num_chunks[mesh_axis] = global_mesh.shape[mesh_axis] // num_devices_per_chunk
+            self.chunk_ids[mesh_axis] = host_location[mesh_axis] // num_devices_per_chunk
+
+    def get_local_chunk_info(self, global_shape: Tuple[int, ...], mesh_axes: Sequence[Optional[str]]) -> LocalChunkInfo:
+        local_slice = [slice(None) for dim in global_shape]
+        sharded_mesh_axes = set()
+        for (i, (mesh_axis, size)) in enumerate(zip(mesh_axes, global_shape)):
+            if not mesh_axis:
+                continue
+            sharded_mesh_axes.add(mesh_axis)
+            if not isinstance(mesh_axis, str):
+                raise NotImplementedError('TODO(jekbradbury)')
+            chunk_id = self.chunk_ids[mesh_axis]
+            chunk_size = size // self.num_chunks[mesh_axis]
+            local_slice[i] = slice(chunk_id * chunk_size, (chunk_id + 1) * chunk_size)
+        replicated_mesh_axes = [mesh_axis for mesh_axis in self.mesh_axes if mesh_axis not in sharded_mesh_axes]
+        replica_id = 0
+        for mesh_axis in replicated_mesh_axes:
+            chunk_id = self.chunk_ids[mesh_axis]
+            replica_id = replica_id * self.num_chunks[mesh_axis] + chunk_id
+        return LocalChunkInfo(tuple(local_slice), replica_id)
+
+def standard_logical_axis_rules(activation_partitioning_dims: int=1, parameter_partitioning_dims: int=1, additional_rules: Optional[LogicalAxisRules]=None) -> LogicalAxisRules:
+    logging.info('`activation_partitioning_dims` = %d, `parameter_partitioning_dims` = %d', activation_partitioning_dims, parameter_partitioning_dims)
+    if activation_partitioning_dims == 1 and parameter_partitioning_dims == 1:
+        rules = [('batch', 'data'), ('vocab', 'model'), ('embed', None), ('mlp', 'model'), ('heads', 'model'), ('kv', None), ('joined_kv', 'model')]
+    elif activation_partitioning_dims == 2 and parameter_partitioning_dims == 1:
+        rules = [('batch', 'data'), ('vocab', 'model'), ('mlp', 'model'), ('heads', 'model'), ('kv', None), ('joined_kv', 'model'), ('embed', 'model')]
+    elif activation_partitioning_dims == 1 and parameter_partitioning_dims == 2:
+        rules = [('batch', 'data'), ('vocab', 'model'), ('mlp', 'model'), ('heads', 'model'), ('kv', None), ('joined_kv', 'model'), ('embed', 'data')]
+    elif activation_partitioning_dims == 2 and parameter_partitioning_dims == 2:
+        rules = [('batch', 'data'), ('vocab', 'model'), ('mlp', 'model'), ('heads', 'model'), ('kv', None), ('joined_kv', 'model'), ('embed', 'model'), ('embed', 'data')]
+    else:
+        raise ValueError(f'`activation_partitioning_dims` = {activation_partitioning_dims} `parameter_partitioning_dims` = {parameter_partitioning_dims} is not supported.')
+    replicated_rules = [('relpos_buckets', None), ('abspos_buckets', None), ('length', None), ('layers', None), ('stack', None), ('mlp_activations', None)]
+    rules.extend(replicated_rules)
+    if additional_rules:
+        rules.extend(additional_rules)
+    return rules
+
+def _id_fn(x, ix):
+    y = random.split(random.PRNGKey(jnp.array(ix, dtype=jnp.uint32)))
+    return (x, y)
+
+@dataclasses.dataclass
+class DataLayout:
+    batch_size: int
+    shard_id: int
+    num_shards: int
+    is_first_host_in_replica_set: bool
+PartitionedCallable = Callable[..., Any]
+CompiledPartitionedCallable = Callable[..., Any]
+
+class BasePartitioner(metaclass=abc.ABCMeta):
+
+    def __init__(self, num_partitions: Optional[int]=None, model_parallel_submesh: Optional[HardwareMesh]=None, params_on_devices: bool=True, backend: Optional[str]=None):
+        if not num_partitions and (not model_parallel_submesh):
+            raise ValueError('At least one of `num_partitions` or `model_parallel_submesh` must be set.')
+        if model_parallel_submesh is not None and len(model_parallel_submesh) != 4:
+            logging.error('`model_parallel_submesh` must be either None or a 4-tuple. Got `model_parallel_submesh`=%s. A ValueError will be raised beginning March 1, 2022.', model_parallel_submesh)
+        if bool(num_partitions) and bool(model_parallel_submesh):
+            logging.error('At most one of `num_partitions` or `model_parallel_submesh` can be set. Got `num_partitions=%s` and `model_parallel_submesh`=%s. A ValueError will be raised beginning March 21, 2022.', num_partitions, model_parallel_submesh)
+        self._num_partitions = num_partitions
+        self._model_parallel_submesh = model_parallel_submesh
+        self._params_on_devices = params_on_devices
+        self._data_axis = 'data'
+        self._backend = backend
+
+    @property
+    def mesh(self) -> Mesh:
+        raise NotImplementedError
+
+    @property
+    def data_partition_spec(self) -> PartitionSpec:
+        return PartitionSpec(self._data_axis)
+
+    def get_data_layout(self, batch_size: Optional[int]=None, host_index: Optional[int]=None) -> DataLayout:
+        if host_index is not None:
+            raise NotImplementedError('Explicit host_index is not yet implemented.')
+        if self._data_axis is None:
+            return DataLayout(batch_size=batch_size, shard_id=0, num_shards=1, is_first_host_in_replica_set=jax.process_index() == 0)
+        mesh_size = self._local_chunker.global_mesh.shape[self._data_axis]
+        batch_size = batch_size or mesh_size
+        if batch_size % mesh_size:
+            raise ValueError(f'Batch size ({batch_size}) must be divisible by corresponding mesh size ({mesh_size}).')
+        num_shards = self._local_chunker.num_chunks[self._data_axis]
+        if batch_size % num_shards:
+            raise ValueError(f'Batch size ({batch_size}) must be divisible by number of replicas ({num_shards}).')
+        replica_id = self._local_chunker.get_local_chunk_info((batch_size,), [self._data_axis]).replica_id
+        return DataLayout(batch_size=int(batch_size), shard_id=int(self._local_chunker.chunk_ids[self._data_axis]), num_shards=int(num_shards), is_first_host_in_replica_set=replica_id == 0)
+
+    def get_local_chunk_info(self, global_shape: Tuple[int, ...], mesh_axes: Sequence[Optional[str]]) -> LocalChunkInfo:
+        return self._local_chunker.get_local_chunk_info(global_shape, mesh_axes)
+
+    @property
+    def params_on_devices(self):
+        return self._params_on_devices
+
+    def move_params_to_devices(self, train_state: TrainState, train_state_axes: TrainState) -> TrainState:
+        p_id_fn = self.partition(_id_fn, in_axis_resources=(train_state_axes, None), out_axis_resources=(train_state_axes, None), donate_argnums=(0,))
+        if jax.config.jax_array and jax.process_count() > 1:
+            train_state = multihost_utils.host_local_array_to_global_array(train_state, self.mesh, train_state_axes)
+        (train_state, _) = p_id_fn(train_state, jnp.ones((), dtype=jnp.uint32))
+        return train_state
+
+    @property
+    @abc.abstractmethod
+    def _local_chunker(self):
+        raise NotImplementedError
+
+    def get_logical_axes(self, train_state: TrainState) -> TrainState:
+        return train_state.restore_state(jax.tree_map(lambda x: None, train_state.state_dict()))
+
+    def get_mesh_axes(self, train_state: TrainState) -> TrainState:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def partition(self, fn: Callable, in_axis_resources, out_axis_resources, static_argnums: Union[int, Sequence[int]]=(), donate_argnums: Union[int, Sequence[int]]=()) -> PartitionedCallable:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def compile(self, partitioned_fn: PartitionedCallable, *args) -> CompiledPartitionedCallable:
+        raise NotImplementedError
+
+class PjittedFnWithContext(PartitionedCallable):
+
+    def __init__(self, pjitted_fn, partition_mesh: Mesh, logical_axis_rules: flax_partitioning.LogicalRules=()):
+        self._pjitted_fn = pjitted_fn
+        self._mesh = partition_mesh
+        self._logical_axis_rules = logical_axis_rules
+
+    def __call__(self, *args):
+        with Mesh(self._mesh.devices, self._mesh.axis_names), flax_partitioning.axis_rules(self._logical_axis_rules):
+            return self._pjitted_fn(*args)
+
+    def lower(self, *args):
+        with Mesh(self._mesh.devices, self._mesh.axis_names), flax_partitioning.axis_rules(self._logical_axis_rules):
+            return self._pjitted_fn.lower(*args)
+
+class BasePjitPartitioner(BasePartitioner):
+
+    @cached_property
+    def _local_chunker(self) -> LocalChunker:
+        return LocalChunker(self.mesh)
+
+    @cached_property
+    def mesh(self) -> Mesh:
+        return default_mesh(self._num_partitions, self._model_parallel_submesh, self._backend)
+
+    def partition(self, fn: Callable, in_axis_resources, out_axis_resources, static_argnums: Union[int, Sequence[int]]=(), donate_argnums: Union[int, Sequence[int]]=()) -> PjittedFnWithContext:
+        pjitted = pjit(fn, in_axis_resources=in_axis_resources, out_axis_resources=out_axis_resources, static_argnums=static_argnums, donate_argnums=donate_argnums, backend=self._backend)
+        return PjittedFnWithContext(pjitted, self.mesh)
+
+    def compile(self, partitioned_fn: PjittedFnWithContext, *args) -> CompiledPartitionedCallable:
+        return partitioned_fn.lower(*args).compile()
+
+class PjitPartitioner(BasePjitPartitioner):
+
+    def __init__(self, num_partitions: Optional[int]=None, model_parallel_submesh: Optional[HardwareMesh]=None, params_on_devices: bool=True, backend: Optional[str]=None, logical_axis_rules: Optional[LogicalAxisRules]=None, use_cpu_pjit: Optional[bool]=False):
+        super().__init__(num_partitions=num_partitions, model_parallel_submesh=model_parallel_submesh, params_on_devices=params_on_devices, backend=backend)
+        if logical_axis_rules is None:
+            logical_axis_rules = standard_logical_axis_rules()
+        self._logical_axis_rules = tuple(logical_axis_rules)
+        (self._data_axis,) = flax_partitioning.logical_to_mesh_axes(['batch'], logical_axis_rules)
+        self._use_cpu_pjit = use_cpu_pjit
+
+    def partition(self, fn: Callable, in_axis_resources, out_axis_resources, static_argnums: Union[int, Sequence[int]]=(), donate_argnums: Union[int, Sequence[int]]=()) -> PjittedFnWithContext:
+        if self._use_cpu_pjit:
+            pjit_fn = pjit_with_cpu_fallback
+        else:
+            pjit_fn = pjit
+        pjitted = pjit_fn(fn, in_axis_resources=in_axis_resources, out_axis_resources=out_axis_resources, static_argnums=static_argnums, donate_argnums=donate_argnums, backend=self._backend)
+        return PjittedFnWithContext(pjitted, self.mesh, self._logical_axis_rules)
+
+    @property
+    def logical_axis_rules(self):
+        return self._logical_axis_rules
+
+    def get_logical_axes(self, train_state: TrainState) -> TrainState:
+        return train_state.as_logical_axes()
+
+    def get_mesh_axes(self, train_state: TrainState) -> TrainState:
+        logical_axes = self.get_logical_axes(train_state)
+
+        def _logical_to_mesh_axes(param_name, logical_axes):
+            if logical_axes is None:
+                return None
+            elif logical_axes is traverse_util.empty_node:
+                return traverse_util.empty_node
+            try:
+                return flax_partitioning.logical_to_mesh_axes(logical_axes, self._logical_axis_rules)
+            except ValueError as e:
+                raise ValueError(f'Failed to map logical axes for {param_name}') from e
+        flat_logical_axes = traverse_util.flatten_dict(logical_axes.state_dict(), keep_empty_nodes=True, sep='/')
+        flat_mesh_axes = {k: _logical_to_mesh_axes(k, v) for (k, v) in flat_logical_axes.items()}
+        return logical_axes.restore_state(traverse_util.unflatten_dict(flat_mesh_axes, sep='/'))
+
+# File: distil-whisper-main/training/flax/distil_whisper/pipeline.py
+""""""
+import math
+import jax
+import jax.numpy as jnp
+import numpy as np
+import requests
+import torch
+from flax import jax_utils
+from flax.core.frozen_dict import freeze
+from flax.training.common_utils import shard
+from transformers import WhisperFeatureExtractor, WhisperTokenizerFast
+from transformers.models.whisper.tokenization_whisper import TO_LANGUAGE_CODE
+from transformers.pipelines.audio_utils import ffmpeg_read
+from transformers.utils import logging
+from .modeling_flax_whisper import FlaxWhisperForConditionalGeneration
+logger = logging.get_logger(__name__)
+
+class FlaxWhisperFeatureExtractor(WhisperFeatureExtractor):
+
+    def _np_extract_fbank_features(self, waveform: np.array) -> np.ndarray:
+        waveform = torch.from_numpy(waveform).type(torch.float32)
+        window = torch.hann_window(self.n_fft)
+        stft = torch.stft(waveform, self.n_fft, self.hop_length, window=window, return_complex=True)
+        magnitudes = stft[..., :-1].abs() ** 2
+        mel_filters = torch.from_numpy(self.mel_filters).type(torch.float32)
+        mel_spec = mel_filters.T @ magnitudes
+        log_spec = torch.clamp(mel_spec, min=1e-10).log10()
+        log_spec = torch.maximum(log_spec, log_spec.max() - 8.0)
+        log_spec = (log_spec + 4.0) / 4.0
+        return log_spec.numpy()
+
+class FlaxWhisperPipeline:
+
+    def __init__(self, checkpoint='openai/whisper-large-v2', dtype=jnp.float32, batch_size=None, max_length=None, **kwargs):
+        self.checkpoint = checkpoint
+        self.dtype = dtype
+        self.feature_extractor = FlaxWhisperFeatureExtractor.from_pretrained(self.checkpoint)
+        self.tokenizer = WhisperTokenizerFast.from_pretrained(self.checkpoint)
+        (self.model, self.params) = FlaxWhisperForConditionalGeneration.from_pretrained(self.checkpoint, _do_init=False, dtype=self.dtype, **kwargs)
+        self.max_length = max_length if max_length is not None else self.model.generation_config.max_length
+        self.min_batch_size = jax.local_device_count()
+        self.batch_size = batch_size if batch_size is not None else self.min_batch_size
+
+        def generate(params, input_features, forced_decoder_ids, return_timestamps, num_beams, length_penalty, do_sample, top_k, temperature):
+            output_ids = self.model.pipeline_generate(input_features, params=params, forced_decoder_ids=forced_decoder_ids, return_timestamps=return_timestamps, max_length=self.max_length, num_beams=num_beams, length_penalty=length_penalty, do_sample=do_sample, top_k=top_k, temperature=temperature)
+            return output_ids
+        self.params = jax_utils.replicate(self.params)
+        self.p_generate = jax.pmap(generate, 'input_features', in_axes=(0, 0, None, None, None, None, None, None, None), static_broadcasted_argnums=(3, 4, 5, 6, 7, 8))
+
+    def generate(self, input_features, language=None, task=None, return_timestamps=False, num_beams=1, length_penalty=1.0, do_sample=False, top_k=50, temperature=1.0):
+        forced_decoder_ids = self.get_forced_decoder_ids(language=language, task=task, return_timestamps=return_timestamps)
+        output_ids = self.p_generate(freeze(self.params), shard(input_features), forced_decoder_ids, return_timestamps, num_beams, length_penalty, do_sample, top_k, temperature).sequences
+        output_ids = jax.device_get(output_ids.reshape(-1, self.max_length))
+        return output_ids
+
+    def get_forced_decoder_ids(self, generation_config=None, task=None, language=None, return_timestamps=False):
+        if generation_config is None:
+            generation_config = self.model.generation_config
+        if hasattr(generation_config, 'is_multilingual'):
+            is_multilingual = generation_config.is_multilingual
+        else:
+            is_multilingual = None
+        forced_decoder_ids = []
+        if is_multilingual:
+            if language is not None:
+                language = language.lower()
+                if language in generation_config.lang_to_id.keys():
+                    language_token = language
+                elif language in TO_LANGUAGE_CODE.values():
+                    language_token = f'<|{language}|>'
+                elif language in TO_LANGUAGE_CODE.keys():
+                    language_token = f'<|{TO_LANGUAGE_CODE[language]}|>'
+                else:
+                    if len(language) == 2:
+                        acceptable_languages = list(TO_LANGUAGE_CODE.values())
+                    elif '<' in language or '|' in language or '>' in language:
+                        acceptable_languages = list(generation_config.lang_to_id.keys())
+                    else:
+                        acceptable_languages = list(TO_LANGUAGE_CODE.keys())
+                    raise ValueError(f'Unsupported language: {language}. Language should be one of: {acceptable_languages}.')
+                forced_decoder_ids.append((1, generation_config.lang_to_id[language_token]))
+            if task is not None:
+                forced_decoder_ids.append((2, generation_config.task_to_id[task]))
+            else:
+                forced_decoder_ids.append((2, generation_config.task_to_id['transcribe']))
+        if not return_timestamps:
+            if forced_decoder_ids and forced_decoder_ids[-1][0] != generation_config.no_timestamps_token_id:
+                idx = forced_decoder_ids[-1][0] + 1 if forced_decoder_ids else 1
+                forced_decoder_ids.append((idx, generation_config.no_timestamps_token_id))
+            else:
+                forced_decoder_ids.append((1, generation_config.no_timestamps_token_id))
+        return forced_decoder_ids
+
+    def chunk_iter_with_batch(self, inputs, chunk_len, stride_left, stride_right, batch_size):
+        inputs_len = inputs.shape[0]
+        step = chunk_len - stride_left - stride_right
+        all_chunk_start_idx = np.arange(0, inputs_len, step)
+        num_samples = len(all_chunk_start_idx)
+        num_batches = math.ceil(num_samples / batch_size)
+        batch_idx = np.array_split(np.arange(num_samples), num_batches)
+        for idx in batch_idx:
+            chunk_start_idx = all_chunk_start_idx[idx]
+            chunk_end_idx = chunk_start_idx + chunk_len
+            chunks = [inputs[chunk_start:chunk_end] for (chunk_start, chunk_end) in zip(chunk_start_idx, chunk_end_idx)]
+            processed = self.feature_extractor(chunks, sampling_rate=self.feature_extractor.sampling_rate, return_tensors='np')
+            _stride_left = np.where(chunk_start_idx == 0, 0, stride_left)
+            is_last = np.where(stride_right > 0, chunk_end_idx > inputs_len, chunk_end_idx >= inputs_len)
+            _stride_right = np.where(is_last, 0, stride_right)
+            chunk_lens = [chunk.shape[0] for chunk in chunks]
+            strides = [(chunk_l, _stride_l, _stride_r) for (chunk_l, _stride_l, _stride_r) in zip(chunk_lens, _stride_left, _stride_right)]
+            yield {'stride': strides, **processed}
+
+    def preprocess_batch(self, inputs, chunk_length_s=30.0, stride_length_s=None, batch_size=None):
+        if isinstance(inputs, np.ndarray):
+            logger.warning("Numpy array passed as input - no sampling rate checks will be performed.It is strongly recommended to pass the input as a dictionary with an 'array' key containing the numpy array representing the audio, and a 'sampling_rate' key containing the sampling rate associated with the audio array.Failing to do so can result in silent errors that might be hard to debug.")
+        if isinstance(inputs, str):
+            if inputs.startswith('http://') or inputs.startswith('https://'):
+                inputs = requests.get(inputs).content
+            else:
+                with open(inputs, 'rb') as f:
+                    inputs = f.read()
+        if isinstance(inputs, bytes):
+            inputs = ffmpeg_read(inputs, self.feature_extractor.sampling_rate)
+        stride = None
+        if isinstance(inputs, dict):
+            stride = inputs.get('stride', None)
+            if not ('sampling_rate' in inputs and 'array' in inputs):
+                raise ValueError("When passing a dictionary to FlaxWhisperPipline, the dict needs to contain an 'array' key containing the numpy array representing the audio, and a 'sampling_rate' key containing the sampling rate associated with the audio array.")
+            in_sampling_rate = inputs.get('sampling_rate')
+            inputs = inputs.get('array', None)
+            if in_sampling_rate != self.feature_extractor.sampling_rate:
+                try:
+                    import librosa
+                except ImportError as err:
+                    raise ImportError("To support resampling audio files, please install 'librosa' and 'soundfile'.") from err
+                inputs = librosa.resample(inputs, orig_sr=in_sampling_rate, target_sr=self.feature_extractor.sampling_rate)
+                ratio = self.feature_extractor.sampling_rate / in_sampling_rate
+            else:
+                ratio = 1
+        if not isinstance(inputs, np.ndarray):
+            raise ValueError(f'We expect a numpy ndarray as input, got `{type(inputs)}`')
+        if len(inputs.shape) != 1:
+            raise ValueError('We expect a single channel audio input for AutomaticSpeechRecognitionPipeline')
+        if stride is not None:
+            if stride[0] + stride[1] > inputs.shape[0]:
+                raise ValueError('Stride is too large for input')
+            stride = (inputs.shape[0], int(round(stride[0] * ratio)), int(round(stride[1] * ratio)))
+        if chunk_length_s:
+            if stride_length_s is None:
+                stride_length_s = chunk_length_s / 6
+            if isinstance(stride_length_s, (int, float)):
+                stride_length_s = [stride_length_s, stride_length_s]
+            chunk_len = round(chunk_length_s * self.feature_extractor.sampling_rate)
+            stride_left = round(stride_length_s[0] * self.feature_extractor.sampling_rate)
+            stride_right = round(stride_length_s[1] * self.feature_extractor.sampling_rate)
+            if chunk_len < stride_left + stride_right:
+                raise ValueError('Chunk length must be superior to stride length')
+            for item in self.chunk_iter_with_batch(inputs, chunk_len, stride_left, stride_right, batch_size):
+                yield item
+        else:
+            processed = self.feature_extractor(inputs, sampling_rate=self.feature_extractor.sampling_rate, return_tensors='np')
+            if stride is not None:
+                processed['stride'] = stride
+            yield processed
+
+    def postprocess(self, model_outputs, return_timestamps=None, return_language=None):
+        model_outputs = [dict(zip(output, t)) for output in model_outputs for t in zip(*output.values())]
+        time_precision = self.feature_extractor.chunk_length / self.model.config.max_source_positions
+        sampling_rate = self.feature_extractor.sampling_rate
+        for output in model_outputs:
+            if 'stride' in output:
+                (chunk_len, stride_left, stride_right) = output['stride']
+                chunk_len /= sampling_rate
+                stride_left /= sampling_rate
+                stride_right /= sampling_rate
+                output['stride'] = (chunk_len, stride_left, stride_right)
+        (text, optional) = self.tokenizer._decode_asr(model_outputs, return_timestamps=return_timestamps, return_language=return_language, time_precision=time_precision)
+        return {'text': text, **optional}
+
+    def forward(self, model_inputs, batch_size=None, language=None, task=None, return_timestamps=False, num_beams=1, length_penalty=1.0, do_sample=False, top_k=50, temperature=1.0):
+        input_features = model_inputs.pop('input_features')
+        input_batch_size = input_features.shape[0]
+        if input_batch_size != batch_size:
+            padding = np.zeros([batch_size - input_batch_size, *input_features.shape[1:]], input_features.dtype)
+            input_features = np.concatenate([input_features, padding])
+        pred_ids = self.generate(input_features, language=language, task=task, return_timestamps=return_timestamps, num_beams=num_beams, length_penalty=length_penalty, do_sample=do_sample, top_k=top_k, temperature=temperature)[:input_batch_size]
+        out = {'tokens': pred_ids[:, None, :]}
+        stride = model_inputs.pop('stride', None)
+        if stride is not None:
+            out['stride'] = stride
+        return out
+
+    def __call__(self, inputs, chunk_length_s=30.0, stride_length_s=None, batch_size=None, language=None, task=None, return_timestamps=None, num_beams=1, length_penalty=1.0, do_sample=False, top_k=50, temperature=1.0):
+        batch_size = batch_size if batch_size is not None else self.batch_size
+        if batch_size % self.min_batch_size != 0:
+            raise ValueError(f'Batch size must be a multiple of the number of JAX devices, but got batch size {batch_size} and num devices {self.min_batch_size}.')
+        dataloader = self.preprocess_batch(inputs, chunk_length_s=chunk_length_s, stride_length_s=stride_length_s, batch_size=batch_size)
+        model_outputs = []
+        for batch in dataloader:
+            model_outputs.append(self.forward(batch, batch_size=batch_size, language=language, task=task, return_timestamps=return_timestamps, num_beams=num_beams, length_penalty=length_penalty, do_sample=do_sample, top_k=top_k, temperature=temperature))
+        post_processed = self.postprocess(model_outputs, return_timestamps=return_timestamps)
+        return post_processed
+
+# File: distil-whisper-main/training/flax/distil_whisper/train_state.py
+from typing import Any, Mapping, MutableMapping, Optional, Tuple
+import flax.core
+import flax.serialization
+import flax.struct
+import jax.numpy as jnp
+from flax import traverse_util
+from flax.core import scope as flax_scope
+from flax.linen import partitioning as flax_partitioning
+EMPTY_DICT = flax.core.freeze({})
+FrozenDict = flax_scope.FrozenDict
+FrozenVariableDict = flax_scope.FrozenVariableDict
+MutableVariableDict = flax_scope.MutableVariableDict
+VariableDict = flax_scope.VariableDict
+
+def _validate_params_axes(params_axes, params):
+    axis_names = flax_partitioning.get_axis_names(params_axes)
+    missing_params_axes = set(traverse_util.flatten_dict(params, sep='/')) - set(traverse_util.flatten_dict(axis_names, sep='/'))
+    if missing_params_axes:
+        raise ValueError(f'Missing axis names for parameters: {missing_params_axes}')
+
+def _split_variables_and_axes(variables_and_axes: FrozenVariableDict) -> Tuple[FrozenVariableDict, FrozenVariableDict]:
+    variables = {}
+    axes = {}
+    for (k, v) in variables_and_axes.items():
+        if k.endswith('_axes'):
+            axes[k[:-5]] = v
+            _validate_params_axes(v, variables_and_axes[k[:-5]])
+        else:
+            variables[k] = v
+    return (flax.core.freeze(variables), flax.core.freeze(axes))
+
+class InferenceState(flax.struct.PyTreeNode):
+    step: jnp.ndarray
+    params: flax_scope.FrozenVariableDict
+    params_axes: Optional[flax_scope.FrozenVariableDict] = None
+    flax_mutables: flax_scope.FrozenDict = EMPTY_DICT
+    flax_mutables_axes: Optional[flax_scope.FrozenVariableDict] = None
+
+    @classmethod
+    def create(cls, model_variables: FrozenVariableDict) -> 'InferenceState':
+        (other_variables, params) = model_variables.pop('params')
+        if 'params_axes' in other_variables:
+            (other_variables, params_axes) = other_variables.pop('params_axes')
+            _validate_params_axes(params_axes, params)
+        else:
+            params_axes = None
+        (flax_mutables, flax_mutables_axes) = _split_variables_and_axes(other_variables)
+        flax_mutables_axes = flax_mutables_axes or None
+        return InferenceState(step=jnp.array(0), params=params, params_axes=params_axes, flax_mutables=flax_mutables, flax_mutables_axes=flax_mutables_axes)
+
+    @property
+    def param_states(self) -> FrozenVariableDict:
+        raise NotImplementedError('InferenceState has no optimizer states.')
+
+    def apply_gradient(self, *args, **kwargs) -> 'InferenceState':
+        raise NotImplementedError('InferenceState does not support `apply_gradient`.')
+
+    def state_dict(self) -> MutableMapping[str, Any]:
+        state_dict = {'target': flax.core.unfreeze(self.params), 'state': {'step': self.step}}
+        if self.flax_mutables:
+            state_dict['flax_mutables'] = flax.core.unfreeze(self.flax_mutables)
+        return state_dict
+
+    def replace_step(self, step: jnp.ndarray) -> 'InferenceState':
+        return self.replace(step=step)
+
+    def replace_params(self, params: FrozenVariableDict) -> 'InferenceState':
+        return self.replace(params=params)
+
+    def replace_flax_mutables(self, flax_mutables: FrozenDict) -> 'InferenceState':
+        return self.replace(flax_mutables=flax_mutables)
+
+    def restore_state(self, state_dict: Mapping[str, Any]) -> 'InferenceState':
+        return self.replace(params=flax.core.freeze(state_dict['target']), step=state_dict['state']['step'], flax_mutables=flax.core.freeze(state_dict['flax_mutables']) if 'flax_mutables' in state_dict else EMPTY_DICT)
+
+    def as_logical_axes(self) -> 'InferenceState':
+        flax_mutables_axes = self.flax_mutables_axes or EMPTY_DICT
+        return InferenceState(step=None, params=flax_partitioning.get_axis_names(self.params_axes), flax_mutables=flax_partitioning.get_axis_names(flax_mutables_axes))
+
+# File: distil-whisper-main/training/flax/run_distillation.py
+""""""
+import logging
+import os
+import re
+import shutil
+import string
+import sys
+import time
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Union
+import datasets
+import evaluate
+import flax
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import torch
+import transformers
+from datasets import DatasetDict, IterableDataset, IterableDatasetDict, concatenate_datasets, interleave_datasets, load_dataset
+from flax import jax_utils, traverse_util
+from flax.jax_utils import pad_shard_unpad, unreplicate
+from flax.serialization import from_bytes, to_bytes
+from flax.training import train_state
+from flax.training.common_utils import get_metrics, onehot, shard, shard_prng_key
+from huggingface_hub import Repository, create_repo
+from jax.experimental.compilation_cache import compilation_cache as cc
+from optax._src import linear_algebra
+from torch.utils.data import DataLoader
+from torchdata.datapipes.iter import IterableWrapper
+from tqdm import tqdm
+from transformers import AddedToken, HfArgumentParser, Seq2SeqTrainingArguments, WhisperConfig, WhisperFeatureExtractor, WhisperProcessor, WhisperTokenizerFast, is_tensorboard_available, is_wandb_available, set_seed
+from transformers.file_utils import get_full_repo_name
+from transformers.modeling_flax_outputs import FlaxBaseModelOutput
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+from distil_whisper import FlaxWhisperForConditionalGeneration
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: pip install -r examples/flax/speech-recogintion/requirements.txt')
+logger = logging.getLogger(__name__)
+
+@flax.struct.dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained student model or model identifier from huggingface.co/models'})
+    teacher_model_name_or_path: str = field(metadata={'help': 'Path to pretrained teacher model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    tokenizer_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'})
+    feature_extractor_name: Optional[str] = field(default=None, metadata={'help': 'feature extractor name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    use_auth_token: bool = field(default=False, metadata={'help': 'Will use the token generated when running `transformers-cli login` (necessary to use this script with private models).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'Floating-point format in which the model weights should be initialized and trained. Choose one of `[float32, float16, bfloat16]`.'})
+    load_with_scan_weights: bool = field(default=False, metadata={'help': 'Whether the pre-trained checkpoint has its weights stored in scan format. Set to True for scanned weights, defaults to False for non-scan (unrolled) weights.'})
+    activation_dropout: float = field(default=0.0, metadata={'help': 'The dropout ratio for activations inside the fully connected layer.'})
+    attention_dropout: float = field(default=0.0, metadata={'help': 'The dropout ratio for the attention probabilities.'})
+    dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.'})
+
+@flax.struct.dataclass
+class DataTrainingArguments:
+    train_dataset_name: str = field(default=None, metadata={'help': "The name of the training dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset ids by a '+' symbol. For example, to load and combine  librispeech and common voice, set `train_dataset_name='librispeech_asr+common_voice'`."})
+    train_dataset_config_name: Optional[str] = field(default=None, metadata={'help': "The configuration name of the training dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset configs by a '+' symbol."})
+    train_dataset_samples: str = field(default=None, metadata={'help': "Number of samples in the training data. Load and combine multiple datasets by separating dataset samples by a '+' symbol."})
+    eval_dataset_name: str = field(default=None, metadata={'help': 'The name of the evaluation dataset to use (via the datasets library). Defaults to the training dataset name if unspecified.'})
+    eval_dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the evaluation dataset to use (via the datasets library). Defaults to the training dataset config name if unspecified'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    max_train_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes or quicker training, truncate the number of training examples to this value if set.'})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes or quicker training, truncate the number of evaluation examples to this value if set.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    train_text_column_name: str = field(default='whisper_transcript', metadata={'help': "The name of the dataset column containing the text data. Defaults to 'whisper_transcript'which is the pseudo-labelled Whisper transcription data."})
+    eval_text_column_name: str = field(default='text', metadata={'help': "The name of the dataset column containing the text data. Defaults to 'text', which is the original text data"})
+    max_duration_in_seconds: float = field(default=30.0, metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'})
+    min_duration_in_seconds: float = field(default=0.0, metadata={'help': 'Filter audio files that are shorter than `min_duration_in_seconds` seconds'})
+    max_label_length: int = field(default=128, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    pad_target_to_multiple_of: Optional[int] = field(default=None, metadata={'help': 'If set will pad the target sequence to a multiple of the provided value. This is important to avoid triggering recompilations on TPU. If unspecified, will default to padding the targets to max length.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    train_split_name: str = field(default='train', metadata={'help': "The name of the training data set split to use (via the datasets library). Defaults to 'train'"})
+    eval_split_name: str = field(default='validation', metadata={'help': "The name of the evaluation data set split to use (via the datasets library). Defaults to 'validation'"})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experiment reproducibility and to diff code across experiments in the UI.'})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and the data."})
+    wer_threshold: float = field(default=None, metadata={'help': 'Filter training data with Whisper transcriptions that have greater than `wer_threshold` WER with the normalised transcriptions.'})
+    prefetch_size: int = field(default=0, metadata={'help': 'Number of samples to pre-fetch if using an iterable dataset.'})
+    timestamp_probability: float = field(default=0.5, metadata={'help': 'Probability for training on timestamped tokens if the data contains it.'})
+    return_timestamps: bool = field(default=False, metadata={'help': 'Whether or not to predict timestamps in the generation step.'})
+    round_timestamps: bool = field(default=False, metadata={'help': 'Whether or not to round the timestamp tokens to the nearest tenth of a second.By default, Whisper predicts timestamps to the nearest hundredth of a second.Reducing the timestamp precision to one tenth of a second simplifies the timestampprediction task, at the expense of timestamp granularity.'})
+
+@dataclass
+class FlaxSeq2SeqTrainingArguments(Seq2SeqTrainingArguments):
+    use_scan: Optional[bool] = field(default=True, metadata={'help': 'Whether or not to use `scan_with_axes` over the encoder and decoder blocks. Using scan results in faster compile times and more efficient memory use during training, since all of the layers in the encoder/decoder are stacked, and we perform a lax.scan over the stacked block to index each layer. However, it results in slower inference time due to the overhead of stacking the layers this way. Thus, we **always** default to disabling scan for the inference step.'})
+    freeze_encoder: Optional[bool] = field(default=False, metadata={'help': 'Whether to freeze the entire encoder model. Only recommended when the entire encoder has been copied from the teacher model.'})
+    temperature: Optional[float] = field(default=2.0, metadata={'help': 'Temperature to anneal the logits when computing the softmax.'})
+    kl_weight: Optional[float] = field(default=1.0, metadata={'help': 'Weighting assigned to the MSE loss in the KD formulation. MSE loss is computed between the teacher-student hidden states and attentions.'})
+    mse_weight: Optional[float] = field(default=0.0, metadata={'help': 'Weighting assigned to the MSE loss in the KD formulation. MSE loss is computed between the teacher-student hidden states and attentions.'})
+    precision: Optional[str] = field(default='half_mixed', metadata={'help': 'Precision with which run training, Can be one of `full`, `half_mixed` or `full_mixed`, the latter twoof which enable *mixed-precision* training. **Note that this only specifies the dtype of the computation and optimizer state. It does not influence the dtype of model parameters.** An explanation of the three settings is provided below:   1. Full precision: forward pass, backward pass and optimiser states all in float32.   2. Half mixed precision: forward pass in bfloat16, backward pass and optimiser states in float32. This    corresponds to setting the dtype argument to bfloat16 when instantiating the model.   3. Full mixed precision: forward pass, backward pass and optimiser states all in bfloat16. The dtype    argument is set to bfloat16 for the forward pass, and the gradients computed with respect to the bfloat16    parameters in the backward pass (giving bfloat16 gradients). The new optimiser states and parameter    updates are computed in float32 by upcasting the bfloat16 gradients and optimiser states to float32    prior to the optimiser update step. The optimiser states are returned in float32 (but not saved to    memory) and then downcasted to bfloat16 (saved to memory) for the subsequent train step.For further details, refer to https://github.com/deepmind/optax/discussions/336'})
+    compilation_cache: Optional[bool] = field(default=False, metadata={'help': 'Whether to enable the JAX (experimental) compilation cache. The compilation step is *cached* the first time it is run. Successive compilation steps for the same function utilise the cache to reducethe compilation time.'})
+    save_train_state: Optional[bool] = field(default=False, metadata={'help': 'Whether or not to save the Flax Train State on each `save_steps` steps. Required if you intendto resume training from partial training runs. If False, only the model weights will be saved.If True, both the model weights and Flax Train state will be saved.'})
+
+def shift_tokens_right(label_ids: np.array, decoder_start_token_id: int) -> np.ndarray:
+    shifted_label_ids = np.zeros_like(label_ids)
+    shifted_label_ids[:, 1:] = label_ids[:, :-1]
+    shifted_label_ids[:, 0] = decoder_start_token_id
+    return shifted_label_ids
+
+@flax.struct.dataclass
+class FlaxDataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+    decoder_start_token_id: int
+    decoder_prev_token_id: int
+    input_padding: Union[bool, str] = 'max_length'
+    target_padding: Union[bool, str] = 'max_length'
+    max_target_length: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], np.ndarray]]]) -> Dict[str, np.ndarray]:
+        model_input_name = self.processor.model_input_names[0]
+        input_features = {model_input_name: [feature[model_input_name] for feature in features]}
+        label_features = {'input_ids': [feature['labels'] for feature in features]}
+        batch = self.processor.feature_extractor.pad(input_features, padding=self.input_padding, return_tensors='np')
+        labels_batch = self.processor.tokenizer.pad(label_features, max_length=self.max_target_length, padding=self.target_padding, return_tensors='np')
+        labels = labels_batch['input_ids']
+        if set(np.unique(labels[:, 0])).issubset({self.decoder_start_token_id, self.decoder_prev_token_id}):
+            decoder_input_ids = labels[:, :-1]
+            labels = labels[:, 1:]
+            labels_batch.attention_mask = labels_batch.attention_mask[:, 1:]
+        else:
+            decoder_input_ids = shift_tokens_right(labels, self.decoder_start_token_id)
+        labels = np.ma.array(labels, mask=np.not_equal(labels_batch.attention_mask, 1))
+        labels = labels.filled(fill_value=-100)
+        bos_index = np.argmax(labels == self.decoder_start_token_id, axis=1)
+        prompt_mask = np.arange(labels.shape[1]) < bos_index[:, None]
+        labels = np.where(prompt_mask, -100, labels)
+        batch['labels'] = labels
+        batch['decoder_input_ids'] = decoder_input_ids
+        return batch
+
+def get_data_loader(seed: int, dataset: IterableDataset, batch_size: int, data_collator: FlaxDataCollatorSpeechSeq2SeqWithPadding, shuffle: bool=True, drop_last: bool=True, dataloader_num_workers: int=0, skip_batches: int=0, pin_memory: bool=True, prefetch_size: int=0) -> DataLoader:
+    if shuffle:
+        dataset = dataset.shuffle(seed)
+    if skip_batches > 0:
+        dataset = dataset.skip(skip_batches * batch_size)
+    if prefetch_size > 0:
+        dataset = IterableWrapper(dataset)
+        dataset = dataset.prefetch(prefetch_size)
+    data_loader = DataLoader(dataset, batch_size=batch_size, drop_last=drop_last, pin_memory=pin_memory, collate_fn=data_collator, num_workers=dataloader_num_workers)
+    return data_loader
+
+def sorted_checkpoints(output_dir=None, checkpoint_prefix='checkpoint', use_mtime=False) -> List[str]:
+    ordering_and_checkpoint_path = []
+    glob_checkpoints = [str(x) for x in Path(output_dir).glob(f'{checkpoint_prefix}-*') if os.path.isdir(x)]
+    for path in glob_checkpoints:
+        if use_mtime:
+            ordering_and_checkpoint_path.append((os.path.getmtime(path), path))
+        else:
+            regex_match = re.match(f'.*{checkpoint_prefix}-([0-9]+)', path)
+            if regex_match is not None and regex_match.groups() is not None:
+                ordering_and_checkpoint_path.append((int(regex_match.groups()[0]), path))
+    checkpoints_sorted = sorted(ordering_and_checkpoint_path)
+    checkpoints_sorted = [checkpoint[1] for checkpoint in checkpoints_sorted]
+    return checkpoints_sorted
+
+def rotate_checkpoints(save_total_limit=None, use_mtime=False, output_dir=None, checkpoint_prefix='checkpoint') -> None:
+    if save_total_limit is None or save_total_limit <= 0:
+        return
+    checkpoints_sorted = sorted_checkpoints(use_mtime=use_mtime, output_dir=output_dir, checkpoint_prefix=checkpoint_prefix)
+    if len(checkpoints_sorted) <= save_total_limit:
+        return
+    number_of_checkpoints_to_delete = max(0, len(checkpoints_sorted) - save_total_limit)
+    checkpoints_to_be_deleted = checkpoints_sorted[:number_of_checkpoints_to_delete]
+    for checkpoint in checkpoints_to_be_deleted:
+        logger.info(f'Deleting older checkpoint [{checkpoint}] due to args.save_total_limit')
+        shutil.rmtree(checkpoint, ignore_errors=True)
+
+def to_fp32(t):
+    return jax.tree_map(lambda x: x.astype(jnp.float32) if x.dtype == jnp.bfloat16 else x, t)
+
+def to_bf16(t):
+    return jax.tree_map(lambda x: x.astype(jnp.bfloat16) if x.dtype == jnp.float32 else x, t)
+
+class TrainState(train_state.TrainState):
+    dropout_rng: jnp.ndarray
+    max_grad_norm: float
+
+    def apply_gradients(self, *, grads, to_dtype: to_fp32, **kwargs):
+        casted_max_grad_norm = to_dtype(self.max_grad_norm)
+        g_norm = linear_algebra.global_norm(grads)
+        g_norm = jnp.maximum(casted_max_grad_norm, g_norm)
+        grads = jax.tree_map(lambda t: t / g_norm * casted_max_grad_norm, grads)
+        (updates, new_opt_state) = self.tx.update(to_fp32(grads), to_fp32(self.opt_state), self.params)
+        new_params = optax.apply_updates(self.params, updates)
+        return self.replace(step=self.step + 1, params=new_params, opt_state=to_dtype(new_opt_state), **kwargs)
+
+    @classmethod
+    def create(cls, *, apply_fn, params, tx, to_dtype: to_fp32, **kwargs):
+        opt_state = tx.init(to_dtype(params))
+        return cls(step=0, apply_fn=apply_fn, params=params, tx=tx, opt_state=opt_state, **kwargs)
+
+    def replicate(self):
+        return jax_utils.replicate(self).replace(dropout_rng=shard_prng_key(self.dropout_rng))
+
+    def unreplicate(self):
+        return jax_utils.unreplicate(self)
+
+    def save_state(self, output_dir, save_total_limit=None, checkpoint_prefix='checkpoint'):
+        step = int(jax.device_get(unreplicate(self.step)))
+        serialized_state = to_bytes(self.unreplicate())
+        output_file = Path(os.path.join(output_dir, f'{checkpoint_prefix}-{step}', 'train_state.msgpack'))
+        output_file.parent.mkdir(exist_ok=True, parents=True)
+        with output_file.open('wb') as f:
+            f.write(serialized_state)
+        logger.info(f'Flax train state saved in {output_file}')
+        rotate_checkpoints(save_total_limit=save_total_limit, output_dir=output_dir, checkpoint_prefix=checkpoint_prefix)
+
+def save_hf_weights(student_state: TrainState, student_model: FlaxWhisperForConditionalGeneration, processor: WhisperProcessor, output_dir: str, cur_step: int, total_train_steps: int, use_scan: bool=True, checkpoint_prefix: str='checkpoint') -> None:
+    student_state_params = unreplicate(student_state.params)
+    student_state_params = student_model.convert_scan_to_unroll(student_state_params)
+    student_params = jax.device_get(student_state_params)
+    student_model.disable_scan()
+    if cur_step != total_train_steps:
+        output_dir = os.path.join(output_dir, f'{checkpoint_prefix}-{cur_step}')
+        os.makedirs(output_dir, exist_ok=True)
+    student_model.save_pretrained(output_dir, params=student_params)
+    processor.save_pretrained(output_dir)
+    if use_scan:
+        student_model.enable_scan()
+
+def write_train_metric(summary_writer, train_metrics, train_time, step, logging_steps):
+    summary_writer.scalar('train/time', train_time, step)
+    train_metrics = get_metrics(train_metrics)
+    for (key, vals) in train_metrics.items():
+        steps_arr = np.arange(0, step, logging_steps)[-len(vals):]
+        tag = f'train/{key}'
+        for (i, val) in enumerate(vals):
+            summary_writer.scalar(tag, val, steps_arr[i])
+
+def write_eval_metric(summary_writer, eval_metrics, step, prefix='eval'):
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.scalar(f'{prefix}/{metric_name}', value, step)
+
+def write_wandb_metric(wandb_logger, metrics, train_time, step, epoch, prefix='train'):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    log_metrics[f'{prefix}/epoch'] = epoch
+    wandb_logger.log(log_metrics, step)
+
+def write_wandb_pred(wandb_logger, pred_str, label_str, norm_pred_str, norm_label_str, cur_step, prefix='eval', num_lines=200000):
+    cur_step_pretty = f'{int(cur_step // 1000)}k' if cur_step > 1000 else cur_step
+    str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+    wandb_logger.log({f"predictions/{prefix.replace('/', '-')}-step-{cur_step_pretty}": wandb_logger.Table(columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data[:num_lines])}, cur_step)
+    str_data = np.asarray(str_data)
+    str_data_incorrect = str_data[str_data[:, -2] != str_data[:, -1]]
+    wandb_logger.log({f"incorrect_predictions/{prefix.replace('/', '-')}-step-{cur_step_pretty}": wandb_logger.Table(columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data_incorrect[:num_lines])}, cur_step)
+
+def create_learning_rate_fn(num_train_steps: int, lr_scheduler_type: str, num_warmup_steps: int, learning_rate: float) -> Callable[[int], jnp.array]:
+    lr_scheduler_types = ('linear', 'constant_with_warmup')
+    if lr_scheduler_type not in lr_scheduler_types:
+        raise ValueError(f'lr_scheduler_type of type {lr_scheduler_type} not supported, choose from {lr_scheduler_types}.')
+    warmup_fn = optax.linear_schedule(init_value=0.0, end_value=learning_rate, transition_steps=num_warmup_steps)
+    decay_fn = optax.linear_schedule(init_value=learning_rate, end_value=0 if lr_scheduler_type == 'linear' else learning_rate, transition_steps=num_train_steps - num_warmup_steps)
+    schedule_fn = optax.join_schedules(schedules=[warmup_fn, decay_fn], boundaries=[num_warmup_steps])
+    return schedule_fn
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_samples=None, default_split='train'):
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        for i in range(len(dataset_names)):
+            ds_name = dataset_names[i]
+            dataset_names[i] = f'distil-whisper/{ds_name}' if '/' not in ds_name else ds_name
+        dataset_config_names = dataset_config_names.split('+')
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_samples = dataset_samples.split('+') if dataset_samples is not None else None
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_samples is not None:
+        if len(dataset_samples) != len(dataset_names):
+            raise ValueError(f'Ensure one sample is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_samples)} samples.')
+        dataset_samples = [float(ds_sample) for ds_sample in dataset_samples]
+    else:
+        dataset_samples = [None] * len(dataset_names)
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'samples': dataset_samples[i]})
+    return dataset_names_dict
+
+def load_multiple_datasets(dataset_names: Union[List, str], dataset_config_names: Union[List, str], splits: Optional[Union[List, str]]=None, text_column_names: Optional[List]=None, sampling_rate: Optional[int]=16000, stopping_strategy: Optional[str]='first_exhausted', dataset_samples: Optional[Union[List, np.array]]=None, streaming: bool=True, seed: int=None, **kwargs) -> IterableDataset:
+    dataset_names_dict = convert_dataset_str_to_list(dataset_names, dataset_config_names, splits, text_column_names, dataset_samples)
+    if dataset_samples is not None:
+        dataset_samples = [ds_dict['samples'] for ds_dict in dataset_names_dict]
+        probabilities = np.array(dataset_samples) / np.sum(dataset_samples)
+    else:
+        probabilities = None
+    if len(dataset_names_dict) == 1:
+        dataset_dict = dataset_names_dict[0]
+        return load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], streaming=streaming, **kwargs)
+    all_datasets = []
+    for dataset_dict in tqdm(dataset_names_dict, desc='Combining datasets...'):
+        dataset = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], streaming=streaming, **kwargs)
+        dataset = dataset.cast_column('audio', datasets.features.Audio(sampling_rate))
+        dataset = dataset.remove_columns(set(dataset.features.keys()) - {'audio', dataset_dict['text_column_name'], 'whisper_transcript'})
+        all_datasets.append(dataset)
+    if streaming:
+        interleaved_dataset = interleave_datasets(all_datasets, stopping_strategy=stopping_strategy, probabilities=probabilities, seed=seed)
+    else:
+        interleaved_dataset = concatenate_datasets(all_datasets)
+    return interleaved_dataset
+
+def get_layers_to_supervise(student_layers: int, teacher_layers: int) -> dict:
+    layer_intervals = np.linspace(teacher_layers // student_layers - 1, teacher_layers - 1, student_layers, dtype=int)
+    layer_intervals[-1] = teacher_layers - 1
+    layer_map = {}
+    for (student_layer, teacher_layer) in enumerate(layer_intervals):
+        layer_map[student_layer] = teacher_layer
+    return layer_map
+
+class FlaxWhisperFeatureExtractor(WhisperFeatureExtractor):
+
+    def _np_extract_fbank_features(self, waveform: np.array) -> np.ndarray:
+        waveform = torch.from_numpy(waveform).type(torch.float32)
+        window = torch.hann_window(self.n_fft)
+        stft = torch.stft(waveform, self.n_fft, self.hop_length, window=window, return_complex=True)
+        magnitudes = stft[..., :-1].abs() ** 2
+        mel_filters = torch.from_numpy(self.mel_filters).type(torch.float32)
+        mel_spec = mel_filters.T @ magnitudes
+        log_spec = torch.clamp(mel_spec, min=1e-10).log10()
+        log_spec = torch.maximum(log_spec, log_spec.max() - 8.0)
+        log_spec = (log_spec + 4.0) / 4.0
+        return log_spec.numpy()
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, FlaxSeq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    send_example_telemetry('run_flax_speech_recognition_seq2seq', model_args, data_args, framework='flax')
+    has_tensorboard = is_tensorboard_available()
+    if has_tensorboard:
+        if jax.process_index() == 0:
+            try:
+                from flax.metrics.tensorboard import SummaryWriter
+                summary_writer = SummaryWriter(log_dir=os.path.join(Path(training_args.output_dir), 'runs'))
+            except ImportError as ie:
+                has_tensorboard = False
+                logger.warning(f'Unable to display metrics through TensorBoard because some package are not installed: {ie}')
+    else:
+        logger.warning('Unable to display metrics through TensorBoard because the package is not installed: Please run `pip install tensorboard` to enable.')
+    has_wandb = is_wandb_available()
+    if has_wandb:
+        import wandb as wandb_logger
+        if jax.process_index() == 0:
+            wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb)
+    else:
+        logger.warning('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    logger.setLevel(logging.INFO if jax.process_index() == 0 else logging.ERROR)
+    if jax.process_index() == 0:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Training/evaluation parameters %s', training_args)
+    if os.path.exists(training_args.output_dir) and os.listdir(training_args.output_dir) and training_args.do_train and (not training_args.overwrite_output_dir):
+        raise ValueError(f'Output directory ({training_args.output_dir}) already exists and is not empty. Use `--overwrite_output_dir` to overcome.')
+    if training_args.push_to_hub:
+        if training_args.hub_model_id is None:
+            repo_name = get_full_repo_name(Path(training_args.output_dir).absolute().name, token=training_args.hub_token)
+        else:
+            repo_name = training_args.hub_model_id
+        create_repo(repo_name, exist_ok=True, token=training_args.hub_token)
+        repo = Repository(training_args.output_dir, clone_from=repo_name, token=training_args.hub_token)
+    if training_args.compilation_cache:
+        cc.initialize_cache(os.path.join(model_args.cache_dir, 'jax_cache'))
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    set_seed(training_args.seed)
+    if training_args.do_train:
+        raw_datasets['train'] = load_multiple_datasets(data_args.train_dataset_name, data_args.train_dataset_config_name, splits=data_args.train_split_name, streaming=data_args.streaming, dataset_samples=data_args.train_dataset_samples, seed=training_args.seed, cache_dir=data_args.dataset_cache_dir, token=True if model_args.use_auth_token else None)
+    if training_args.do_eval:
+        dataset_names_dict = convert_dataset_str_to_list(data_args.eval_dataset_name if data_args.eval_dataset_name else data_args.train_dataset_name, data_args.eval_dataset_config_name if data_args.eval_dataset_config_name else data_args.train_dataset_config_name, splits=data_args.eval_split_name, text_column_names=data_args.eval_text_column_name)
+        all_eval_splits = []
+        if len(dataset_names_dict) == 1:
+            dataset_dict = dataset_names_dict[0]
+            all_eval_splits.append('eval')
+            raw_datasets['eval'] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, token=True if model_args.use_auth_token else None, streaming=data_args.streaming)
+        else:
+            for dataset_dict in dataset_names_dict:
+                if dataset_dict['name'] == 'esb/diagnostic-dataset':
+                    pretty_name = f"{dataset_dict['config']}-diagnostic/{dataset_dict['split']}"
+                else:
+                    pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+                all_eval_splits.append(pretty_name)
+                raw_datasets[pretty_name] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, token=True if model_args.use_auth_token else None, streaming=data_args.streaming)
+                features = raw_datasets[pretty_name].features.keys()
+                if 'text' not in features:
+                    raw_datasets[pretty_name] = raw_datasets[pretty_name].rename_column(dataset_dict['text_column_name'], 'text')
+                raw_datasets[pretty_name] = raw_datasets[pretty_name].remove_columns(set(raw_datasets[pretty_name].features.keys()) - {'audio', 'text'})
+    if not training_args.do_train and (not training_args.do_eval):
+        raise ValueError('Cannot not train and not do evaluation. At least one of training or evaluation has to be performed.')
+    raw_datasets_train_features = list(raw_datasets['train'].features.keys())
+    if data_args.audio_column_name not in raw_datasets_train_features:
+        raise ValueError(f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. Make sure to set `--audio_column_name` to the correct audio column - one of {', '.join(raw_datasets_train_features)}.")
+    if data_args.train_text_column_name not in raw_datasets_train_features:
+        raise ValueError(f"--train_text_column_name {data_args.train_text_column_name} not found in dataset '{data_args.dataset_name}'. Make sure to set `--train_text_column_name` to the correct text column - one of {', '.join(raw_datasets_train_features)}.")
+    config = WhisperConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=True if model_args.use_auth_token else None)
+    feature_extractor = FlaxWhisperFeatureExtractor.from_pretrained(model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=True if model_args.use_auth_token else None)
+    tokenizer = WhisperTokenizerFast.from_pretrained(model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_fast=model_args.use_fast_tokenizer, revision=model_args.model_revision, token=True if model_args.use_auth_token else None)
+    timestamps = [AddedToken('<|%.2f|>' % (i * 0.02), lstrip=False, rstrip=False) for i in range(1500 + 1)]
+    tokenizer.add_tokens(timestamps)
+    config.update({'activation_dropout': model_args.activation_dropout, 'attention_dropout': model_args.attention_dropout, 'dropout': model_args.dropout})
+    if training_args.precision == 'full_mixed':
+        dtype = jnp.bfloat16
+        to_dtype = to_bf16
+    elif training_args.precision == 'half_mixed' or model_args.dtype == 'bfloat16':
+        dtype = jnp.bfloat16
+        to_dtype = to_fp32
+    else:
+        if training_args.precision != 'full':
+            raise ValueError(f'`precision` should be one of: `full`, `half_mixed` or `full_mixed`, got {training_args.precision}')
+        dtype = jnp.float32
+        to_dtype = to_fp32
+    (student_model, student_params) = FlaxWhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, dtype=dtype, cache_dir=model_args.cache_dir, revision=model_args.model_revision, subfolder=model_args.subfolder, token=True if model_args.use_auth_token else None, _do_init=False, use_scan=model_args.load_with_scan_weights)
+    (teacher_model, teacher_params) = FlaxWhisperForConditionalGeneration.from_pretrained(model_args.teacher_model_name_or_path, dtype=dtype, cache_dir=model_args.cache_dir, token=True if model_args.use_auth_token else None, _do_init=False)
+    if student_model.config.decoder_start_token_id is None or teacher_model.config.decoder_start_token_id is None:
+        raise ValueError(f'Make sure that `config.decoder_start_token_id` is correctly defined for both the student and teacher model. Got {student_model.config.decoder_start_token_id} for the student and {teacher_model.config.decoder_start_token_id} for the teacher.')
+    if training_args.use_scan:
+        student_model.enable_scan()
+        student_params = student_model.convert_unroll_to_scan(student_params)
+        teacher_model.enable_scan()
+        teacher_params = teacher_model.convert_unroll_to_scan(teacher_params)
+    if training_args.gradient_checkpointing:
+        student_model.enable_gradient_checkpointing()
+        teacher_model.enable_gradient_checkpointing()
+    if hasattr(teacher_model.generation_config, 'is_multilingual') and teacher_model.generation_config.is_multilingual:
+        tokenizer.set_prefix_tokens(language='English', task='transcribe', predict_timestamps=False)
+        student_model.generation_config.update(**{'language': '<|en|>', 'task': 'transcribe'})
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate))
+    max_input_length = int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate)
+    min_input_length = int(data_args.min_duration_in_seconds * feature_extractor.sampling_rate)
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else student_model.config.max_length
+    audio_column_name = data_args.audio_column_name
+    num_workers = data_args.preprocessing_num_workers
+    dataloader_num_workers = training_args.dataloader_num_workers
+    dataloader_prefetch_size = data_args.prefetch_size
+    train_text_column_name = data_args.train_text_column_name
+    eval_text_column_name = 'text'
+    model_input_name = feature_extractor.model_input_names[0]
+    normalizer = EnglishTextNormalizer(tokenizer.english_spelling_normalizer)
+    wer_threshold = data_args.wer_threshold
+    round_timestamps = data_args.round_timestamps
+    if training_args.do_train and data_args.max_train_samples is not None:
+        raw_datasets['train'] = raw_datasets['train'].take(data_args.max_train_samples) if data_args.streaming else raw_datasets['train'].select(range(data_args.max_train_samples))
+    if training_args.do_eval and data_args.max_eval_samples is not None:
+        for eval_split in all_eval_splits:
+            raw_datasets[eval_split] = raw_datasets[eval_split].take(data_args.max_eval_samples) if data_args.streaming else raw_datasets[eval_split].select(range(data_args.max_eval_samples))
+
+    def is_wer_in_range(ground_truth, whisper_transcript):
+        norm_ground_truth = normalizer(ground_truth)
+        if len(norm_ground_truth) > 0 and whisper_transcript is not None:
+            norm_whisper_transcript = normalizer(whisper_transcript)
+            wer = 100 * metric.compute(predictions=[norm_whisper_transcript], references=[norm_ground_truth])
+            return wer < wer_threshold
+        else:
+            return False
+    filter_by_wer_threshold = partial(raw_datasets['train'].filter, function=is_wer_in_range, input_columns=[eval_text_column_name, train_text_column_name])
+    if wer_threshold is not None:
+        raw_datasets['train'] = filter_by_wer_threshold(num_proc=num_workers, desc='filtering train dataset by wer') if not data_args.streaming else filter_by_wer_threshold()
+
+    def has_timestamp_tokens(input_str):
+        return bool(re.search('\\<[^\\>]*\\>', input_str))
+
+    def round_timestamp_tokens(input_str: str, ndigits: int=1):
+        timestamps = re.findall('\\<[^\\>]*\\>', input_str, re.DOTALL)
+        for token in timestamps:
+            time_digit = token[2:-2]
+            time_digit = round(float(time_digit), ndigits=ndigits)
+            input_str = input_str.replace(token, '<|{:.2f}|>'.format(time_digit))
+        return input_str
+
+    def prepare_train_dataset(batch):
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch['input_length'] = len(sample['array'])
+        input_str = batch[train_text_column_name]
+        if input_str.startswith('<|startoftranscript|>') or input_str.startswith('<|startofprev|>'):
+            batch['labels'] = tokenizer(input_str, add_special_tokens=False).input_ids
+            return batch
+        has_timestamps = has_timestamp_tokens(input_str)
+        if has_timestamps:
+            predict_timestamps = bool(np.random.binomial(1, data_args.timestamp_probability))
+            if not predict_timestamps:
+                input_str = tokenizer._filter_timestamp_ids(input_str)
+            elif round_timestamps:
+                input_str = round_timestamp_tokens(input_str)
+        else:
+            predict_timestamps = False
+        tokenizer.set_prefix_tokens(language='English', task='transcribe', predict_timestamps=predict_timestamps)
+        input_ids = tokenizer(input_str).input_ids
+        batch['labels'] = input_ids
+        return batch
+
+    def prepare_eval_dataset(batch):
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch['input_length'] = len(sample['array'])
+        input_str = batch[eval_text_column_name]
+        batch['labels'] = tokenizer(input_str).input_ids
+        return batch
+    vectorized_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    if training_args.do_train:
+        map_fn_train = partial(raw_datasets['train'].map, function=prepare_train_dataset, remove_columns=raw_datasets_train_features)
+        vectorized_datasets['train'] = map_fn_train(num_proc=num_workers, desc='preprocess train dataset') if not data_args.streaming else map_fn_train()
+    if training_args.do_eval:
+        for eval_split in all_eval_splits:
+            raw_datasets_eval_features = list(raw_datasets[eval_split].features.keys())
+            map_fn_eval = partial(raw_datasets[eval_split].map, function=prepare_eval_dataset, remove_columns=raw_datasets_eval_features)
+            vectorized_datasets[eval_split] = map_fn_eval(num_proc=num_workers, desc='preprocess eval dataset') if not data_args.streaming else map_fn_eval()
+
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+    filter_by_audio_fn = partial(vectorized_datasets.filter, function=is_audio_in_length_range, input_columns=['input_length'])
+    vectorized_datasets = filter_by_audio_fn(num_proc=num_workers, desc='filtering train dataset by audio length') if not data_args.streaming else filter_by_audio_fn()
+
+    def is_labels_in_length_range(labels):
+        return 0 < len(labels) < max_label_length
+    filter_by_labels_fn = partial(vectorized_datasets.filter, function=is_labels_in_length_range, input_columns=['labels'])
+    vectorized_datasets = filter_by_labels_fn(num_proc=num_workers, desc='filtering train dataset') if not data_args.streaming else filter_by_labels_fn()
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    metric = evaluate.load('wer')
+    all_punctuation = list(string.punctuation.replace("'", ''))
+    return_timestamps = data_args.return_timestamps if data_args.timestamp_probability > 0 else False
+
+    def compute_metrics(preds, labels):
+        for idx in range(len(labels)):
+            labels[idx][labels[idx] == -100] = tokenizer.pad_token_id
+        pred_str = tokenizer.batch_decode(preds, skip_special_tokens=True, decode_with_timestamps=return_timestamps)
+        label_str = tokenizer.batch_decode(labels, skip_special_tokens=True)
+        spaced_pred_str = [pred_str[i].replace(punctuation, f' {punctuation} ') for punctuation in all_punctuation for i in range(len(pred_str))]
+        spaced_label_str = [label_str[i].replace(punctuation, f' {punctuation} ') for punctuation in all_punctuation for i in range(len(label_str))]
+        wer_ortho = 100 * metric.compute(predictions=spaced_pred_str, references=spaced_label_str)
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return ({'wer': wer, 'wer_ortho': wer_ortho}, pred_str, label_str, norm_pred_str, norm_label_str)
+    feature_extractor.save_pretrained(training_args.output_dir)
+    tokenizer.save_pretrained(training_args.output_dir)
+    config.save_pretrained(training_args.output_dir)
+    student_model.generation_config.save_pretrained(training_args.output_dir)
+    processor = WhisperProcessor.from_pretrained(training_args.output_dir)
+    data_collator = FlaxDataCollatorSpeechSeq2SeqWithPadding(processor=processor, decoder_start_token_id=student_model.config.decoder_start_token_id, decoder_prev_token_id=tokenizer.all_special_ids[-3], input_padding='longest', target_padding='max_length', max_target_length=max_label_length)
+    rng = jax.random.PRNGKey(training_args.seed)
+    (rng, dropout_rng) = jax.random.split(rng)
+    train_batch_size = int(training_args.per_device_train_batch_size) * jax.device_count()
+    gradient_accumulation_steps = int(training_args.gradient_accumulation_steps)
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    eval_batch_size = per_device_eval_batch_size * jax.device_count()
+    if not data_args.streaming and training_args.max_steps < 0:
+        num_epochs = int(training_args.num_train_epochs)
+        steps_per_epoch = len(vectorized_datasets['train']) // train_batch_size
+        total_train_steps = steps_per_epoch * num_epochs
+    elif training_args.max_steps > 0:
+        logger.info('max_steps is given, it will override any value given in num_train_epochs')
+        total_train_steps = int(training_args.max_steps)
+        num_epochs = sys.maxsize
+        steps_per_epoch = total_train_steps
+    else:
+        raise ValueError('max_steps must be specified when training with a streaming (iterable) dataset')
+    if training_args.eval_steps is None:
+        logger.info(f"eval_steps is not set, evaluating at the end of {('each epoch' if not data_args.streaming else 'training')}")
+        eval_steps = steps_per_epoch
+    else:
+        eval_steps = training_args.eval_steps
+    linear_decay_lr_schedule_fn = create_learning_rate_fn(total_train_steps * gradient_accumulation_steps, training_args.lr_scheduler_type, training_args.warmup_steps * gradient_accumulation_steps, training_args.learning_rate)
+
+    def decay_mask_fn(params):
+        flat_params = traverse_util.flatten_dict(params)
+        layer_norm_candidates = ['layer_norm', 'self_attn_layer_norm', 'final_layer_norm', 'encoder_attn_layer_norm']
+        layer_norm_named_params = {layer[-2:] for layer_norm_name in layer_norm_candidates for layer in flat_params.keys() if layer_norm_name in ''.join(layer).lower()}
+        flat_mask = {path: path[-1] != 'bias' and path[-2:] not in layer_norm_named_params for path in flat_params}
+        return traverse_util.unflatten_dict(flat_mask)
+    adamw = optax.adamw(learning_rate=linear_decay_lr_schedule_fn, b1=training_args.adam_beta1, b2=training_args.adam_beta2, eps=training_args.adam_epsilon, weight_decay=training_args.weight_decay, mask=decay_mask_fn)
+    if gradient_accumulation_steps > 1:
+        adamw = optax.MultiSteps(adamw, every_k_schedule=gradient_accumulation_steps)
+    share_hidden_states = training_args.freeze_encoder and student_model.config.d_model == teacher_model.config.d_model
+    encoder_layer_mapping = get_layers_to_supervise(student_model.config.encoder_layers, teacher_model.config.encoder_layers)
+    decoder_layer_mapping = get_layers_to_supervise(student_model.config.decoder_layers, teacher_model.config.decoder_layers)
+    student_state = TrainState.create(apply_fn=student_model.decode if share_hidden_states else student_model.__call__, params=student_params, tx=adamw, to_dtype=to_dtype, dropout_rng=dropout_rng, max_grad_norm=training_args.max_grad_norm)
+    if training_args.resume_from_checkpoint is not None:
+        if os.path.isfile(os.path.join(training_args.resume_from_checkpoint, 'train_state.msgpack')):
+            logger.info(f'Checkpoint detected, resuming training at {training_args.resume_from_checkpoint}. To avoid this behavior, omit the resume_from_checkpoint argument.')
+            with Path(os.path.join(training_args.resume_from_checkpoint, 'train_state.msgpack')).open('rb') as f:
+                student_state = from_bytes(student_state, f.read())
+        else:
+            logger.warning(f'Checkpoint {training_args.resume_from_checkpoint} not detected, training from scratch. Ensure you pass the path to a folder with a valid checkpoint for your model.')
+
+    def cross_entropy_loss(logits, labels):
+        vocab_size = logits.shape[-1]
+        onehot_targets = to_dtype(onehot(labels, vocab_size))
+        loss = optax.softmax_cross_entropy(logits, onehot_targets)
+        padding = labels >= 0
+        loss = loss * padding
+        loss = loss.sum()
+        num_labels = padding.sum()
+        return (loss, num_labels)
+
+    def kl_divergence(target_distribution, log_predicted_distribution, labels, eps=1e-20):
+        divergence = -target_distribution * (log_predicted_distribution - jnp.log(target_distribution + eps))
+        padding_mask = labels >= 0
+        padding_mask = jnp.expand_dims(padding_mask, axis=-1)
+        divergence = (divergence * padding_mask).sum()
+        return to_dtype(divergence)
+
+    def mean_square_error_loss(student_outputs, teacher_outputs):
+        mse = dtype(0.0)
+        mse += jnp.mean(jnp.square(teacher_outputs.encoder_hidden_states[0] - student_outputs.encoder_hidden_states[0]))
+        for (student_layer_id, teacher_layer_id) in encoder_layer_mapping.items():
+            student_hidden_state = student_outputs.encoder_hidden_states[student_layer_id + 1]
+            teacher_hidden_state = teacher_outputs.encoder_hidden_states[teacher_layer_id + 1]
+            mse += jnp.mean(jnp.square(teacher_hidden_state - student_hidden_state))
+        mse += jnp.mean(jnp.square(teacher_outputs.decoder_hidden_states[0] - student_outputs.decoder_hidden_states[0]))
+        for (student_layer_id, teacher_layer_id) in decoder_layer_mapping.items():
+            student_hidden_state = student_outputs.decoder_hidden_states[student_layer_id + 1]
+            teacher_hidden_state = teacher_outputs.decoder_hidden_states[teacher_layer_id + 1]
+            mse += jnp.mean(jnp.square(teacher_hidden_state - student_hidden_state))
+        return to_dtype(mse)
+
+    def train_step(student_state, teacher_params, batch, freeze_encoder, share_hidden_states, temperature=2.0):
+        (dropout_rng, new_dropout_rng) = jax.random.split(student_state.dropout_rng)
+
+        def compute_loss(student_params):
+            labels = batch.pop('labels')
+            output_hidden_states = not share_hidden_states and training_args.mse_weight > 0.0
+            teacher_outputs = teacher_model(**batch, params=teacher_params, freeze_encoder=True, output_hidden_states=output_hidden_states, train=False)
+            if share_hidden_states:
+                encoder_hidden_states = jax.lax.stop_gradient(teacher_outputs.encoder_last_hidden_state)
+                encoder_outputs = FlaxBaseModelOutput(last_hidden_state=encoder_hidden_states)
+                student_outputs = student_state.apply_fn(decoder_input_ids=batch['decoder_input_ids'], encoder_outputs=encoder_outputs, params=student_params, dropout_rng=dropout_rng, train=True)
+            else:
+                student_outputs = student_state.apply_fn(**batch, params=student_params, dropout_rng=dropout_rng, freeze_encoder=freeze_encoder, output_hidden_states=output_hidden_states, train=True)
+            (ce_loss, num_labels) = cross_entropy_loss(student_outputs.logits, labels)
+            teacher_distribution = jax.nn.softmax(teacher_outputs.logits / temperature, axis=-1)
+            teacher_distribution = jax.lax.stop_gradient(teacher_distribution)
+            student_distribution = jax.nn.log_softmax(student_outputs.logits / temperature, axis=-1)
+            kl_loss = kl_divergence(teacher_distribution, student_distribution, labels) * temperature ** 2
+            mse_loss = mean_square_error_loss(student_outputs, teacher_outputs) if output_hidden_states else jnp.zeros_like(kl_loss)
+            ce_weight = 0.8 if training_args.kl_weight > 0 else 1.0
+            loss = ce_weight * ce_loss + training_args.kl_weight * kl_loss + training_args.mse_weight * mse_loss
+            return (loss, (ce_loss, kl_loss, mse_loss, num_labels))
+        grad_fn = jax.value_and_grad(compute_loss, has_aux=True)
+        ((loss, (ce_loss, kl_loss, mse_loss, num_labels)), grad) = grad_fn(to_dtype(student_state.params))
+        loss = jax.lax.psum(loss, 'batch')
+        num_labels = jax.lax.psum(num_labels, 'batch')
+        loss = jax.tree_util.tree_map(lambda x: x / num_labels, loss)
+        grad = jax.lax.psum(grad, 'batch')
+        grad = jax.tree_util.tree_map(lambda x: x / num_labels, grad)
+        new_state = student_state.apply_gradients(grads=grad, dropout_rng=new_dropout_rng, to_dtype=to_dtype)
+        ce_loss = jax.lax.psum(ce_loss, 'batch')
+        ce_loss = jax.tree_util.tree_map(lambda x: x / num_labels, ce_loss)
+        kl_loss = jax.lax.psum(kl_loss, 'batch')
+        kl_loss = jax.tree_util.tree_map(lambda x: x / num_labels, kl_loss)
+        mse_loss = jax.lax.psum(mse_loss, 'batch')
+        mse_loss = jax.tree_util.tree_map(lambda x: x / num_labels, mse_loss)
+        metrics = {'loss': loss, 'learning_rate': linear_decay_lr_schedule_fn(student_state.step), 'ce_loss': ce_loss, 'kl_loss': kl_loss, 'mse_loss': mse_loss}
+        return (new_state, metrics)
+
+    def eval_step(student_params, teacher_params, batch):
+        labels = batch.pop('labels')
+        output_hidden_states = not share_hidden_states and training_args.mse_weight > 0
+        student_outputs = student_model(**batch, params=student_params, output_hidden_states=output_hidden_states, train=False)
+        student_distribution = jax.nn.log_softmax(student_outputs.logits, axis=-1)
+        (ce_loss, num_labels) = cross_entropy_loss(student_outputs.logits, labels)
+        teacher_outputs = teacher_model(**batch, params=teacher_params, output_hidden_states=output_hidden_states, train=False)
+        teacher_distribution = jax.nn.softmax(teacher_outputs.logits, axis=-1)
+        kl_loss = kl_divergence(teacher_distribution, student_distribution, labels)
+        mse_loss = mean_square_error_loss(student_outputs, teacher_outputs) if output_hidden_states else jnp.zeros_like(kl_loss)
+        ce_weight = 0.8 if training_args.kl_weight > 0 else 1.0
+        loss = ce_weight * ce_loss + training_args.kl_weight * kl_loss + training_args.mse_weight * mse_loss
+        loss = jax.lax.psum(loss, 'batch')
+        num_labels = jax.lax.psum(num_labels, 'batch')
+        loss = jax.tree_util.tree_map(lambda x: x / num_labels, loss)
+        ce_loss = jax.lax.psum(ce_loss, 'batch')
+        ce_loss = jax.tree_util.tree_map(lambda x: x / num_labels, ce_loss)
+        kl_loss = jax.lax.psum(kl_loss, 'batch')
+        kl_loss = jax.tree_util.tree_map(lambda x: x / num_labels, kl_loss)
+        mse_loss = jax.lax.psum(mse_loss, 'batch')
+        mse_loss = jax.tree_util.tree_map(lambda x: x / num_labels, mse_loss)
+        metrics = {'loss': loss, 'ce_loss': ce_loss, 'kl_loss': kl_loss, 'mse_loss': mse_loss}
+        return metrics
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else student_model.config.num_beams
+    gen_kwargs = {'max_length': max_label_length, 'num_beams': num_beams, 'language': '<|en|>', 'task': 'transcribe', 'return_timestamps': return_timestamps}
+
+    def generate_step(student_params, batch):
+        output_ids = student_model.generate(batch[model_input_name], attention_mask=batch.get('attention_mask'), params=student_params, **gen_kwargs)
+        return output_ids.sequences
+    student_state = student_state.replicate()
+    teacher_params = jax_utils.replicate(teacher_params)
+    p_train_step = jax.pmap(train_step, 'batch', in_axes=(0, 0, 0, None, None, None), donate_argnums=(0,), static_broadcasted_argnums=(3, 4))
+    p_eval_step = jax.pmap(eval_step, 'batch')
+    p_generate_step = jax.pmap(generate_step, 'batch')
+    logger.info('***** Running training *****')
+    logger.info(f'  Num examples = {total_train_steps * train_batch_size * gradient_accumulation_steps}')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_train_batch_size}')
+    logger.info(f'  Gradient accumulation steps = {gradient_accumulation_steps}')
+    logger.info(f'  Total train batch size (w. parallel & distributed) = {train_batch_size * gradient_accumulation_steps}')
+    logger.info(f'  Total optimization steps = {total_train_steps}')
+    train_time = 0
+    train_start = time.time()
+    train_metrics = []
+    batches_to_skip = jax.device_get(unreplicate(student_state.step))
+    cur_step = int(batches_to_skip)
+    epochs_trained = batches_to_skip // steps_per_epoch
+    steps_trained_progress_bar = tqdm(range(total_train_steps), desc='Train steps ... ', position=0)
+    steps_trained_progress_bar.update(batches_to_skip)
+    continue_training = True
+    minibatch_steps = 0
+    if batches_to_skip > 0:
+        logger.info('  Continuing training from checkpoint, will skip to saved global_step')
+        logger.info(f'  Continuing training from epoch {epochs_trained}')
+        logger.info(f'  Continuing training from global step {batches_to_skip}')
+    train_loader = get_data_loader(training_args.seed, vectorized_datasets['train'], batch_size=train_batch_size, data_collator=data_collator, dataloader_num_workers=dataloader_num_workers, skip_batches=batches_to_skip, prefetch_size=dataloader_prefetch_size)
+    for epoch in range(epochs_trained, num_epochs):
+        if hasattr(train_loader, 'dataset') and isinstance(train_loader.dataset, IterableDataset):
+            train_loader.dataset.set_epoch(epoch)
+        for batch in train_loader:
+            minibatch_steps += 1
+            update_step = minibatch_steps == gradient_accumulation_steps
+            if update_step:
+                steps_trained_progress_bar.update(1)
+                cur_step += 1
+                minibatch_steps = 0
+            batch = shard(batch.data)
+            (student_state, train_metric) = p_train_step(student_state, teacher_params, batch, training_args.freeze_encoder, share_hidden_states, training_args.temperature)
+            if cur_step % training_args.logging_steps == 0 and update_step:
+                train_metrics.append(train_metric)
+                train_metric_to_write = unreplicate(train_metric)
+                steps_trained_progress_bar.write(f"Step... ({cur_step} / {total_train_steps} | Loss: {train_metric_to_write['loss']}, Learning Rate: {train_metric_to_write['learning_rate']})")
+                if has_wandb and jax.process_index() == 0:
+                    write_wandb_metric(wandb_logger, train_metric_to_write, train_time + time.time() - train_start, cur_step, epoch, prefix='train')
+            if cur_step % training_args.save_steps == 0 and update_step or cur_step == total_train_steps:
+                if jax.process_index() == 0:
+                    save_hf_weights(student_state, student_model, processor, training_args.output_dir, cur_step, total_train_steps, use_scan=training_args.use_scan)
+                    if training_args.save_train_state:
+                        student_state.save_state(training_args.output_dir, save_total_limit=training_args.save_total_limit)
+                    if training_args.push_to_hub:
+                        repo.push_to_hub(commit_message=f'Saving train state of step {cur_step}', blocking=False)
+            if training_args.do_eval and (cur_step % eval_steps == 0 and update_step or cur_step == total_train_steps):
+                train_time += time.time() - train_start
+                for eval_split in all_eval_splits:
+                    eval_metrics = []
+                    eval_preds = []
+                    eval_labels = []
+                    eval_start = time.time()
+                    eval_loader = get_data_loader(training_args.seed, vectorized_datasets[eval_split], batch_size=eval_batch_size, data_collator=data_collator, shuffle=False, drop_last=False, dataloader_num_workers=dataloader_num_workers)
+                    for batch in tqdm(eval_loader, desc=f'Evaluating {eval_split}...', position=2):
+                        labels = batch['labels']
+                        metrics = pad_shard_unpad(p_eval_step, static_argnums=(0, 1), static_return=True)(student_state.params, teacher_params, batch.data, min_device_batch=per_device_eval_batch_size)
+                        eval_metrics.append(metrics)
+                        if training_args.predict_with_generate:
+                            generated_ids = pad_shard_unpad(p_generate_step)(student_state.params, batch.data, min_device_batch=per_device_eval_batch_size)
+                            eval_preds.extend(jax.device_get(generated_ids.reshape(-1, gen_kwargs['max_length'])))
+                            eval_labels.extend(labels)
+                    eval_time = time.time() - eval_start
+                    eval_metrics = get_metrics(eval_metrics)
+                    eval_metrics = jax.tree_util.tree_map(jnp.mean, eval_metrics)
+                    wer_desc = ''
+                    if training_args.predict_with_generate:
+                        (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str) = compute_metrics(eval_preds, eval_labels)
+                        eval_metrics.update(wer_metric)
+                        wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in wer_metric.items()])
+                    steps_trained_progress_bar.write(f"Eval results for step ({cur_step} / {total_train_steps} | Eval Loss: {eval_metrics['loss']} | {wer_desc})")
+                    if has_tensorboard and jax.process_index() == 0:
+                        write_eval_metric(summary_writer, eval_metrics, cur_step, prefix=eval_split)
+                    if has_wandb and jax.process_index() == 0:
+                        write_wandb_metric(wandb_logger, eval_metrics, eval_time, cur_step, epoch, prefix=eval_split)
+                        if training_args.predict_with_generate:
+                            write_wandb_pred(wandb_logger, pred_str, label_str, norm_pred_str, norm_label_str, cur_step, prefix=eval_split)
+                if has_tensorboard and jax.process_index() == 0:
+                    write_train_metric(summary_writer, train_metrics, train_time, cur_step, training_args.logging_steps)
+                train_start = time.time()
+                train_metrics = []
+            if cur_step == total_train_steps:
+                continue_training = False
+                break
+        if not continue_training:
+            break
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/run_eval.py
+""""""
+import logging
+import os
+import string
+import sys
+import time
+from dataclasses import field
+from functools import partial
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import datasets
+import evaluate
+import flax
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import torch
+import transformers
+from datasets import Dataset, DatasetDict, IterableDatasetDict, load_dataset
+from flax import jax_utils
+from flax.jax_utils import pad_shard_unpad
+from flax.training.common_utils import get_metrics, onehot
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import HfArgumentParser, Seq2SeqTrainingArguments, WhisperConfig, WhisperFeatureExtractor, WhisperProcessor, WhisperTokenizerFast, is_tensorboard_available, is_wandb_available
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+from distil_whisper import FlaxWhisperForConditionalGeneration
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: pip install -r examples/flax/speech-recogintion/requirements.txt')
+logger = logging.getLogger(__name__)
+
+@flax.struct.dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    tokenizer_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'})
+    feature_extractor_name: Optional[str] = field(default=None, metadata={'help': 'feature extractor name or path if not the same as model_name'})
+    processor_name: Optional[str] = field(default=None, metadata={'help': 'processor name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    use_auth_token: bool = field(default=False, metadata={'help': 'Will use the token generated when running `transformers-cli login` (necessary to use this script with private models).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'Floating-point format in which the model weights should be initialized and trained. Choose one of `[float32, float16, bfloat16]`.'})
+    load_with_scan: Optional[bool] = field(default=False, metadata={'help': 'Whether to load the model with scan enabled. Required when the model was saved with scan enabled'})
+    return_timestamps: bool = field(default=False, metadata={'help': 'Whether or not to predict timestamps in the generation step.'})
+
+@flax.struct.dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': "The name of the dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset hours by a '+' symbol."})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_split_name: Optional[str] = field(default=None, metadata={'help': 'The split name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default=None, metadata={'help': 'The name of the dataset column containing the text data. Defaults to `text`.'})
+    max_duration_in_seconds: float = field(default=30.0, metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'})
+    min_duration_in_seconds: float = field(default=0.0, metadata={'help': 'Filter audio files that are shorter than `min_duration_in_seconds` seconds'})
+    max_label_length: int = field(default=128, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    pad_target_to_multiple_of: Optional[int] = field(default=None, metadata={'help': 'If set will pad the target sequence to a multiple of the provided value. This is important to avoid triggering recompilations on TPU. If unspecified, will default to padding the targets to max length.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experiment reproducibility and to diff code across experiments in the UI.'})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and the data."})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of eval examples to this value if set.'})
+    log_audio: Optional[bool] = field(default=False, metadata={'help': 'For debugging purposes, record the audio samples as well as the ground truths / preds.'})
+
+def shift_tokens_right(label_ids: np.array, decoder_start_token_id: int) -> np.ndarray:
+    shifted_label_ids = np.zeros_like(label_ids)
+    shifted_label_ids[:, 1:] = label_ids[:, :-1]
+    shifted_label_ids[:, 0] = decoder_start_token_id
+    return shifted_label_ids
+
+@flax.struct.dataclass
+class FlaxDataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+    decoder_start_token_id: int
+    input_padding: Union[bool, str] = 'max_length'
+    target_padding: Union[bool, str] = 'max_length'
+    max_target_length: Optional[int] = None
+    log_audio: Optional[bool] = False
+    audio_column_name: Optional[str] = 'audio'
+
+    def __call__(self, features: List[Dict[str, Union[List[int], np.ndarray]]]) -> Dict[str, np.ndarray]:
+        model_input_name = self.processor.model_input_names[0]
+        input_features = {model_input_name: [feature[model_input_name] for feature in features]}
+        label_features = {'input_ids': [feature['labels'] for feature in features]}
+        batch = self.processor.feature_extractor.pad(input_features, padding=self.input_padding, return_tensors='np')
+        labels_batch = self.processor.tokenizer.pad(label_features, max_length=self.max_target_length, padding=self.target_padding, return_tensors='np')
+        labels = labels_batch['input_ids']
+        if (labels[:, 0] == self.decoder_start_token_id).all().item():
+            labels = labels[:, 1:]
+            labels_batch.attention_mask = labels_batch.attention_mask[:, 1:]
+        decoder_input_ids = shift_tokens_right(labels, self.decoder_start_token_id)
+        labels = np.ma.array(labels, mask=np.not_equal(labels_batch.attention_mask, 1))
+        labels = labels.filled(fill_value=-100)
+        batch['labels'] = labels
+        batch['decoder_input_ids'] = decoder_input_ids
+        if self.log_audio:
+            audio_samples = [feature[self.audio_column_name] for feature in features]
+            batch['audio'] = audio_samples
+        return batch
+
+def get_data_loader(dataset: Dataset, batch_size: int, data_collator: FlaxDataCollatorSpeechSeq2SeqWithPadding, dataloader_num_workers: int=0, pin_memory: bool=True) -> DataLoader:
+    data_loader = DataLoader(dataset, batch_size=batch_size, drop_last=False, pin_memory=pin_memory, collate_fn=data_collator, num_workers=dataloader_num_workers)
+    return data_loader
+
+def write_metric(summary_writer, eval_metrics, step, prefix='eval'):
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.scalar(f'{prefix}/{metric_name}', value, step)
+
+def write_wandb_metric(wandb_logger, metrics, train_time, prefix):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    wandb_logger.log(log_metrics)
+
+def convert_audio_to_wandb(wandb_logger, audio):
+    return wandb_logger.Audio(audio['array'][:, np.newaxis], sample_rate=audio['sampling_rate'])
+
+def write_wandb_pred(wandb_logger, eval_audios, pred_str, label_str, norm_pred_str, norm_label_str, prefix='eval', num_lines=200000):
+    columns = ['Target', 'Pred', 'Norm Target', 'Norm Pred']
+    str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+    if len(eval_audios) > 0:
+        columns.insert(0, 'Audio')
+        str_data = [[convert_audio_to_wandb(wandb_logger, eval_audios[i]), *str_data[i]] for i in range(len(pred_str))]
+    wandb_logger.log({f'{prefix}/all_predictions': wandb_logger.Table(columns=columns, data=str_data[:num_lines])})
+    str_data = np.asarray(str_data)
+    str_data_incorrect = str_data[str_data[:, -2] != str_data[:, -1]]
+    wandb_logger.log({f'{prefix}/incorrect_predictions': wandb_logger.Table(columns=columns, data=str_data_incorrect[:num_lines])})
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_hours=None, default_split='train'):
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        for i in range(len(dataset_names)):
+            ds_name = dataset_names[i]
+            dataset_names[i] = f'distil-whisper/{ds_name}' if '/' not in ds_name else ds_name
+        dataset_config_names = dataset_config_names.split('+')
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_hours = dataset_hours.split('+') if dataset_hours is not None else None
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_hours is not None:
+        if len(dataset_hours) != len(dataset_names):
+            raise ValueError(f'Ensure one probability is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_hours)} hours.')
+        dataset_hours = [float(ds_hours) for ds_hours in dataset_hours]
+    else:
+        dataset_hours = [None] * len(dataset_names)
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'hours': dataset_hours[i]})
+    return dataset_names_dict
+
+class FlaxWhisperFeatureExtractor(WhisperFeatureExtractor):
+
+    def _np_extract_fbank_features(self, waveform: np.array) -> np.ndarray:
+        waveform = torch.from_numpy(waveform).type(torch.float32)
+        window = torch.hann_window(self.n_fft)
+        stft = torch.stft(waveform, self.n_fft, self.hop_length, window=window, return_complex=True)
+        magnitudes = stft[..., :-1].abs() ** 2
+        mel_filters = torch.from_numpy(self.mel_filters).type(torch.float32)
+        mel_spec = mel_filters.T @ magnitudes
+        log_spec = torch.clamp(mel_spec, min=1e-10).log10()
+        log_spec = torch.maximum(log_spec, log_spec.max() - 8.0)
+        log_spec = (log_spec + 4.0) / 4.0
+        return log_spec.numpy()
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    send_example_telemetry('run_flax_speech_recognition_seq2seq', model_args, data_args, framework='flax')
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    logger.setLevel(logging.INFO if jax.process_index() == 0 else logging.ERROR)
+    if jax.process_index() == 0:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Evaluation parameters %s', training_args)
+    has_tensorboard = is_tensorboard_available()
+    if 'tensorboard' in training_args.report_to:
+        if has_tensorboard and jax.process_index() == 0:
+            try:
+                from flax.metrics.tensorboard import SummaryWriter
+                summary_writer = SummaryWriter(log_dir=Path(training_args.output_dir))
+            except ImportError as ie:
+                has_tensorboard = False
+                logger.warning(f'Unable to display metrics through TensorBoard because some package are not installed: {ie}')
+        else:
+            logger.warning('Unable to display metrics through TensorBoard because the package is not installed: Please run `pip install tensorboard` to enable.')
+    has_wandb = is_wandb_available()
+    if 'wandb' in training_args.report_to:
+        if has_wandb and jax.process_index() == 0:
+            import wandb as wandb_logger
+            wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb)
+        else:
+            logger.warning('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    dataset_names_dict = convert_dataset_str_to_list(data_args.dataset_name, data_args.dataset_config_name, splits=data_args.dataset_split_name, text_column_names=data_args.text_column_name)
+    if len(dataset_names_dict) == 1:
+        dataset_dict = dataset_names_dict[0]
+        raw_datasets['eval'] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, use_auth_token=True if model_args.use_auth_token else None, streaming=data_args.streaming)
+        if dataset_dict['text_column_name'] not in list(raw_datasets['eval'].features.keys()):
+            raise ValueError(f"--text column name {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(raw_datasets['eval'].features.keys()))}")
+        if dataset_dict['text_column_name'] != 'text':
+            raw_datasets['eval'] = raw_datasets['eval'].rename_column(dataset_dict['text_column_name'], 'text')
+    else:
+        for dataset_dict in tqdm(dataset_names_dict, desc='Loading datasets...'):
+            pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+            raw_datasets[pretty_name] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, use_auth_token=True if model_args.use_auth_token else None, streaming=data_args.streaming)
+            if dataset_dict['text_column_name'] not in list(raw_datasets[pretty_name].features.keys()):
+                raise ValueError(f"`--text_column_name` {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(raw_datasets[pretty_name].features.keys()))}")
+            if dataset_dict['text_column_name'] != 'text':
+                raw_datasets[pretty_name] = raw_datasets[pretty_name].rename_column(dataset_dict['text_column_name'], 'text')
+    config = WhisperConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    feature_extractor = FlaxWhisperFeatureExtractor.from_pretrained(model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    tokenizer = WhisperTokenizerFast.from_pretrained(model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_fast=model_args.use_fast_tokenizer, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    processor = WhisperProcessor.from_pretrained(model_args.processor_name if model_args.processor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    (model, params) = FlaxWhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, dtype=getattr(jnp, model_args.dtype), cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None, _do_init=False, subfolder=model_args.subfolder)
+    if model.config.decoder_start_token_id is None:
+        raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+    if model_args.load_with_scan:
+        model.disable_scan()
+        params = model.convert_scan_to_unroll(params)
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate))
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else model.config.max_length
+    audio_column_name = data_args.audio_column_name
+    num_workers = data_args.preprocessing_num_workers
+    dataloader_num_workers = training_args.dataloader_num_workers
+    model_input_name = feature_extractor.model_input_names[0]
+    normalizer = EnglishTextNormalizer(tokenizer.english_spelling_normalizer)
+    if data_args.max_eval_samples is not None:
+        for split in raw_datasets:
+            raw_datasets[split] = raw_datasets[split].take(data_args.max_eval_samples) if data_args.streaming else raw_datasets[split].select(range(data_args.max_eval_samples))
+
+    def prepare_dataset(batch):
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        input_str = batch['text']
+        batch['labels'] = tokenizer(input_str, max_length=max_label_length, truncation=True).input_ids
+        return batch
+    vectorized_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    for split in raw_datasets:
+        raw_datasets_features = list(raw_datasets[split].features.keys())
+        if data_args.log_audio:
+            raw_datasets_features.remove(audio_column_name)
+        map_fn = partial(raw_datasets[split].map, function=prepare_dataset, remove_columns=raw_datasets_features)
+        vectorized_datasets[split] = map_fn(num_proc=num_workers, desc='preprocess eval dataset') if not data_args.streaming else map_fn()
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    metric = evaluate.load('wer')
+    all_punctuation = list(string.punctuation.replace("'", ''))
+    return_timestamps = model_args.return_timestamps
+
+    def compute_metrics(preds, labels):
+        for idx in range(len(labels)):
+            labels[idx][labels[idx] == -100] = tokenizer.pad_token_id
+        pred_str = tokenizer.batch_decode(preds, skip_special_tokens=True, decode_with_timestamps=return_timestamps)
+        label_str = tokenizer.batch_decode(labels, skip_special_tokens=True)
+        spaced_pred_str = [pred_str[i].replace(punctuation, f' {punctuation} ') for punctuation in all_punctuation for i in range(len(pred_str))]
+        spaced_label_str = [label_str[i].replace(punctuation, f' {punctuation} ') for punctuation in all_punctuation for i in range(len(label_str))]
+        wer_ortho = 100 * metric.compute(predictions=spaced_pred_str, references=spaced_label_str)
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return ({'wer': wer, 'wer_ortho': wer_ortho}, pred_str, label_str, norm_pred_str, norm_label_str)
+    data_collator = FlaxDataCollatorSpeechSeq2SeqWithPadding(processor=processor, decoder_start_token_id=model.config.decoder_start_token_id, input_padding='longest', target_padding='max_length', max_target_length=max_label_length, log_audio=data_args.log_audio)
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    eval_batch_size = per_device_eval_batch_size * jax.device_count()
+
+    def loss_fn(logits, labels, label_smoothing_factor=0.0):
+        vocab_size = logits.shape[-1]
+        confidence = 1.0 - label_smoothing_factor
+        low_confidence = (1.0 - confidence) / (vocab_size - 1)
+        normalizing_constant = -(confidence * jnp.log(confidence) + (vocab_size - 1) * low_confidence * jnp.log(low_confidence + 1e-20))
+        soft_labels = onehot(labels, vocab_size, on_value=confidence, off_value=low_confidence)
+        loss = optax.softmax_cross_entropy(logits, soft_labels)
+        loss = loss - normalizing_constant
+        padding_mask = labels >= 0
+        loss = loss * padding_mask
+        loss = loss.sum()
+        num_labels = padding_mask.sum()
+        return (loss, num_labels)
+
+    def eval_step(params, batch, label_smoothing_factor=0.0):
+        labels = batch.pop('labels')
+        logits = model(**batch, params=params, freeze_encoder=True, train=False)[0]
+        (loss, num_labels) = loss_fn(logits, labels, label_smoothing_factor)
+        num_labels = jax.lax.psum(num_labels, 'batch')
+        loss = jax.lax.psum(loss, 'batch')
+        loss = jax.tree_util.tree_map(lambda x: x / num_labels, loss)
+        metrics = {'loss': loss}
+        return metrics
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else model.config.num_beams
+    gen_kwargs = {'max_length': max_label_length, 'num_beams': num_beams, 'language': '<|en|>', 'task': 'transcribe', 'return_timestamps': return_timestamps}
+
+    def generate_step(params, batch):
+        output_ids = model.generate(batch[model_input_name], attention_mask=batch.get('attention_mask'), params=params, freeze_encoder=True, **gen_kwargs)
+        return output_ids.sequences
+    p_eval_step = jax.pmap(partial(eval_step, label_smoothing_factor=training_args.label_smoothing_factor), 'batch')
+    p_generate_step = jax.pmap(generate_step, 'batch')
+    params = jax_utils.replicate(params)
+
+    def eval_step(split='eval'):
+        eval_metrics = []
+        eval_preds = []
+        eval_labels = []
+        eval_audios = []
+        eval_start = time.time()
+        eval_loader = get_data_loader(vectorized_datasets[split], batch_size=eval_batch_size, data_collator=data_collator, dataloader_num_workers=dataloader_num_workers)
+        for batch in tqdm(eval_loader, desc=f'Evaluating {split}...'):
+            labels = batch['labels']
+            if data_args.log_audio:
+                eval_audios.extend(batch.pop('audio'))
+            metrics = pad_shard_unpad(p_eval_step, static_return=True)(params, batch.data, min_device_batch=per_device_eval_batch_size)
+            eval_metrics.append(metrics)
+            if training_args.predict_with_generate:
+                generated_ids = pad_shard_unpad(p_generate_step)(params, batch.data, min_device_batch=per_device_eval_batch_size)
+                eval_preds.extend(jax.device_get(generated_ids.reshape(-1, gen_kwargs['max_length'])))
+                eval_labels.extend(labels)
+        eval_time = time.time() - eval_start
+        eval_metrics = get_metrics(eval_metrics)
+        eval_metrics = jax.tree_util.tree_map(jnp.mean, eval_metrics)
+        wer_desc = ''
+        if training_args.predict_with_generate:
+            (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str) = compute_metrics(eval_preds, eval_labels)
+            eval_metrics.update(wer_metric)
+            wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in wer_metric.items()])
+        logger.info(f"Eval Loss: {eval_metrics['loss']} | {wer_desc})")
+        if has_tensorboard and jax.process_index() == 0 and ('tensorboard' in training_args.report_to):
+            write_metric(summary_writer, eval_metrics, model_args.step, prefix=split)
+        if has_wandb and jax.process_index() == 0 and ('wandb' in training_args.report_to):
+            write_wandb_metric(wandb_logger, eval_metrics, eval_time, prefix=split)
+            if training_args.predict_with_generate:
+                write_wandb_pred(wandb_logger, eval_audios, pred_str, label_str, norm_pred_str, norm_label_str, prefix=split)
+    logger.info('***** Running Eval *****')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_eval_batch_size}')
+    logger.info(f'  Total eval batch size (w. parallel & distributed) = {eval_batch_size}')
+    for split in vectorized_datasets:
+        eval_step(split=split)
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/run_finetuning.py
+""""""
+import logging
+import os
+import string
+import sys
+import time
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Union
+import datasets
+import evaluate
+import flax
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import transformers
+from datasets import Dataset, DatasetDict, load_dataset
+from flax import jax_utils, traverse_util
+from flax.jax_utils import pad_shard_unpad, unreplicate
+from flax.training import train_state
+from flax.training.common_utils import get_metrics, onehot, shard, shard_prng_key
+from huggingface_hub import Repository, create_repo
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoConfig, AutoFeatureExtractor, AutoProcessor, AutoTokenizer, HfArgumentParser, Seq2SeqTrainingArguments, is_tensorboard_available, is_wandb_available
+from transformers.file_utils import get_full_repo_name
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+from distil_whisper import FlaxWhisperForConditionalGeneration
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: pip install -r examples/flax/speech-recogintion/requirements.txt')
+logger = logging.getLogger(__name__)
+
+@flax.struct.dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    tokenizer_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'})
+    feature_extractor_name: Optional[str] = field(default=None, metadata={'help': 'feature extractor name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    use_auth_token: bool = field(default=False, metadata={'help': 'Will use the token generated when running `transformers-cli login` (necessary to use this script with private models).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'Floating-point format in which the model weights should be initialized and trained. Choose one of `[float32, float16, bfloat16]`.'})
+    activation_dropout: float = field(default=0.0, metadata={'help': 'The dropout ratio for activations inside the fully connected layer.'})
+    attention_dropout: float = field(default=0.0, metadata={'help': 'The dropout ratio for the attention probabilities.'})
+    dropout: float = field(default=0.0, metadata={'help': 'The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.'})
+
+@flax.struct.dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': 'The name of the dataset to use (via the datasets library).'})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    max_train_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes or quicker training, truncate the number of training examples to this value if set.'})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes or quicker training, truncate the number of evaluation examples to this value if set.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default='whisper_transcript', metadata={'help': "The name of the dataset column containing the text data. Defaults to 'whisper_transcript'which is the pseudo-labelled Whisper transcription data."})
+    max_duration_in_seconds: float = field(default=30.0, metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'})
+    min_duration_in_seconds: float = field(default=0.0, metadata={'help': 'Filter audio files that are shorter than `min_duration_in_seconds` seconds'})
+    max_label_length: int = field(default=128, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    pad_target_to_multiple_of: Optional[int] = field(default=None, metadata={'help': 'If set will pad the target sequence to a multiple of the provided value. This is important to avoid triggering recompilations on TPU. If unspecified, will default to padding the targets to max length.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    train_split_name: str = field(default='train', metadata={'help': "The name of the training data set split to use (via the datasets library). Defaults to 'train'"})
+    eval_split_name: str = field(default='validation', metadata={'help': "The name of the evaluation data set split to use (via the datasets library). Defaults to 'validation'"})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experimentreproducibility and to diff code across experiments in the UI.'})
+
+@dataclass
+class FlaxSeq2SeqTrainingArguments(Seq2SeqTrainingArguments):
+    use_scan: Optional[bool] = field(default=True, metadata={'help': 'Whether or not to use `scan_with_axes` over the encoder and decoder blocks. Using scan results in faster compile times and more efficient memory use during training, since all of the layers in the encoder/decoder are stacked, and we perform a lax.scan over the stacked block to index each layer. However, it results in slower inference time due to the overhead of stacking the layers this way. Thus, we always default to disabling scan for the inference step.'})
+    freeze_encoder: Optional[bool] = field(default=False, metadata={'help': 'Whether to freeze the entire encoder model. Only recommended when the entire encoder has been copiedfrom the teacher model.'})
+
+def shift_tokens_right(label_ids: np.array, decoder_start_token_id: int) -> np.ndarray:
+    shifted_label_ids = np.zeros_like(label_ids)
+    shifted_label_ids[:, 1:] = label_ids[:, :-1]
+    shifted_label_ids[:, 0] = decoder_start_token_id
+    return shifted_label_ids
+
+@flax.struct.dataclass
+class FlaxDataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+    decoder_start_token_id: int
+    input_padding: Union[bool, str] = 'max_length'
+    target_padding: Union[bool, str] = 'max_length'
+    max_target_length: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], np.ndarray]]]) -> Dict[str, np.ndarray]:
+        model_input_name = self.processor.model_input_names[0]
+        input_features = {model_input_name: [feature[model_input_name] for feature in features]}
+        label_features = {'input_ids': [feature['labels'] for feature in features]}
+        batch = self.processor.feature_extractor.pad(input_features, padding=self.input_padding, return_tensors='np')
+        labels_batch = self.processor.tokenizer.pad(label_features, max_length=self.max_target_length, padding=self.target_padding, return_tensors='np')
+        labels = labels_batch['input_ids']
+        if (labels[:, 0] == self.decoder_start_token_id).all().item():
+            labels = labels[:, 1:]
+            labels_batch.attention_mask = labels_batch.attention_mask[:, 1:]
+        decoder_input_ids = shift_tokens_right(labels, self.decoder_start_token_id)
+        labels = np.ma.array(labels, mask=np.not_equal(labels_batch.attention_mask, 1))
+        labels = labels.filled(fill_value=-100)
+        batch['labels'] = labels
+        batch['decoder_input_ids'] = decoder_input_ids
+        return batch
+
+def get_data_loader(rng: jax.random.PRNGKey, dataset: Dataset, batch_size: int, data_collator: FlaxDataCollatorSpeechSeq2SeqWithPadding, shuffle: bool=True, drop_last: bool=True, dataloader_num_workers: int=0, pin_memory: bool=True) -> DataLoader:
+    if shuffle:
+        batch_idx = jax.random.permutation(rng, len(dataset))
+        batch_idx = np.asarray(batch_idx)
+        dataset = dataset.select(batch_idx)
+    data_loader = DataLoader(dataset, batch_size=batch_size, drop_last=drop_last, pin_memory=pin_memory, collate_fn=data_collator, num_workers=dataloader_num_workers)
+    return data_loader
+
+class TrainState(train_state.TrainState):
+    dropout_rng: jnp.ndarray
+
+    def replicate(self):
+        return jax_utils.replicate(self).replace(dropout_rng=shard_prng_key(self.dropout_rng))
+
+def write_metric(summary_writer, train_metrics, eval_metrics, train_time, step, logging_steps):
+    summary_writer.scalar('train/time', train_time, step)
+    train_metrics = get_metrics(train_metrics)
+    for (key, vals) in train_metrics.items():
+        steps_arr = np.arange(0, step, logging_steps)[-len(vals):]
+        tag = f'train/{key}'
+        for (i, val) in enumerate(vals):
+            summary_writer.scalar(tag, val, steps_arr[i])
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.scalar(f'eval/{metric_name}', value, step)
+
+def write_wandb_metric(wandb_logger, metrics, train_time, step, prefix):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    wandb_logger.log(log_metrics, step)
+
+def write_wandb_pred(wandb_logger, pred_str, label_str, prefix='eval', num_lines=100):
+    if num_lines < len(pred_str):
+        str_data = [[label_str[i], pred_str[i]] for i in range(num_lines)]
+    else:
+        str_data = [[label_str[i], pred_str[i]] for i in range(len(pred_str))]
+    wandb_logger.log({f'{prefix}/predictions': wandb_logger.Table(columns=['label_str', 'pred_str'], data=str_data)})
+
+def create_learning_rate_fn(num_train_steps: int, num_warmup_steps: int, learning_rate: float) -> Callable[[int], jnp.array]:
+    warmup_fn = optax.linear_schedule(init_value=0.0, end_value=learning_rate, transition_steps=num_warmup_steps)
+    decay_fn = optax.linear_schedule(init_value=learning_rate, end_value=0, transition_steps=num_train_steps - num_warmup_steps)
+    schedule_fn = optax.join_schedules(schedules=[warmup_fn, decay_fn], boundaries=[num_warmup_steps])
+    return schedule_fn
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, FlaxSeq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    send_example_telemetry('run_flax_speech_recognition_seq2seq', model_args, data_args, framework='flax')
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    logger.setLevel(logging.INFO if jax.process_index() == 0 else logging.ERROR)
+    if jax.process_index() == 0:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Training/evaluation parameters %s', training_args)
+    if os.path.exists(training_args.output_dir) and os.listdir(training_args.output_dir) and training_args.do_train and (not training_args.overwrite_output_dir):
+        raise ValueError(f'Output directory ({training_args.output_dir}) already exists and is not empty.Use `--overwrite_output_dir` to overcome.')
+    if training_args.push_to_hub:
+        if training_args.hub_model_id is None:
+            repo_name = get_full_repo_name(Path(training_args.output_dir).absolute().name, token=training_args.hub_token)
+        else:
+            repo_name = training_args.hub_model_id
+        create_repo(repo_name, exist_ok=True, token=training_args.hub_token)
+        repo = Repository(training_args.output_dir, clone_from=repo_name, token=training_args.hub_token)
+    raw_datasets = DatasetDict()
+    if training_args.do_train:
+        raw_datasets['train'] = load_dataset(data_args.dataset_name, data_args.dataset_config_name, split=data_args.train_split_name, cache_dir=data_args.dataset_cache_dir, use_auth_token=True if model_args.use_auth_token else None, num_proc=data_args.preprocessing_num_workers)
+    if training_args.do_eval:
+        raw_datasets['eval'] = load_dataset(data_args.dataset_name, data_args.dataset_config_name, split=data_args.eval_split_name, cache_dir=data_args.dataset_cache_dir, use_auth_token=True if model_args.use_auth_token else None, num_proc=data_args.preprocessing_num_workers)
+    if not training_args.do_train and (not training_args.do_eval):
+        raise ValueError('Cannot not train and not do evaluation. At least one of training or evaluation has to be performed.')
+    if data_args.audio_column_name not in next(iter(raw_datasets.values())).column_names:
+        raise ValueError(f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. Make sure to set `--audio_column_name` to the correct audio column - one of {', '.join(next(iter(raw_datasets.values())).column_names)}.")
+    if data_args.text_column_name not in next(iter(raw_datasets.values())).column_names:
+        raise ValueError(f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. Make sure to set `--text_column_name` to the correct text column - one of {', '.join(next(iter(raw_datasets.values())).column_names)}.")
+    config = AutoConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    feature_extractor = AutoFeatureExtractor.from_pretrained(model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_fast=model_args.use_fast_tokenizer, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None)
+    config.update({'activation_dropout': model_args.activation_dropout, 'attention_dropout': model_args.attention_dropout, 'dropout': model_args.dropout})
+    (model, params) = FlaxWhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, dtype=getattr(jnp, model_args.dtype), cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None, _do_init=False)
+    if model.config.decoder_start_token_id is None:
+        raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+    if training_args.use_scan:
+        model.enable_scan()
+        params = model.convert_unroll_to_scan(params)
+    if training_args.gradient_checkpointing:
+        model.enable_gradient_checkpointing()
+    if hasattr(model.generation_config, 'is_multilingual') and model.generation_config.is_multilingual:
+        tokenizer.set_prefix_tokens(language='English', task='transcribe', predict_timestamps=False)
+        model.generation_config.forced_decoder_ids = tokenizer.get_decoder_prompt_ids(language='English', task='transcribe', no_timestamps=True)
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate))
+    max_input_length = int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate)
+    min_input_length = int(data_args.min_duration_in_seconds * feature_extractor.sampling_rate)
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else model.config.max_length
+    audio_column_name = data_args.audio_column_name
+    num_workers = data_args.preprocessing_num_workers
+    dataloader_num_workers = training_args.dataloader_num_workers
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    normalizer = EnglishTextNormalizer(tokenizer.english_spelling_normalizer)
+    if training_args.do_train and data_args.max_train_samples is not None:
+        raw_datasets['train'] = raw_datasets['train'].select(range(data_args.max_train_samples))
+    if training_args.do_eval and data_args.max_eval_samples is not None:
+        raw_datasets['eval'] = raw_datasets['eval'].select(range(data_args.max_eval_samples))
+
+    def prepare_dataset(batch):
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch['input_length'] = len(sample['array'])
+        input_str = ' ' + batch[text_column_name].lower()
+        batch['labels'] = tokenizer(input_str).input_ids
+        return batch
+    vectorized_datasets = raw_datasets.map(prepare_dataset, remove_columns=next(iter(raw_datasets.values())).column_names, num_proc=num_workers, desc='preprocess train dataset')
+
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+    vectorized_datasets = vectorized_datasets.filter(is_audio_in_length_range, num_proc=num_workers, input_columns=['input_length'])
+
+    def is_labels_in_length_range(labels):
+        return 0 < len(labels) < max_label_length
+    vectorized_datasets = vectorized_datasets.filter(is_labels_in_length_range, num_proc=num_workers, input_columns=['labels'])
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    metric = evaluate.load('wer')
+    all_punctuation = list(string.punctuation.replace("'", ''))
+
+    def compute_metrics(preds, labels):
+        for idx in range(len(labels)):
+            labels[idx][labels[idx] == -100] = tokenizer.pad_token_id
+        pred_str = tokenizer.batch_decode(preds, skip_special_tokens=True)
+        label_str = tokenizer.batch_decode(labels, skip_special_tokens=True)
+        spaced_pred_str = [pred_str[i].replace(punctuation, '') for punctuation in all_punctuation for i in range(len(pred_str))]
+        spaced_label_str = [label_str[i].replace(punctuation, '') for punctuation in all_punctuation for i in range(len(label_str))]
+        wer_ortho = 100 * metric.compute(predictions=spaced_pred_str, references=spaced_label_str)
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return ({'wer': wer, 'wer_ortho': wer_ortho}, pred_str, label_str)
+    feature_extractor.save_pretrained(training_args.output_dir)
+    tokenizer.save_pretrained(training_args.output_dir)
+    config.save_pretrained(training_args.output_dir)
+    model.generation_config.save_pretrained(training_args.output_dir)
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+    data_collator = FlaxDataCollatorSpeechSeq2SeqWithPadding(processor=processor, decoder_start_token_id=model.config.decoder_start_token_id, input_padding='longest', target_padding='max_length', max_target_length=max_label_length)
+    has_tensorboard = is_tensorboard_available()
+    if has_tensorboard and jax.process_index() == 0:
+        try:
+            from flax.metrics.tensorboard import SummaryWriter
+            summary_writer = SummaryWriter(log_dir=Path(training_args.output_dir))
+        except ImportError as ie:
+            has_tensorboard = False
+            logger.warning(f'Unable to display metrics through TensorBoard because some package are not installed: {ie}')
+    else:
+        logger.warning('Unable to display metrics through TensorBoard because the package is not installed: Please run `pip install tensorboard` to enable.')
+    has_wandb = is_wandb_available()
+    if has_wandb:
+        import wandb as wandb_logger
+        if jax.process_index() == 0:
+            wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb)
+    else:
+        logger.warning('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    rng = jax.random.PRNGKey(training_args.seed)
+    (rng, dropout_rng) = jax.random.split(rng)
+    num_epochs = int(training_args.num_train_epochs)
+    train_batch_size = int(training_args.per_device_train_batch_size) * jax.device_count()
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    eval_batch_size = per_device_eval_batch_size * jax.device_count()
+    steps_per_epoch = len(vectorized_datasets['train']) // train_batch_size
+    total_train_steps = steps_per_epoch * num_epochs
+    linear_decay_lr_schedule_fn = create_learning_rate_fn(total_train_steps, training_args.warmup_steps, training_args.learning_rate)
+
+    def decay_mask_fn(params):
+        flat_params = traverse_util.flatten_dict(params)
+        layer_norm_candidates = ['layer_norm', 'self_attn_layer_norm', 'final_layer_norm', 'encoder_attn_layer_norm']
+        layer_norm_named_params = {layer[-2:] for layer_norm_name in layer_norm_candidates for layer in flat_params.keys() if layer_norm_name in ''.join(layer).lower()}
+        flat_mask = {path: path[-1] != 'bias' and path[-2:] not in layer_norm_named_params for path in flat_params}
+        return traverse_util.unflatten_dict(flat_mask)
+    adamw = optax.adamw(learning_rate=linear_decay_lr_schedule_fn, b1=training_args.adam_beta1, b2=training_args.adam_beta2, eps=training_args.adam_epsilon, weight_decay=training_args.weight_decay, mask=decay_mask_fn)
+    state = TrainState.create(apply_fn=model.__call__, params=params, tx=adamw, dropout_rng=dropout_rng)
+
+    def loss_fn(logits, labels, label_smoothing_factor=0.0):
+        vocab_size = logits.shape[-1]
+        confidence = 1.0 - label_smoothing_factor
+        low_confidence = (1.0 - confidence) / (vocab_size - 1)
+        normalizing_constant = -(confidence * jnp.log(confidence) + (vocab_size - 1) * low_confidence * jnp.log(low_confidence + 1e-20))
+        soft_labels = onehot(labels, vocab_size, on_value=confidence, off_value=low_confidence)
+        loss = optax.softmax_cross_entropy(logits, soft_labels)
+        loss = loss - normalizing_constant
+        padding_mask = labels >= 0
+        loss = loss * padding_mask
+        loss = loss.sum()
+        num_labels = padding_mask.sum()
+        return (loss, num_labels)
+
+    def train_step(state, batch, freeze_encoder, label_smoothing_factor=0.0):
+        (dropout_rng, new_dropout_rng) = jax.random.split(state.dropout_rng)
+
+        def compute_loss(params):
+            labels = batch.pop('labels')
+            logits = state.apply_fn(**batch, params=params, dropout_rng=dropout_rng, freeze_encoder=freeze_encoder, train=True)[0]
+            (loss, num_labels) = loss_fn(logits, labels, label_smoothing_factor)
+            return (loss, num_labels)
+        grad_fn = jax.value_and_grad(compute_loss, has_aux=True)
+        ((loss, num_labels), grad) = grad_fn(state.params)
+        num_labels = jax.lax.psum(num_labels, 'batch')
+        loss = jax.lax.psum(loss, 'batch')
+        loss = jax.tree_util.tree_map(lambda x: x / num_labels, loss)
+        grad = jax.lax.psum(grad, 'batch')
+        grad = jax.tree_util.tree_map(lambda x: x / num_labels, grad)
+        new_state = state.apply_gradients(grads=grad, dropout_rng=new_dropout_rng)
+        metrics = {'loss': loss, 'learning_rate': linear_decay_lr_schedule_fn(state.step)}
+        return (new_state, metrics)
+
+    def eval_step(params, batch, label_smoothing_factor=0.0):
+        labels = batch.pop('labels')
+        logits = model(**batch, params=params, train=False)[0]
+        (loss, num_labels) = loss_fn(logits, labels, label_smoothing_factor)
+        num_labels = jax.lax.psum(num_labels, 'batch')
+        loss = jax.lax.psum(loss, 'batch')
+        loss = jax.tree_util.tree_map(lambda x: x / num_labels, loss)
+        metrics = {'loss': loss}
+        return metrics
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else model.config.num_beams
+    gen_kwargs = {'max_length': max_label_length, 'num_beams': num_beams}
+
+    def generate_step(params, batch):
+        output_ids = model.generate(batch[model_input_name], attention_mask=batch.get('attention_mask'), params=params, **gen_kwargs)
+        return output_ids.sequences
+    p_train_step = jax.pmap(partial(train_step, label_smoothing_factor=training_args.label_smoothing_factor), 'batch', donate_argnums=(0,), static_broadcasted_argnums=(2,))
+    p_eval_step = jax.pmap(partial(eval_step, label_smoothing_factor=training_args.label_smoothing_factor), 'batch')
+    p_generate_step = jax.pmap(generate_step, 'batch')
+    state = state.replicate()
+    logger.info('***** Running training *****')
+    logger.info(f"  Num examples = {len(vectorized_datasets['train'])}")
+    logger.info(f'  Num Epochs = {num_epochs}')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_train_batch_size}')
+    logger.info(f'  Total train batch size (w. parallel & distributed) = {train_batch_size}')
+    logger.info(f'  Total optimization steps = {total_train_steps}')
+    train_time = 0
+    epochs = tqdm(range(num_epochs), desc=f'Epoch ... (1/{num_epochs})', position=0)
+    for epoch in epochs:
+        train_start = time.time()
+        (rng, input_rng) = jax.random.split(rng)
+        train_metrics = []
+        train_loader = get_data_loader(input_rng, vectorized_datasets['train'], batch_size=train_batch_size, data_collator=data_collator, dataloader_num_workers=dataloader_num_workers)
+        for (step, batch) in enumerate(tqdm(train_loader, desc='Training...', position=1), 1):
+            batch = shard(batch.data)
+            (state, train_metric) = p_train_step(state, batch, training_args.freeze_encoder)
+            cur_step = epoch * steps_per_epoch + step
+            if cur_step % training_args.logging_steps == 0:
+                train_metrics.append(train_metric)
+                train_metric_to_write = unreplicate(train_metric)
+                epochs.write(f"Step... ({cur_step} / {total_train_steps} | Loss: {train_metric_to_write['loss']}, Learning Rate: {train_metric_to_write['learning_rate']})")
+                if has_wandb and jax.process_index() == 0:
+                    write_wandb_metric(wandb_logger, train_metric_to_write, train_time + time.time() - train_start, cur_step, 'train')
+        train_time += time.time() - train_start
+        train_metric = unreplicate(train_metric)
+        epochs.write(f"Epoch... ({epoch + 1}/{num_epochs} | Loss: {train_metric['loss']}, Learning Rate: {train_metric['learning_rate']})")
+        eval_metrics = []
+        eval_preds = []
+        eval_labels = []
+        eval_start = time.time()
+        eval_loader = get_data_loader(input_rng, vectorized_datasets['eval'], batch_size=eval_batch_size, data_collator=data_collator, shuffle=False, drop_last=False, dataloader_num_workers=dataloader_num_workers)
+        for batch in tqdm(eval_loader, desc='Evaluating...', position=2):
+            labels = batch['labels']
+            metrics = pad_shard_unpad(p_eval_step, static_return=True)(state.params, batch.data, min_device_batch=per_device_eval_batch_size)
+            eval_metrics.append(metrics)
+            if training_args.predict_with_generate:
+                generated_ids = pad_shard_unpad(p_generate_step)(state.params, batch.data, min_device_batch=per_device_eval_batch_size)
+                eval_preds.extend(jax.device_get(generated_ids.reshape(-1, gen_kwargs['max_length'])))
+                eval_labels.extend(labels)
+        eval_time = time.time() - eval_start
+        eval_metrics = get_metrics(eval_metrics)
+        eval_metrics = jax.tree_util.tree_map(jnp.mean, eval_metrics)
+        wer_desc = ''
+        if training_args.predict_with_generate:
+            (wer_metric, pred_str, label_str) = compute_metrics(eval_preds, eval_labels)
+            eval_metrics.update(wer_metric)
+            wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in wer_metric.items()])
+        desc = f"Epoch... ({epoch + 1}/{num_epochs} | Eval Loss: {eval_metrics['loss']} | {wer_desc})"
+        epochs.write(desc)
+        epochs.desc = desc
+        if has_tensorboard and jax.process_index() == 0:
+            write_metric(summary_writer, train_metrics, eval_metrics, train_time, cur_step, training_args.logging_steps)
+        if has_wandb and jax.process_index() == 0:
+            write_wandb_metric(wandb_logger, eval_metrics, eval_time, cur_step, 'eval')
+            if training_args.predict_with_generate:
+                write_wandb_pred(wandb_logger, pred_str, label_str)
+        if jax.process_index() == 0:
+            params = jax.device_get(jax.tree_util.tree_map(lambda x: x[0], state.params))
+            model.save_pretrained(training_args.output_dir, params=params)
+            tokenizer.save_pretrained(training_args.output_dir)
+            if training_args.push_to_hub:
+                repo.push_to_hub(commit_message=f'Saving weights and logs of epoch {epoch + 1}', blocking=False)
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/run_long_form_transcription.py
+""""""
+import logging
+import os
+import sys
+import time
+from dataclasses import field
+from pathlib import Path
+from typing import Optional
+import datasets
+import flax
+import jax
+import jax.numpy as jnp
+import numpy as np
+import transformers
+from datasets import DatasetDict, IterableDatasetDict, load_dataset
+from jax.experimental.compilation_cache import compilation_cache as cc
+from jiwer import process_words, wer_default
+from nltk import ngrams
+from tqdm import tqdm
+from transformers import HfArgumentParser, Seq2SeqTrainingArguments, is_tensorboard_available, is_wandb_available
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+from distil_whisper import FlaxWhisperPipeline
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: pip install -r examples/flax/speech-recogintion/requirements.txt')
+logger = logging.getLogger(__name__)
+
+@flax.struct.dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    use_auth_token: bool = field(default=False, metadata={'help': 'Will use the token generated when running `transformers-cli login` (necessary to use this script with private models).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'Floating-point format in which the model weights should be initialized and trained. Choose one of `[float32, float16, bfloat16]`.'})
+    load_with_scan: Optional[bool] = field(default=False, metadata={'help': 'Whether to load the model with scan enabled. Required when the model was saved with scan enabled'})
+    return_timestamps: Optional[bool] = field(default=False, metadata={'help': 'Whether to predict timestamps (alongside the text predictions). Timestamp predictions are discarded at the end of inference, but may assist in the model in reducing hallucinations.'})
+    length_penalty: Optional[float] = field(default=1.0, metadata={'help': 'Exponential penalty to the length that is used with beam-based generation. It is applied as an exponent to the sequence length, which in turn is used to divide the score of the sequence. Since the score is the log likelihood of the sequence (i.e. negative), length_penalty > 1.0 promotes longer sequences, while length_penalty < 1.0 encourages shorter sequences.'})
+    do_sample: Optional[bool] = field(default=False, metadata={'help': 'Whether or not to use sampling ; use greedy decoding otherwise.'})
+    top_k: Optional[int] = field(default=50, metadata={'help': 'The number of the highest probability vocabulary tokens to keep for top-k-filtering.'})
+    temperature: Optional[float] = field(default=1.0, metadata={'help': 'The value used to modulate the next token probabilities if sampling.'})
+    chunk_length_s: Optional[float] = field(default=30.0, metadata={'help': "The input length for each chunk. By default, the chunklength is set 30.0s, equal to Whisper's context window."})
+    compilation_cache: Optional[str] = field(default=None, metadata={'help': 'Whether to enable the JAX (experimental) compilation cache. The compilation step is *cached* the first time it is run. Successive compilation steps for the same function utilise the cache to reducethe compilation time.'})
+
+@flax.struct.dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': "The name of the dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset hours by a '+' symbol."})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_split_name: Optional[str] = field(default=None, metadata={'help': 'The split name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default=None, metadata={'help': "The name of the dataset column containing the text data. Defaults to 'text'."})
+    max_label_length: int = field(default=256, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experiment reproducibility and to diff code across experiments in the UI.'})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and the data."})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of eval examples to this value if set.'})
+    log_audio: Optional[bool] = field(default=False, metadata={'help': 'For debugging purposes, record the audio samples as well as the ground truths / preds.'})
+    log_predictions: Optional[bool] = field(default=True, metadata={'help': 'Whether or not to log the ground truths / pred text to the wandb logger.'})
+    ngram_degree: Optional[int] = field(default=5, metadata={'help': 'Degree of n-grams used when computing duplicate n-grams in the predicted text.'})
+
+def write_metric(summary_writer, eval_metrics, prefix='eval'):
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.scalar(f'{prefix}/{metric_name}', value, 0)
+
+def write_wandb_metric(wandb_logger, metrics, train_time, prefix):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    wandb_logger.log(log_metrics)
+
+def convert_audio_to_wandb(wandb_logger, audio):
+    return wandb_logger.Audio(audio['array'][:, np.newaxis], sample_rate=audio['sampling_rate'])
+
+def write_wandb_pred(wandb_logger, eval_audios, pred_str, label_str, norm_pred_str, norm_label_str, prefix='eval'):
+    columns = ['Target', 'Pred', 'Norm Target', 'Norm Pred']
+    str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+    if len(eval_audios) > 0:
+        columns.insert(0, 'Audio')
+        str_data = [[convert_audio_to_wandb(wandb_logger, eval_audios[i]), *str_data[i]] for i in range(len(pred_str))]
+    wandb_logger.log({f'{prefix}/predictions': wandb_logger.Table(columns=columns, data=str_data)})
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_hours=None, default_split='train'):
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        for i in range(len(dataset_names)):
+            ds_name = dataset_names[i]
+            dataset_names[i] = f'distil-whisper/{ds_name}' if '/' not in ds_name else ds_name
+        dataset_config_names = dataset_config_names.split('+')
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_hours = dataset_hours.split('+') if dataset_hours is not None else None
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_hours is not None:
+        if len(dataset_hours) != len(dataset_names):
+            raise ValueError(f'Ensure one probability is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_hours)} hours.')
+        dataset_hours = [float(ds_hours) for ds_hours in dataset_hours]
+    else:
+        dataset_hours = [None] * len(dataset_names)
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'hours': dataset_hours[i]})
+    return dataset_names_dict
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    send_example_telemetry('run_flax_speech_recognition_seq2seq', model_args, data_args, framework='flax')
+    has_tensorboard = is_tensorboard_available()
+    if 'tensorboard' in training_args.report_to:
+        if has_tensorboard and jax.process_index() == 0:
+            try:
+                from flax.metrics.tensorboard import SummaryWriter
+                summary_writer = SummaryWriter(log_dir=Path(os.path.join(training_args.output_dir, 'runs')))
+            except ImportError as ie:
+                has_tensorboard = False
+                logger.warning(f'Unable to display metrics through TensorBoard because some packages are not installed: {ie}')
+        else:
+            logger.warning('Unable to display metrics through TensorBoard because the package is not installed: Please run `pip install tensorboard` to enable.')
+    has_wandb = is_wandb_available()
+    if 'wandb' in training_args.report_to:
+        if has_wandb and jax.process_index() == 0:
+            import wandb as wandb_logger
+            wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb)
+        else:
+            logger.warning('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    logger.setLevel(logging.INFO if jax.process_index() == 0 else logging.ERROR)
+    if jax.process_index() == 0:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Evaluation parameters %s', training_args)
+    if model_args.compilation_cache:
+        cc.initialize_cache(os.path.join(model_args.cache_dir, 'jax_cache'))
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    dataset_names_dict = convert_dataset_str_to_list(data_args.dataset_name, data_args.dataset_config_name, splits=data_args.dataset_split_name, text_column_names=data_args.text_column_name)
+    for dataset_dict in dataset_names_dict:
+        pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+        raw_datasets[pretty_name] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, use_auth_token=True if model_args.use_auth_token else None, streaming=data_args.streaming)
+        if dataset_dict['text_column_name'] not in list(raw_datasets[pretty_name].features.keys()):
+            raise ValueError(f"--text column name {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(raw_datasets[pretty_name].features.keys()))}")
+        if dataset_dict['text_column_name'] != 'text':
+            raw_datasets[pretty_name] = raw_datasets[pretty_name].rename_column(dataset_dict['text_column_name'], 'text')
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    audio_column_name = data_args.audio_column_name
+    if audio_column_name not in raw_datasets_features:
+        raise ValueError(f"--audio_column_name '{audio_column_name}' not found in dataset '{data_args.dataset_name}'. Make sure to set `--audio_column_name` to the correct audio column - one of {', '.join(raw_datasets_features)}.")
+    for split in raw_datasets:
+        raw_datasets[split] = raw_datasets[split].remove_columns(set(raw_datasets[split].features.keys()) - {audio_column_name, 'text'})
+    pipeline = FlaxWhisperPipeline(model_args.model_name_or_path, dtype=getattr(jnp, model_args.dtype), max_length=training_args.generation_max_length, cache_dir=model_args.cache_dir, revision=model_args.model_revision, use_auth_token=True if model_args.use_auth_token else None, subfolder=model_args.subfolder)
+    if pipeline.model.config.decoder_start_token_id is None:
+        raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+    if model_args.load_with_scan:
+        pipeline.model.disable_scan()
+        pipeline.params = pipeline.model.convert_scan_to_unroll(pipeline.params)
+    if data_args.max_eval_samples is not None:
+        for split in raw_datasets:
+            raw_datasets[split] = raw_datasets[split].take(data_args.max_eval_samples) if data_args.streaming else raw_datasets[split].select(range(data_args.max_eval_samples))
+    normalizer = EnglishTextNormalizer(pipeline.tokenizer.english_spelling_normalizer)
+
+    def compute_metrics(pred_str, label_str, ngram_degree=5):
+        norm_pred_str = [normalizer(pred).replace('.', '') for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer_output = process_words(norm_label_str, norm_pred_str, wer_default, wer_default)
+        wer_norm = 100 * wer_output.wer
+        ier_norm = 100 * wer_output.insertions / sum([len(ref) for ref in wer_output.references])
+        ser_norm = 100 * wer_output.substitutions / sum([len(ref) for ref in wer_output.references])
+        der_norm = 100 * wer_output.deletions / sum([len(ref) for ref in wer_output.references])
+        all_ngrams = list(ngrams(' '.join(norm_pred_str).split(), ngram_degree))
+        repeated_ngrams = len(all_ngrams) - len(set(all_ngrams))
+        return ({'wer': wer_norm, 'ier': ier_norm, 'ser': ser_norm, 'der': der_norm, 'repeated_ngrams': repeated_ngrams}, pred_str, label_str, norm_pred_str, norm_label_str)
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    eval_batch_size = per_device_eval_batch_size * jax.device_count()
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else pipeline.model.config.num_beams
+    generation_config = pipeline.model.generation_config
+    if hasattr(generation_config, 'is_multilingual') and generation_config.is_multilingual:
+        language = 'English'
+        task = 'transcribe'
+    else:
+        language = None
+        task = None
+    logger.info('Pre-compiling the generate call...')
+    random_inputs = {'input_features': np.ones((eval_batch_size, 80, 2 * pipeline.model.config.max_source_positions))}
+    pipeline.forward(random_inputs, batch_size=eval_batch_size, language=language, task=task, return_timestamps=model_args.return_timestamps, num_beams=num_beams, length_penalty=model_args.length_penalty, do_sample=model_args.do_sample, top_k=model_args.top_k, temperature=model_args.temperature)
+
+    def eval_step(split='eval'):
+        eval_preds = []
+        eval_labels = []
+        eval_audios = []
+        eval_start = time.time()
+        for sample in tqdm(raw_datasets[split], desc=f'Evaluating {split}...'):
+            label_str = sample['text']
+            if data_args.log_audio:
+                eval_audios.append(sample['audio'])
+            pred_str = pipeline(sample['audio'], batch_size=eval_batch_size, language=language, task=task, chunk_length_s=model_args.chunk_length_s, return_timestamps=model_args.return_timestamps, num_beams=num_beams, length_penalty=model_args.length_penalty, do_sample=model_args.do_sample, top_k=model_args.top_k, temperature=model_args.temperature)
+            eval_preds.append(pred_str['text'])
+            eval_labels.append(label_str)
+        eval_time = time.time() - eval_start
+        (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str) = compute_metrics(eval_preds, eval_labels, ngram_degree=data_args.ngram_degree)
+        wer_desc = ' '.join([f'{split} {key}: {value} |' for (key, value) in wer_metric.items()])
+        logger.info(wer_desc)
+        if has_tensorboard and jax.process_index() == 0 and ('tensorboard' in training_args.report_to):
+            write_metric(summary_writer, wer_metric, prefix=split)
+        if has_wandb and jax.process_index() == 0 and ('wandb' in training_args.report_to):
+            write_wandb_metric(wandb_logger, wer_metric, eval_time, prefix=split)
+            if data_args.log_predictions:
+                write_wandb_pred(wandb_logger, eval_audios, pred_str, label_str, norm_pred_str, norm_label_str, prefix=split)
+    logger.info('***** Running Eval *****')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_eval_batch_size}')
+    logger.info(f'  Total eval batch size (w. parallel & distributed) = {eval_batch_size}')
+    logger.info(f'  Beam size = {num_beams}')
+    if num_beams > 1:
+        logger.info(f'  Length penalty size = {model_args.length_penalty}')
+    logger.info(f'  Do sample = {model_args.do_sample}')
+    if model_args.do_sample:
+        logger.info(f'  Top k = {model_args.top_k}')
+        logger.info(f'  Temperature = {model_args.temperature}')
+    for split in raw_datasets:
+        eval_step(split=split)
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/run_pseudo_labelling_pt.py
+""""""
+import csv
+import logging
+import os
+import string
+import sys
+import time
+from dataclasses import dataclass, field
+from datetime import timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import datasets
+import evaluate
+import numpy as np
+import torch
+import transformers
+from accelerate import Accelerator, InitProcessGroupKwargs
+from accelerate.logging import get_logger
+from datasets import DatasetDict, IterableDatasetDict, load_dataset
+from huggingface_hub import HfFolder, Repository, create_repo, get_full_repo_name
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import HfArgumentParser, Seq2SeqTrainingArguments, WhisperConfig, WhisperFeatureExtractor, WhisperForConditionalGeneration, WhisperProcessor, WhisperTokenizerFast
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+check_min_version('4.34.0.dev0')
+require_version('datasets>=2.14.6', 'To fix: `pip install --upgrade datasets`')
+logger = get_logger(__name__)
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained Whisper model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    tokenizer_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'})
+    feature_extractor_name: Optional[str] = field(default=None, metadata={'help': 'feature extractor name or path if not the same as model_name'})
+    processor_name: Optional[str] = field(default=None, metadata={'help': 'processor name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    token: str = field(default=None, metadata={'help': 'The token to use as HTTP bearer authorization for remote files. If not specified, will use the token generated when running `huggingface-cli login` (stored in `~/.huggingface`).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'The data type (dtype) in which to load the model weights. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    attn_type: Optional[str] = field(default=None, metadata={'help': 'Which attention implementation to use in the encoder and decoder attention layers. Can be one of:\n1. `None`: default Transformers attention implementation.2. `flash_attn`: Flash Attention through PyTorch SDPA. Requires `torch>=2.0` and `optimum` to be installed. Recommended for hardware where Flash Attention 2 is not supported, e.g. Turing GPUs, (T4, RTX 2080)3. `flash_attn_2`: Flash Attention 2 through the Flash Attention package https://github.com/Dao-AILab/flash-attention. **Always** recommended on supported hardware (Ampere, Ada, or Hopper GPUs, e.g., A100, RTX 3090, RTX 4090, H100)'})
+    compile_encoder: Optional[bool] = field(default=True, metadata={'help': 'Whether or not to enable torch compile in the encoder module. Requires `torch>=2.0` to be installed.'})
+
+@dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': 'The name of the dataset to use (via the datasets library).'})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default='text', metadata={'help': "The name of the dataset column containing the text data. Defaults to 'text'."})
+    id_column_name: str = field(default='id', metadata={'help': "The name of the dataset column containing the id data. Defaults to 'id'"})
+    max_label_length: int = field(default=128, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    data_split_name: str = field(default='train+validation+test', metadata={'help': "The name of the data set splits to use (via the datasets library). Defaults to 'train+validation+test'. Multiple splits can be passed by splitting a list through the '+' character, e.g. 'train+validation' will pseudo-label both the 'train' and 'validation' splits sequentially."})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    streaming: bool = field(default=False, metadata={'help': "Whether to use dataset's streaming mode to load and pre-process the data."})
+    max_samples_per_split: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of examples per split to this value if set.'})
+    return_timestamps: bool = field(default=False, metadata={'help': 'Whether to return the timestamps with the text. This enables the `FlaxWhisperTimestampsLogitsProcessor`.'})
+    language: str = field(default=None, metadata={'help': 'Language for multilingual distillation. This argument should be set for multilingual distillation only. For English speech recognition, it should be left as `None`.'})
+    task: str = field(default='transcribe', metadata={'help': 'Task, either `transcribe` for speech recognition or `translate` for speech translation.This argument should be set for multilingual distillation only. For English speech recognition, it should be left as `None`.'})
+    decode_token_ids: bool = field(default=True, metadata={'help': 'Whether or not to decode the predicted token ids to text transcriptions.'})
+    private_dataset: bool = field(default=False, metadata={'help': 'Whether or not to create a private dataset for the pseudo-labelled data.'})
+
+def shift_tokens_right(label_ids: np.array, decoder_start_token_id: int) -> np.ndarray:
+    shifted_label_ids = np.zeros_like(label_ids)
+    shifted_label_ids[:, 1:] = label_ids[:, :-1]
+    shifted_label_ids[:, 0] = decoder_start_token_id
+    return shifted_label_ids
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+    decoder_start_token_id: int
+    decoder_prev_token_id: int
+    input_padding: Union[bool, str] = 'max_length'
+    target_padding: Union[bool, str] = 'max_length'
+    max_target_length: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], np.ndarray]]]) -> Dict[str, np.ndarray]:
+        model_input_name = self.processor.model_input_names[0]
+        input_features = {model_input_name: [feature[model_input_name] for feature in features]}
+        label_features = {'input_ids': [feature['labels'] for feature in features]}
+        file_ids = {'input_ids': [feature['file_id'] for feature in features]}
+        batch = self.processor.feature_extractor.pad(input_features, padding=self.input_padding, return_tensors='pt')
+        labels_batch = self.processor.tokenizer.pad(label_features, max_length=self.max_target_length, padding=self.target_padding, return_tensors='pt')
+        file_ids_batch = self.processor.tokenizer.pad(file_ids, max_length=self.max_target_length, padding=self.target_padding, return_tensors='pt')
+        labels = labels_batch['input_ids'].masked_fill(labels_batch.attention_mask.ne(1), -100)
+        if set(torch.unique(labels[:, 0])).issubset({self.decoder_start_token_id, self.decoder_prev_token_id}):
+            labels = labels[:, 1:]
+        bos_index = torch.argmax((labels == self.decoder_start_token_id).long(), dim=1)
+        prompt_mask = torch.arange(labels.shape[1]) < bos_index[:, None]
+        labels = torch.where(prompt_mask, -100, labels)
+        batch['labels'] = labels
+        batch['file_ids'] = file_ids_batch['input_ids']
+        return batch
+
+def log_metric(accelerator, metrics: Dict, train_time: float, prefix: str='eval'):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    accelerator.log(log_metrics)
+
+def log_pred(accelerator, pred_str: List[str], label_str: List[str], norm_pred_str: List[str], norm_label_str: List[str], prefix: str='eval', num_lines: int=200000):
+    if accelerator.is_main_process:
+        wandb_tracker = accelerator.get_tracker('wandb')
+        prefix = prefix.replace('/', '-')
+        str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+        wandb_tracker.log_table(table_name=f'{prefix}/all_predictions', columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data[:num_lines])
+        str_data = np.asarray(str_data)
+        str_data_incorrect = str_data[str_data[:, -2] != str_data[:, -1]]
+        wandb_tracker.log_table(table_name=f'{prefix}/incorrect_predictions', columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data_incorrect[:num_lines])
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    if model_args.dtype == 'float16':
+        mixed_precision = 'fp16'
+        torch_dtype = torch.float16
+    elif model_args.dtype == 'bfloat16':
+        mixed_precision = 'bf16'
+        torch_dtype = torch.bfloat16
+    else:
+        mixed_precision = 'no'
+        torch_dtype = torch.float32
+    kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=7200))
+    accelerator = Accelerator(gradient_accumulation_steps=training_args.gradient_accumulation_steps, mixed_precision=mixed_precision, log_with=training_args.report_to, project_dir=training_args.output_dir, kwargs_handlers=[kwargs])
+    accelerator.init_trackers(project_name=data_args.wandb_project)
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
+    logger.warning(f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, distributed training: {training_args.parallel_mode.value == 'distributed'}, 16-bits training: {training_args.fp16}")
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Training/evaluation parameters %s', training_args)
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    token = model_args.token if model_args.token is not None else HfFolder().get_token()
+    data_splits = data_args.data_split_name.split('+')
+    for split in data_splits:
+        if data_args.streaming:
+            raw_datasets[split] = load_dataset(data_args.dataset_name, data_args.dataset_config_name, split=split, cache_dir=data_args.dataset_cache_dir, token=token, streaming=True)
+        else:
+            raw_datasets[split] = load_dataset(data_args.dataset_name, data_args.dataset_config_name, split=split, cache_dir=data_args.dataset_cache_dir, token=token, streaming=False, num_proc=data_args.preprocessing_num_workers)
+    if data_args.audio_column_name not in next(iter(raw_datasets.values())).column_names:
+        raise ValueError(f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. Make sure to set `--audio_column_name` to the correct audio column - one of {', '.join(next(iter(raw_datasets.values())).column_names)}.")
+    if data_args.text_column_name not in next(iter(raw_datasets.values())).column_names:
+        raise ValueError(f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. Make sure to set `--text_column_name` to the correct text column - one of {', '.join(next(iter(raw_datasets.values())).column_names)}.")
+    config = WhisperConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=token)
+    feature_extractor = WhisperFeatureExtractor.from_pretrained(model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=token)
+    tokenizer = WhisperTokenizerFast.from_pretrained(model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_fast=model_args.use_fast_tokenizer, revision=model_args.model_revision, token=token)
+    processor = WhisperProcessor.from_pretrained(model_args.processor_name if model_args.processor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=token)
+    model = WhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, cache_dir=model_args.cache_dir, revision=model_args.model_revision, subfolder=model_args.subfolder, token=token, low_cpu_mem_usage=True, torch_dtype=torch_dtype, use_flash_attention_2=model_args.attn_type == 'flash_attn_2')
+    if model_args.attn_type == 'flash_attn':
+        model = model.to_bettertransformer()
+    elif model_args.attn_type not in [None, 'flash_attn', 'flash_attn_2']:
+        raise ValueError(f'Argument `attn_type` is set to {model_args.attn_type}. Should be one of:1. `None`: default Transformers attention implementation.2. `flash_attn`: Flash Attention through PyTorch SDPA. Requires `torch>=2.0` and `optimum` to be installed. Recommended for hardware where Flash Attention 2 is not supported, e.g. Turing GPUs, (T4, RTX 2080).3. `flash_attn_2`: Flash Attention 2 through the Flash Attention package https://github.com/Dao-AILab/flash-attention. **Always** recommended on supported hardware (Ampere, Ada, or Hopper GPUs, e.g., A100, RTX 3090, RTX 4090, H100).')
+    if model_args.compile_encoder:
+        model.model.encoder.forward = torch.compile(model.model.encoder.forward, mode='reduce-overhead', fullgraph=True)
+    model.eval()
+    if model.config.decoder_start_token_id is None:
+        raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+    return_timestamps = data_args.return_timestamps
+    if hasattr(model.generation_config, 'is_multilingual') and model.generation_config.is_multilingual:
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task, predict_timestamps=return_timestamps)
+    elif data_args.language is not None:
+        raise ValueError('Setting language token for an English-only checkpoint is not permitted. The language argument should only be set for multilingual checkpoints.')
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate))
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else model.config.max_length
+    audio_column_name = data_args.audio_column_name
+    num_workers = data_args.preprocessing_num_workers
+    dataloader_num_workers = training_args.dataloader_num_workers
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    id_column_name = data_args.id_column_name
+    normalizer = EnglishTextNormalizer(tokenizer.english_spelling_normalizer)
+    if data_args.max_samples_per_split is not None:
+        for split in data_splits:
+            raw_datasets[split] = raw_datasets[split].take(data_args.max_samples_per_split) if data_args.streaming else raw_datasets[split].select(range(data_args.max_samples_per_split))
+
+    def prepare_dataset(batch):
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        input_str = batch[text_column_name]
+        batch['labels'] = tokenizer(input_str, max_length=max_label_length, truncation=True).input_ids
+        batch['file_id'] = tokenizer(batch[id_column_name], add_special_tokens=False).input_ids
+        return batch
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    if data_args.streaming:
+        vectorized_datasets = raw_datasets.map(prepare_dataset, remove_columns=raw_datasets_features)
+    else:
+        vectorized_datasets = raw_datasets.map(prepare_dataset, remove_columns=raw_datasets_features, num_proc=num_workers, desc='preprocess dataset')
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    if data_args.streaming and dataloader_num_workers > 0:
+        logger.warning('Using multiple dataloader num workers with streaming mode will result in different shards of data being transcribed in parallel. This is not advised if you want to preserve the order of the audio-text data.')
+    output_dir = training_args.output_dir
+    if training_args.push_to_hub:
+        if training_args.hub_model_id is None:
+            repo_name = get_full_repo_name(Path(output_dir).absolute().name, token=token)
+        else:
+            repo_name = training_args.hub_model_id
+        create_repo(repo_name, exist_ok=True, token=token, repo_type='dataset', private=data_args.private_dataset)
+        repo = Repository(output_dir, clone_from=repo_name, token=token, repo_type='dataset')
+        with open(os.path.join(output_dir, '.gitattributes'), 'r+') as f:
+            git_lfs_extensions = f.read()
+            if '*.csv' not in git_lfs_extensions:
+                f.write('*.csv filter=lfs diff=lfs merge=lfs -text')
+    elif not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    metric = evaluate.load('wer')
+    all_punctuation = list(string.punctuation.replace("'", ''))
+
+    def compute_metrics(preds, labels, file_ids):
+        for idx in range(len(labels)):
+            labels[idx][labels[idx] == -100] = tokenizer.pad_token_id
+        pred_str = tokenizer.batch_decode(preds, skip_special_tokens=True, decode_with_timestamps=return_timestamps)
+        label_str = tokenizer.batch_decode(labels, skip_special_tokens=True)
+        spaced_pred_str = [pred_str[i].replace(punctuation, f' {punctuation} ') for punctuation in all_punctuation for i in range(len(pred_str))]
+        spaced_label_str = [label_str[i].replace(punctuation, f' {punctuation} ') for punctuation in all_punctuation for i in range(len(label_str))]
+        wer_ortho = 100 * metric.compute(predictions=spaced_pred_str, references=spaced_label_str)
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        file_ids = [file_ids[i] for i in range(len(file_ids)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return ({'wer': wer, 'wer_ortho': wer_ortho}, pred_str, label_str, norm_pred_str, norm_label_str, file_ids)
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor, decoder_start_token_id=model.config.decoder_start_token_id, decoder_prev_token_id=tokenizer.all_special_ids[-3], input_padding='longest', target_padding='max_length', max_target_length=max_label_length)
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else getattr(model.generation_config, 'num_beams', 1)
+    gen_kwargs = {'max_length': max_label_length, 'num_beams': num_beams, 'return_timestamps': return_timestamps}
+    if hasattr(model.generation_config, 'is_multilingual') and model.generation_config.is_multilingual:
+        gen_kwargs.update({'language': data_args.language, 'task': data_args.task})
+    model = accelerator.prepare(model)
+
+    def eval_step_with_save(split='eval'):
+        eval_preds = []
+        eval_labels = []
+        eval_ids = []
+        eval_start = time.time()
+        eval_loader = DataLoader(vectorized_datasets[split], batch_size=per_device_eval_batch_size, collate_fn=data_collator, num_workers=dataloader_num_workers, pin_memory=True)
+        eval_loader = accelerator.prepare(eval_loader)
+        batches = tqdm(eval_loader, desc=f'Evaluating {split}...', disable=not accelerator.is_local_main_process)
+        split = split.replace('.', '-').split('/')[-1]
+        output_csv = os.path.join(output_dir, f'{split}-transcription.csv')
+        for (step, batch) in enumerate(batches):
+            file_ids = batch.pop('file_ids')
+            generated_ids = model.module.generate(batch['input_features'].to(dtype=torch_dtype), **gen_kwargs)
+            generated_ids = accelerator.pad_across_processes(generated_ids, dim=1, pad_index=tokenizer.pad_token_id)
+            (file_ids, generated_ids, labels) = accelerator.gather_for_metrics((file_ids, generated_ids, batch['labels']))
+            eval_preds.extend(generated_ids.cpu().numpy())
+            eval_labels.extend(labels.cpu().numpy())
+            file_ids = tokenizer.batch_decode(file_ids, skip_special_tokens=True)
+            eval_ids.extend(file_ids)
+            if step % training_args.logging_steps == 0 and step > 0:
+                batches.write(f'Saving transcriptions for split {split} step {step}')
+                accelerator.wait_for_everyone()
+                if data_args.decode_token_ids:
+                    eval_preds = tokenizer.batch_decode(eval_preds, skip_special_tokens=True, decode_with_timestamps=return_timestamps)
+                csv_data = [[eval_ids[i], eval_preds[i]] for i in range(len(eval_preds))]
+                with open(output_csv, 'w', encoding='UTF8', newline='') as f:
+                    writer = csv.writer(f)
+                    writer.writerow(['file_id', 'whisper_transcript'])
+                    writer.writerows(csv_data)
+                if training_args.push_to_hub and accelerator.is_main_process:
+                    repo.push_to_hub(commit_message=f'Saving transcriptions for split {split} step {step}.', blocking=False)
+        accelerator.wait_for_everyone()
+        eval_time = time.time() - eval_start
+        wer_desc = ''
+        if 'validation' in split or 'test' in split:
+            (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str, eval_ids) = compute_metrics(eval_preds, eval_labels, eval_ids)
+            wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in wer_metric.items()])
+            log_metric(accelerator, metrics=wer_metric, train_time=eval_time, prefix=split)
+            log_pred(accelerator, pred_str, label_str, norm_pred_str, norm_label_str, prefix=split)
+            if data_args.decode_token_ids:
+                eval_preds = pred_str
+        elif data_args.decode_token_ids:
+            eval_preds = tokenizer.batch_decode(eval_preds, skip_special_tokens=True, decode_with_timestamps=return_timestamps)
+        batches.write(f'Saving final transcriptions for split {split}.')
+        csv_data = [[eval_ids[i], eval_preds[i]] for i in range(len(eval_preds))]
+        with open(output_csv, 'w', encoding='UTF8', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow(['file_id', 'whisper_transcript'])
+            writer.writerows(csv_data)
+        logger.info(wer_desc)
+        if not data_args.streaming:
+            raw_datasets[split] = raw_datasets[split].add_column('whisper_transcript', eval_preds)
+    logger.info('***** Running Labelling *****')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_eval_batch_size}')
+    logger.info(f'  Total eval batch size (w. parallel & distributed) = {training_args.per_device_eval_batch_size * accelerator.num_processes}')
+    logger.info(f'  Predict labels with timestamps = {return_timestamps}')
+    logger.info(f'  Decode labels to transcriptions = {data_args.decode_token_ids}')
+    for split in data_splits:
+        eval_step_with_save(split=split)
+        accelerator.wait_for_everyone()
+        if training_args.push_to_hub and accelerator.is_main_process:
+            repo.push_to_hub(commit_message=f"Saving final transcriptions for split {split.replace('.', '-').split('/')[-1]}", blocking=False)
+    if not data_args.streaming and accelerator.is_main_process:
+        raw_datasets.save_to_disk(output_dir, num_proc=num_workers)
+        if training_args.push_to_hub:
+            raw_datasets.push_to_hub(repo_name, config_name=data_args.dataset_config_name)
+    accelerator.end_training()
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/run_pt_long_form_transcription.py
+""""""
+import logging
+import os
+import sys
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+import datasets
+import numpy as np
+import torch
+import transformers
+from datasets import DatasetDict, IterableDatasetDict, load_dataset
+from jiwer import process_words, wer_default
+from nltk import ngrams
+from tqdm import tqdm
+from transformers import HfArgumentParser, Seq2SeqTrainingArguments, WhisperTokenizer, is_tensorboard_available, is_wandb_available, pipeline
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: update `datasets` to the latest version: `pip install --upgrade datasets[audio]`')
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    use_auth_token: bool = field(default=False, metadata={'help': 'Will use the token generated when running `transformers-cli login` (necessary to use this script with private models).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'Floating-point format in which the model weights should be initialized and evaluated. Choose one of `[float32, float16, bfloat16]`.'})
+    return_timestamps: Optional[bool] = field(default=False, metadata={'help': 'Whether to predict timestamps (alongside the text predictions). Timestamp predictions are discarded at the end of inference, but may assist in the model in reducing hallucinations.'})
+    length_penalty: Optional[float] = field(default=1.0, metadata={'help': 'Exponential penalty to the length that is used with beam-based generation. It is applied as an exponent to the sequence length, which in turn is used to divide the score of the sequence. Since the score is the log likelihood of the sequence (i.e. negative), length_penalty > 1.0 promotes longer sequences, while length_penalty < 1.0 encourages shorter sequences.'})
+    do_sample: Optional[bool] = field(default=False, metadata={'help': 'Whether or not to use sampling ; use greedy decoding otherwise.'})
+    top_k: Optional[int] = field(default=50, metadata={'help': 'The number of the highest probability vocabulary tokens to keep for top-k-filtering.'})
+    temperature: Optional[float] = field(default=1.0, metadata={'help': 'The value used to modulate the next token probabilities if sampling.'})
+    chunk_length_s: Optional[float] = field(default=0, metadata={'help': 'The input length for each chunk. By default, the chunk length is set to 0, which means no chunking.'})
+
+@dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': "The name of the dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset hours by a '+' symbol."})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_split_name: Optional[str] = field(default=None, metadata={'help': 'The split name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default=None, metadata={'help': "The name of the dataset column containing the text data. Defaults to 'text'."})
+    max_label_length: int = field(default=256, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experiment reproducibility and to diff code across experiments in the UI.'})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and the data."})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of eval examples to this value if set.'})
+    log_audio: Optional[bool] = field(default=False, metadata={'help': 'For debugging purposes, record the audio samples as well as the ground truths / preds.'})
+    log_predictions: Optional[bool] = field(default=True, metadata={'help': 'Whether or not to log the ground truths / pred text to the wandb logger.'})
+    ngram_degree: Optional[int] = field(default=5, metadata={'help': 'Degree of n-grams used when computing duplicate n-grams in the predicted text.'})
+
+def write_metric(summary_writer, eval_metrics, prefix='eval'):
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.add_scalar(f'{prefix}/{metric_name}', value, 0)
+
+def write_wandb_metric(wandb_logger, metrics, train_time, prefix):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    wandb_logger.log(log_metrics)
+
+def convert_audio_to_wandb(wandb_logger, audio):
+    return wandb_logger.Audio(audio['array'][:, np.newaxis], sample_rate=audio['sampling_rate'])
+
+def write_wandb_pred(wandb_logger, eval_audios, pred_str, label_str, norm_pred_str, norm_label_str, prefix='eval'):
+    columns = ['Target', 'Pred', 'Norm Target', 'Norm Pred']
+    str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+    if len(eval_audios) > 0:
+        columns.insert(0, 'Audio')
+        str_data = [[convert_audio_to_wandb(wandb_logger, eval_audios[i]), *str_data[i]] for i in range(len(pred_str))]
+    wandb_logger.log({f'{prefix}/predictions': wandb_logger.Table(columns=columns, data=str_data)})
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_hours=None, default_split='train'):
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        for i in range(len(dataset_names)):
+            ds_name = dataset_names[i]
+            dataset_names[i] = f'distil-whisper/{ds_name}' if '/' not in ds_name else ds_name
+        dataset_config_names = dataset_config_names.split('+')
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_hours = dataset_hours.split('+') if dataset_hours is not None else None
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_hours is not None:
+        if len(dataset_hours) != len(dataset_names):
+            raise ValueError(f'Ensure one probability is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_hours)} hours.')
+        dataset_hours = [float(ds_hours) for ds_hours in dataset_hours]
+    else:
+        dataset_hours = [None] * len(dataset_names)
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'hours': dataset_hours[i]})
+    return dataset_names_dict
+
+def data(dataset, text_column_name='text', log_audio=False):
+    for item in dataset:
+        yield {**item['audio'], 'reference': item[text_column_name], 'audio': item['audio'] if log_audio else None}
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    has_tensorboard = is_tensorboard_available()
+    if 'tensorboard' in training_args.report_to:
+        if has_tensorboard:
+            try:
+                from torch.utils.tensorboard import SummaryWriter
+                summary_writer = SummaryWriter(log_dir=os.path.join(training_args.output_dir, 'runs'))
+            except ImportError as ie:
+                has_tensorboard = False
+                logger.warning(f'Unable to display metrics through TensorBoard because some package are not installed: {ie}')
+        else:
+            logger.warning('Unable to display metrics through TensorBoard because the package is not installed: Please run `pip install tensorboard` to enable.')
+    has_wandb = is_wandb_available()
+    if 'wandb' in training_args.report_to:
+        if has_wandb:
+            import wandb as wandb_logger
+            wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb)
+        else:
+            logger.warning('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    logger.setLevel(logging.INFO)
+    datasets.utils.logging.set_verbosity_warning()
+    transformers.utils.logging.set_verbosity_info()
+    logger.info('Evaluation parameters %s', training_args)
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    dataset_names_dict = convert_dataset_str_to_list(data_args.dataset_name, data_args.dataset_config_name, splits=data_args.dataset_split_name, text_column_names=data_args.text_column_name)
+    for dataset_dict in dataset_names_dict:
+        pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+        raw_datasets[pretty_name] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, use_auth_token=True if model_args.use_auth_token else None, streaming=data_args.streaming)
+        if dataset_dict['text_column_name'] not in list(raw_datasets[pretty_name].features.keys()):
+            raise ValueError(f"--text column name {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(raw_datasets[pretty_name].features.keys()))}")
+        if dataset_dict['text_column_name'] != 'text':
+            raw_datasets[pretty_name] = raw_datasets[pretty_name].rename_column(dataset_dict['text_column_name'], 'text')
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    audio_column_name = data_args.audio_column_name
+    if audio_column_name not in raw_datasets_features:
+        raise ValueError(f"--audio_column_name '{audio_column_name}' not found in dataset '{data_args.dataset_name}'. Make sure to set `--audio_column_name` to the correct audio column - one of {', '.join(raw_datasets_features)}.")
+    for split in raw_datasets:
+        raw_datasets[split] = raw_datasets[split].remove_columns(set(raw_datasets[split].features.keys()) - {audio_column_name, 'text'})
+    if data_args.max_eval_samples is not None:
+        for split in raw_datasets:
+            raw_datasets[split] = raw_datasets[split].take(data_args.max_eval_samples) if data_args.streaming else raw_datasets[split].select(range(data_args.max_eval_samples))
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else 1
+    model_kwargs = {'cache_dir': model_args.cache_dir, 'use_auth_token': True if model_args.use_auth_token else None, 'subfolder': model_args.subfolder}
+    pipe = pipeline('automatic-speech-recognition', model_args.model_name_or_path, torch_dtype=getattr(torch, model_args.dtype), model_kwargs=model_kwargs, max_new_tokens=training_args.generation_max_length, batch_size=per_device_eval_batch_size, chunk_length_s=model_args.chunk_length_s, return_timestamps=model_args.return_timestamps, device='cuda:0' if torch.cuda.is_available() else 'cpu')
+    if pipe.model.can_generate():
+        if pipe.model.config.decoder_start_token_id is None:
+            raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+        generate_kwargs = {'num_beams': num_beams, 'length_penalty': model_args.length_penalty, 'do_sample': model_args.do_sample, 'top_k': model_args.top_k, 'temperature': model_args.temperature}
+        if hasattr(pipe.model.generation_config, 'is_multilingual') and pipe.model.generation_config.is_multilingual:
+            generate_kwargs = generate_kwargs.update({'langauge': 'English', 'task': 'transcribe'})
+    else:
+        generate_kwargs = None
+    whisper_tokenizer = WhisperTokenizer.from_pretrained('openai/whisper-tiny.en')
+    normalizer = EnglishTextNormalizer(whisper_tokenizer.english_spelling_normalizer)
+
+    def compute_metrics(pred_str, label_str, ngram_degree=5):
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer_output = process_words(norm_label_str, norm_pred_str, wer_default, wer_default)
+        wer_norm = 100 * wer_output.wer
+        ier_norm = 100 * wer_output.insertions / sum([len(ref) for ref in wer_output.references])
+        ser_norm = 100 * wer_output.substitutions / sum([len(ref) for ref in wer_output.references])
+        der_norm = 100 * wer_output.deletions / sum([len(ref) for ref in wer_output.references])
+        all_ngrams = list(ngrams(' '.join(norm_pred_str).split(), ngram_degree))
+        repeated_ngrams = len(all_ngrams) - len(set(all_ngrams))
+        return ({'wer': wer_norm, 'ier': ier_norm, 'ser': ser_norm, 'der': der_norm, 'repeated_ngrams': repeated_ngrams}, pred_str, label_str, norm_pred_str, norm_label_str)
+
+    def eval_step(split='eval'):
+        eval_preds = []
+        eval_labels = []
+        eval_audios = []
+        eval_start = time.time()
+        for sample in tqdm(pipe(data(raw_datasets[split], log_audio=data_args.log_audio), generate_kwargs=generate_kwargs), desc=f'Evaluating {split}...'):
+            eval_preds.append(sample['text'])
+            eval_labels.append(sample['reference'][0])
+            if data_args.log_audio:
+                eval_audios.append(sample['audio'][0])
+        eval_time = time.time() - eval_start
+        (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str) = compute_metrics(eval_preds, eval_labels, data_args.ngram_degree)
+        wer_desc = ' '.join([f'{split} {key}: {value} |' for (key, value) in wer_metric.items()])
+        logger.info(wer_desc)
+        if has_tensorboard and 'tensorboard' in training_args.report_to:
+            write_metric(summary_writer, wer_metric, prefix=split)
+        if has_wandb and 'wandb' in training_args.report_to:
+            write_wandb_metric(wandb_logger, wer_metric, eval_time, prefix=split)
+            if data_args.log_predictions:
+                write_wandb_pred(wandb_logger, eval_audios, pred_str, label_str, norm_pred_str, norm_label_str, prefix=split)
+    logger.info('***** Running Eval *****')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_eval_batch_size}')
+    logger.info(f'  Total eval batch size (w. parallel & distributed) = {training_args.per_device_eval_batch_size}')
+    if pipe.model.can_generate():
+        logger.info(f'  Beam size = {num_beams}')
+        if num_beams > 1:
+            logger.info(f'  Length penalty size = {model_args.length_penalty}')
+        logger.info(f'  Do sample = {model_args.do_sample}')
+        if model_args.do_sample:
+            logger.info(f'  Top k = {model_args.top_k}')
+            logger.info(f'  Temperature = {model_args.temperature}')
+    for split in raw_datasets:
+        eval_step(split=split)
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/flax/run_speculative_decoding.py
+import copy
+import time
+import torch
+from datasets import load_dataset
+from transformers import AutoProcessor, WhisperForConditionalGeneration
+DEVICE = 'cuda'
+DTYPE = torch.float16
+SAMPLING_RATE = 16000
+BATCH_SIZE = 1
+USE_FLASH_ATTN_2 = True
+GAMMAS = [5, 7, 6, 5, 4, 3, 5]
+COUNT = 0
+teacher = WhisperForConditionalGeneration.from_pretrained('/home/patrick/distil_whisper/', torch_dtype=DTYPE, variant='fp16', low_cpu_mem_usage=True, use_flash_attention_2=USE_FLASH_ATTN_2)
+student = WhisperForConditionalGeneration.from_pretrained('/home/patrick/distil_whisper_student/', torch_dtype=DTYPE, variant='fp16', low_cpu_mem_usage=True, use_flash_attention_2=USE_FLASH_ATTN_2)
+student.generation_config = copy.deepcopy(teacher.generation_config)
+student.generation_config.num_assistant_tokens_schedule = 'constant'
+teacher.to(DEVICE)
+student.to(DEVICE)
+processor = AutoProcessor.from_pretrained('sanchit-gandhi/large-32-2-gpu-flat-lr')
+ds = load_dataset('hf-internal-testing/librispeech_asr_dummy', 'clean', split='validation')
+total_time_default = 0
+total_time_spec = 0
+total_time_spec_2 = 0
+input_values = ds[0]['audio']['array']
+inputs = processor(input_values, return_tensors='pt', sampling_rate=SAMPLING_RATE)
+input_features = inputs.input_features.to(device=DEVICE, dtype=DTYPE)
+_ = teacher.generate(input_features, max_length=100)
+end_idx = ds.shape[0]
+for audio_idx in range(0, end_idx, BATCH_SIZE):
+    input_values = ds[audio_idx:audio_idx + BATCH_SIZE]
+    input_values = [i['array'] for i in input_values['audio']]
+    inputs = processor(input_values, return_tensors='pt', sampling_rate=SAMPLING_RATE)
+    input_features = inputs.input_features.to(device=DEVICE, dtype=DTYPE)
+    start_time = time.time()
+    out = teacher.generate(input_features, max_length=100)
+    run_time = time.time() - start_time
+    print(f'Normal Decoding: {run_time}')
+    total_time_default += run_time
+    default_out = processor.batch_decode(out, skip_special_tokens=True)
+    start_time = time.time()
+    with torch.no_grad():
+        encoder_outputs = teacher.get_encoder()(input_features)
+    out = teacher.generate(assistant_model=student, assistant_encoder_outputs=encoder_outputs, encoder_outputs=encoder_outputs, max_length=100)
+    run_time = time.time() - start_time
+    spec_out_2 = processor.batch_decode(out, skip_special_tokens=True)
+    print(f'Speculative Decoding 2: {run_time}')
+    total_time_spec_2 += run_time
+    if spec_out_2 != default_out:
+        COUNT += 1
+        print(f'Audio {audio_idx} does not match. Spec: {spec_out_2}, True: {default_out}')
+print(20 * '=')
+print('Total time', total_time_default)
+print(f'Overall speed-up spec 2 {total_time_default / total_time_spec_2}')
+
+# File: distil-whisper-main/training/flax/run_speed_pt.py
+""""""
+import json
+import logging
+import os
+import string
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+import datasets
+import evaluate
+import numpy as np
+import torch
+import transformers
+import whisper
+from datasets import DatasetDict, IterableDatasetDict, load_dataset
+from tqdm import tqdm
+from transformers import HfArgumentParser, WhisperForConditionalGeneration, WhisperProcessor, is_wandb_available, pipeline
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer
+from transformers.models.whisper.modeling_whisper import WhisperForCausalLM
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+check_min_version('4.27.0.dev0')
+require_version('datasets>=1.18.0', 'To fix: pip install -r examples/flax/speech-recogintion/requirements.txt')
+logger = logging.getLogger(__name__)
+PIPELINE_BATCH_SIZE = 16
+
+@dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': "The name of the dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset hours by a '+' symbol."})
+    model_name_or_path: str = field(default=None, metadata={'help': 'The name of the model to use (via the transformers library). '})
+    assistant_model_name_or_path: str = field(default=None, metadata={'help': 'The name of the assistant model to use to do speculative decoding. If None, no speculative decoding will be done.'})
+    use_fp16: bool = field(default=True, metadata={'help': 'Whether to evaluate in fp16'})
+    use_torch_compile: bool = field(default=False, metadata={'help': 'Whether to compile the model'})
+    use_orig_whisper: bool = field(default=False, metadata={'help': 'Whether to evaluate with orig whisper'})
+    use_bf16: bool = field(default=False, metadata={'help': 'Whether to evaluate in bf16'})
+    use_pipeline: bool = field(default=False, metadata={'help': 'Whether to evaluate with Transformers pipeline'})
+    chunk_length_s: float = field(default=30.0, metadata={'help': 'Chunk length to use when `use_pipeline` is enabled.'})
+    return_timestamps: bool = field(default=False, metadata={'help': 'Whether to decode with timestamps. This can help for improved WER for long form evaluation.'})
+    attn_type: Optional[str] = field(default=None, metadata={'help': "Which attn type to use: None, 'flash', 'compile', 'flash+compile'"})
+    batch_size: int = field(default=1, metadata={'help': 'The batch size used for evluation.'})
+    num_beams: int = field(default=1, metadata={'help': 'The beam size used for evluation.'})
+    samples_per_dataset: Optional[int] = field(default=None, metadata={'help': 'Number of samples per dataset used to measure speed.'})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_split_name: Optional[str] = field(default=None, metadata={'help': 'The split name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default=None, metadata={'help': 'The name of the dataset column containing the text data. Defaults to `text`.'})
+    max_duration_in_seconds: float = field(default=30.0, metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'})
+    min_duration_in_seconds: float = field(default=0.0, metadata={'help': 'Filter audio files that are shorter than `min_duration_in_seconds` seconds'})
+    max_label_length: int = field(default=128, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    max_gen_length: int = field(default=128, metadata={'help': 'Generate up until max_gen_length tokens.'})
+    pad_target_to_multiple_of: Optional[int] = field(default=None, metadata={'help': 'If set will pad the target sequence to a multiple of the provided value. This is important to avoid triggering recompilations on TPU. If unspecified, will default to padding the targets to max length.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    wandb_project: str = field(default='distil-whisper-speed-benchmark', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experiment reproducibility and to diff code across experiments in the UI.'})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and the data."})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of eval examples to this value if set.'})
+    log_audio: Optional[bool] = field(default=False, metadata={'help': 'For debugging purposes, record the audio samples as well as the ground truths / preds.'})
+
+def write_metric(summary_writer, eval_metrics, step, prefix='eval'):
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.scalar(f'{prefix}/{metric_name}', value, step)
+
+def write_wandb_metric(wandb_logger, metrics, train_time, prefix):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    wandb_logger.log(log_metrics)
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_hours=None, default_split='train'):
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        for i in range(len(dataset_names)):
+            ds_name = dataset_names[i]
+            dataset_names[i] = f'distil-whisper/{ds_name}' if '/' not in ds_name else ds_name
+        dataset_config_names = dataset_config_names.split('+')
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_hours = dataset_hours.split('+') if dataset_hours is not None else None
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_hours is not None:
+        if len(dataset_hours) != len(dataset_names):
+            raise ValueError(f'Ensure one probability is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_hours)} hours.')
+        dataset_hours = [float(ds_hours) for ds_hours in dataset_hours]
+    else:
+        dataset_hours = [None] * len(dataset_names)
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'hours': dataset_hours[i]})
+    return dataset_names_dict
+
+def main():
+    parser = HfArgumentParser([DataTrainingArguments])
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        data_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))[0]
+    else:
+        data_args = parser.parse_args_into_dataclasses()[0]
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    if data_args.use_pipeline and data_args.batch_size > 1:
+        raise ValueError('Make sure that `batch_size` is set to 1 when `use_pipeline=True`.')
+    has_wandb = is_wandb_available()
+    if has_wandb:
+        import wandb
+        import wandb as wandb_logger
+        wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb)
+        wandb_logger.log({'torch_version': str(torch.__version__)})
+        wandb_logger.log({'transformers_version': str(transformers.__version__)})
+        wandb_logger.log({'batch_size': data_args.batch_size})
+        if data_args.use_pipeline:
+            wandb_logger.log({'chunk_length_s': data_args.chunk_length_s})
+    else:
+        raise ValueError('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    dataset_names_dict = convert_dataset_str_to_list(data_args.dataset_name, data_args.dataset_config_name, splits=data_args.dataset_split_name, text_column_names=data_args.text_column_name)
+    if len(dataset_names_dict) == 1:
+        dataset_dict = dataset_names_dict[0]
+        raw_datasets['eval'] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, use_auth_token=True, streaming=data_args.streaming)
+        if dataset_dict['text_column_name'] not in list(raw_datasets['eval'].features.keys()):
+            raise ValueError(f"--text column name {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(raw_datasets['eval'].features.keys()))}")
+        if dataset_dict['text_column_name'] != 'text':
+            raw_datasets['eval'] = raw_datasets['eval'].rename_column(dataset_dict['text_column_name'], 'text')
+    else:
+        for dataset_dict in tqdm(dataset_names_dict, desc='Loading datasets...'):
+            pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+            raw_datasets[pretty_name] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, use_auth_token=True, streaming=data_args.streaming)
+            if dataset_dict['text_column_name'] not in list(raw_datasets[pretty_name].features.keys()):
+                raise ValueError(f"`--text_column_name` {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(raw_datasets[pretty_name].features.keys()))}")
+            if dataset_dict['text_column_name'] != 'text':
+                raw_datasets[pretty_name] = raw_datasets[pretty_name].rename_column(dataset_dict['text_column_name'], 'text')
+    processor = WhisperProcessor.from_pretrained(data_args.model_name_or_path)
+    dtype = torch.float16 if data_args.use_fp16 else torch.float32
+    if data_args.use_bf16:
+        dtype = torch.bfloat16
+    use_flash_attention_2 = data_args.attn_type is not None and 'flash2' in data_args.attn_type
+    result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
+    gpu_type = [x for x in result.stdout.split('=') if len(x) > 1][1].split('0')[1].split()
+    use_sdpa = False
+    if gpu_type[0] == 'Tesla' and use_flash_attention_2:
+        use_flash_attention_2 = False
+        use_sdpa = True
+    use_orig_whisper = False
+    if data_args.use_orig_whisper:
+        use_orig_whisper = True
+        model_name = data_args.model_name_or_path.split('/')[-1].split('whisper-')[-1]
+        model = whisper.load_model(model_name)
+        model.cuda()
+    else:
+        model = WhisperForConditionalGeneration.from_pretrained(data_args.model_name_or_path, torch_dtype=dtype, use_flash_attention_2=use_flash_attention_2)
+        model.cuda()
+    if use_sdpa:
+        logger.info('Use SDPA via BetterTransformers...')
+        model.to_bettertransformer()
+    if data_args.use_torch_compile:
+        logger.info('Enabling torch compile for the encoder.')
+        model.model.encoder.forward = torch.compile(model.model.encoder.forward, mode='reduce-overhead', fullgraph=True)
+        input_values = np.random.randn(data_args.batch_size, 16000)
+        input_features = processor(input_values, return_tensors='pt', sampling_rate=16000).input_features
+        input_features = input_features.to(dtype=dtype, device=model.device)
+        for _ in range(3):
+            _ = model.generate(input_features)
+    model_pipeline = None
+    if data_args.use_pipeline:
+        model_pipeline = pipeline('automatic-speech-recognition', model=model, tokenizer=processor.tokenizer, feature_extractor=processor.feature_extractor, torch_dtype=dtype, device=model.device, chunk_length_s=data_args.chunk_length_s)
+        model_pipeline_forward = model_pipeline._forward
+    assistant_model = None
+    if data_args.assistant_model_name_or_path is not None:
+        logger.info('Loading assistant model...')
+        if data_args.assistant_model_name_or_path.startswith('openai'):
+            assistant_model = WhisperForConditionalGeneration.from_pretrained(data_args.assistant_model_name_or_path, torch_dtype=dtype, use_flash_attention_2=use_flash_attention_2)
+        else:
+            assistant_model = WhisperForCausalLM.from_pretrained(data_args.assistant_model_name_or_path, torch_dtype=dtype, use_flash_attention_2=use_flash_attention_2)
+        assistant_model.cuda()
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=processor.feature_extractor.sampling_rate))
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else model.config.max_length
+    audio_column_name = data_args.audio_column_name
+    num_workers = data_args.preprocessing_num_workers
+    model_input_name = processor.feature_extractor.model_input_names[0]
+    normalizer = EnglishTextNormalizer(processor.tokenizer.english_spelling_normalizer)
+    if data_args.max_eval_samples is not None:
+        for split in raw_datasets:
+            raw_datasets[split] = raw_datasets[split].take(data_args.max_eval_samples) if data_args.streaming else raw_datasets[split].select(range(data_args.max_eval_samples))
+
+    def prepare_dataset(batch):
+        sample = batch[audio_column_name]
+        if model_pipeline is None and (not use_orig_whisper):
+            inputs = processor.feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'], return_tensors='pt')
+            batch[model_input_name] = inputs.get(model_input_name)
+        else:
+            batch[model_input_name] = sample['array']
+        batch['length_in_s'] = len(sample['array']) / sample['sampling_rate']
+        input_str = batch['text']
+        batch['labels'] = processor.tokenizer(input_str, max_length=max_label_length, truncation=True).input_ids
+        return batch
+    vectorized_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    for split in raw_datasets:
+        raw_datasets_features = list(raw_datasets[split].features.keys())
+        map_fn = partial(raw_datasets[split].map, function=prepare_dataset, remove_columns=raw_datasets_features)
+        vectorized_datasets[split] = map_fn(num_proc=num_workers, desc='preprocess eval dataset') if not data_args.streaming else map_fn()
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    metric = evaluate.load('wer')
+    list(string.punctuation.replace("'", ''))
+
+    def compute_metrics(pred_str, label_str):
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        if len(norm_pred_str) == 0 or len(norm_label_str) == 0:
+            return 0.0
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return wer
+    result_datasets = DatasetDict()
+
+    def benchmark(batch):
+        if model_pipeline is None and (not use_orig_whisper):
+            inputs = torch.cat(batch[model_input_name], dim=0).cuda()
+            if data_args.use_fp16:
+                inputs = inputs.to(torch.float16)
+            if data_args.use_bf16:
+                inputs = inputs.to(torch.bfloat16)
+            inner_batch_size = inputs.shape[0]
+        else:
+            inner_batch_size = 1
+            inputs = batch[model_input_name]
+        gen_kwargs = {'return_timestamps': data_args.return_timestamps, 'max_length': data_args.max_gen_length}
+        if not data_args.model_name_or_path.endswith('.en') and (not data_args.model_name_or_path.endswith('24-2')):
+            gen_kwargs['language'] = '<|en|>'
+            gen_kwargs['task'] = 'transcribe'
+            gen_kwargs['num_beams'] = data_args.num_beams
+        if use_orig_whisper:
+            raw_audio = inputs[0].astype(np.float32)
+            out_dict = model.transcribe(raw_audio)
+            batch['transcription'] = [out_dict['text']]
+            batch['time'] = [out_dict['all_time']]
+        elif model_pipeline is not None:
+            time_result = []
+
+            def _forward_time(*args, **kwargs):
+                start_time = time.time()
+                result = model_pipeline_forward(*args, **kwargs)
+                end_time = time.time() - start_time
+                time_result.append(end_time)
+                return result
+            model_pipeline._forward = _forward_time
+            result = model_pipeline(inputs, batch_size=PIPELINE_BATCH_SIZE, generate_kwargs=gen_kwargs)[0]['text']
+            batch['transcription'] = [result]
+            batch['time'] = [sum(time_result)]
+        elif assistant_model is not None:
+            gen_kwargs['assistant_model'] = assistant_model
+            start_time = time.time()
+            with torch.no_grad():
+                encoder_outputs = model.get_encoder()(inputs)
+            gen_kwargs['encoder_outputs'] = encoder_outputs
+            if data_args.assistant_model_name_or_path.startswith('openai'):
+                with torch.no_grad():
+                    assistant_encoder_outputs = assistant_model.get_encoder()(inputs)
+                gen_kwargs['assistant_encoder_outputs'] = assistant_encoder_outputs
+            else:
+                gen_kwargs['assistant_encoder_outputs'] = encoder_outputs
+            output_ids = model.generate(**gen_kwargs)
+            batch['time'] = inner_batch_size * [(time.time() - start_time) / inner_batch_size]
+            batch['transcription'] = processor.batch_decode(output_ids, skip_special_tokens=True)
+        else:
+            start_time = time.time()
+            output_ids = model.generate(inputs, **gen_kwargs)
+            batch['time'] = inner_batch_size * [(time.time() - start_time) / inner_batch_size]
+            batch['transcription'] = processor.batch_decode(output_ids, skip_special_tokens=True)
+        batch['length_in_s'] = batch['length_in_s']
+        batch['reference'] = processor.batch_decode(batch['labels'], skip_special_tokens=True)
+        batch['num_words'] = [len(r.split()) for r in batch['reference']]
+        return batch
+    for split in vectorized_datasets:
+        vectorized_datasets_features = [model_input_name]
+        map_fn = partial(vectorized_datasets[split].map, function=benchmark, remove_columns=vectorized_datasets_features, batch_size=data_args.batch_size, batched=True)
+        result_datasets[split] = map_fn(num_proc=1, desc='benchmark eval dataset') if not data_args.streaming else map_fn()
+    stats_dataset = DatasetDict()
+    all_stats = {'times_audio_total': 0, 'times_transcription_total': 0, 'num_words_total': 0, 'num_samples': 0, 'time_per_sample': 0, 'rtf': 0, 'words_per_s': 0, 'wer': 0}
+    count = 0
+    for split in result_datasets:
+        transcriptions = []
+        references = []
+        stats = {k: 0 for k in all_stats.keys()}
+        print(f'Start benchmarking {split}...')
+        if data_args.streaming:
+            result_iter = iter(result_datasets[split])
+        for result in result_iter:
+            stats['times_audio_total'] += result['length_in_s']
+            stats['times_transcription_total'] += result['time']
+            stats['num_words_total'] += result['num_words']
+            stats['num_samples'] += 1
+            transcriptions.append(result['transcription'])
+            references.append(result['reference'])
+            count += 1
+            print(f'Processed {count} samples...')
+            if data_args.samples_per_dataset is not None and stats['num_samples'] == data_args.samples_per_dataset:
+                break
+        stats['time_per_sample'] = stats['times_transcription_total'] / stats['num_samples']
+        stats['avg_length_sample'] = stats['times_audio_total'] / stats['num_samples']
+        stats['wer'] = compute_metrics(transcriptions, references)
+        stats['rtf'] = stats['times_audio_total'] / stats['times_transcription_total']
+        stats['words_per_s'] = stats['num_words_total'] / stats['times_transcription_total']
+        stats_dataset[split] = stats
+        log_stats = {f'{split}_{k}': v for (k, v) in stats.items()}
+        wandb_logger.log(log_stats)
+        all_stats['times_audio_total'] += stats['times_audio_total']
+        all_stats['times_transcription_total'] += stats['times_transcription_total']
+        all_stats['wer'] += stats['wer']
+        all_stats['num_samples'] += stats['num_samples']
+        all_stats['num_words_total'] += stats['num_words_total']
+    all_stats['time_per_sample'] = all_stats['times_transcription_total'] / all_stats['num_samples']
+    all_stats['avg_length_sample'] = all_stats['times_audio_total'] / all_stats['num_samples']
+    all_stats['wer'] = all_stats['wer'] / len(result_datasets)
+    all_stats['rtf'] = all_stats['times_audio_total'] / all_stats['times_transcription_total']
+    all_stats['words_per_s'] = all_stats['num_words_total'] / all_stats['times_transcription_total']
+    stats_dataset['all'] = all_stats
+    log_all_stats = {f'all_{k}': v for (k, v) in all_stats.items()}
+    wandb_logger.log(log_all_stats)
+    benchmark_artifact = wandb.Artifact('Benchmark', type='datasets')
+    with tempfile.TemporaryDirectory() as temp_dir:
+        for split in stats_dataset:
+            file_name = os.path.join(temp_dir, f"{'_'.join(split.split('/'))}.json")
+            with open(file_name, 'w') as json_file:
+                json.dump(stats_dataset[split], json_file)
+            benchmark_artifact.add_file(file_name, split)
+        wandb_logger.log_artifact(benchmark_artifact)
+    print('Done!')
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/run_distillation.py
+""""""
+import logging
+import os
+import re
+import shutil
+import sys
+import time
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import datasets
+import evaluate
+import numpy as np
+import torch
+import torch.nn as nn
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from datasets import DatasetDict, IterableDataset, IterableDatasetDict, concatenate_datasets, interleave_datasets, load_dataset
+from huggingface_hub import create_repo, get_full_repo_name, upload_folder
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AddedToken, HfArgumentParser, Seq2SeqTrainingArguments, WhisperConfig, WhisperFeatureExtractor, WhisperForConditionalGeneration, WhisperProcessor, WhisperTokenizerFast, get_scheduler
+from transformers.modeling_outputs import BaseModelOutput
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer, EnglishTextNormalizer
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+check_min_version('4.34.0.dev0')
+require_version('datasets>=2.14.6', 'To fix: `pip install --upgrade datasets`')
+logger = get_logger(__name__)
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained Whisper model or model identifier from huggingface.co/models'})
+    teacher_model_name_or_path: str = field(metadata={'help': 'Path to pretrained teacher model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    tokenizer_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'})
+    feature_extractor_name: Optional[str] = field(default=None, metadata={'help': 'feature extractor name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    token: str = field(default=None, metadata={'help': 'The token to use as HTTP bearer authorization for remote files. If not specified, will use the token generated when running `huggingface-cli login` (stored in `~/.huggingface`).'})
+    attn_implementation: Optional[str] = field(default=None, metadata={'help': 'Which attention implementation to use in the encoder and decoder attention layers. Can be one of:\n1. `eager` or `None`: default Transformers attention implementation.\n2. `sdpa`: Flash Attention through PyTorch SDPA. Requires `torch>=2.1`. Recommended for hardware where Flash Attention 2 is not supported, e.g. Turing GPUs, (T4, RTX 2080).\n3. `flash_attn_2`: Flash Attention 2 through the Flash Attention package https://github.com/Dao-AILab/flash-attention. **Always** recommended on supported hardware (Ampere, Ada, or Hopper GPUs, e.g., A100, RTX 3090, RTX 4090, H100).'})
+
+    def __post_init__(self):
+        if self.attn_implementation not in [None, 'eager', 'sdpa', 'flash_attention_2']:
+            raise ValueError(f'Got `--attn_implementation={self.attn_implementation}`, which is an invalid attention type. Should be one of:\n1. `eager` or `None`: default Transformers attention implementation.\n2. `sdpa`: Flash Attention through PyTorch SDPA. Requires `torch>=2.1`. Recommended for hardware where Flash Attention 2 is not supported, e.g. Turing GPUs, (T4, RTX 2080).\n3. `flash_attn_2`: Flash Attention 2 through the Flash Attention package https://github.com/Dao-AILab/flash-attention. **Always** recommended on supported hardware (Ampere, Ada, or Hopper GPUs, e.g., A100, RTX 3090, RTX 4090, H100).')
+
+@dataclass
+class DataTrainingArguments:
+    train_dataset_name: str = field(default=None, metadata={'help': "The name of the training dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset ids by a '+' symbol. For example, to load LibriSpeech and Common Voice, set `train_dataset_name='librispeech_asr+common_voice'`."})
+    train_dataset_config_name: Optional[str] = field(default=None, metadata={'help': "The configuration name of the training dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset configs by a '+' symbol. Note that the order of the configs should match the order of the datasets."})
+    train_dataset_samples: str = field(default=None, metadata={'help': 'Number of samples in each dataset when loading multiple datasets with streaming mode. Not required when using one dataset or non-streaming mode. The sample values provide the sampling probability for each dataset. Setting them equal to the number of sample values ensures that every sample from every dataset is used once per epoch.'})
+    eval_dataset_name: str = field(default=None, metadata={'help': "The name of the evaluation dataset to use (via the datasets library). Defaults to the training dataset name if unspecified. Load multiple evaluation datasets by separating dataset ids by a '+' symbol."})
+    eval_dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the evaluation dataset to use (via the datasets library). Defaults to the training dataset config name if unspecified.'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing if using non-streaming mode.'})
+    preprocessing_batch_size: Optional[int] = field(default=256, metadata={'help': 'Number of examples per batch provided to the `prepare_dataset` function.'})
+    max_train_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes or quicker training, truncate the number of training examples to this value if set.'})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes or quicker training, truncate the number of evaluation examples to this value if set.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default=None, metadata={'help': 'The name of the dataset column containing the text data in the training set.'})
+    eval_text_column_name: str = field(default='text', metadata={'help': 'The name of the dataset column containing the text data in the evaluation set.'})
+    max_duration_in_seconds: float = field(default=30.0, metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'})
+    min_duration_in_seconds: float = field(default=0.0, metadata={'help': 'Filter audio files that are shorter than `min_duration_in_seconds` seconds'})
+    max_label_length: int = field(default=448, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    pad_target_to_multiple_of: Optional[int] = field(default=None, metadata={'help': 'If set will pad the target sequence to a multiple of the provided value. This is important to avoid triggering recompilations on TPU. If unspecified, will default to padding the targets to max length.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    train_split_name: str = field(default='train', metadata={'help': "The name of the training data set split to use (via the datasets library). Defaults to 'train'"})
+    eval_split_name: str = field(default='validation', metadata={'help': "The name of the evaluation data set split to use (via the datasets library). Defaults to 'validation'"})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and pre-process the data."})
+    wer_threshold: float = field(default=None, metadata={'help': 'Filter training data with Whisper transcriptions that have greater than `wer_threshold` WER with the normalised transcriptions. This only takes effect if training on pseudo-labels targets.If `--use_pseudo_labels=False`, then no WER filtering is performed, since we train directly on the texttranscriptions.'})
+    use_pseudo_labels: bool = field(default=True, metadata={'help': 'Whether or not to use pseudo-label transcriptions as the targets. If True, the pseudo-labels must be in the dataset column `whisper_transcript` from the previous pseudo-labelling step. This is not currently yet configurable.'})
+    timestamp_probability: float = field(default=0.2, metadata={'help': 'Probability for training on timestamped tokens if the data contains it.'})
+    condition_on_prev_probability: float = field(default=0.2, metadata={'help': 'Probability for conditioning on the previous text example.'})
+    return_timestamps: bool = field(default=False, metadata={'help': 'Whether or not to predict timestamps in the generation step.'})
+    language: str = field(default=None, metadata={'help': 'Language for multilingual distillation. This argument should be set for multilingual distillation only. For English speech recognition, it should be left as `None`.'})
+    task: str = field(default='transcribe', metadata={'help': 'Task, either `transcribe` for speech recognition or `translate` for speech translation.This argument should be set for multilingual distillation only. For English speech recognition, it should be left as `None`.'})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_dir: str = field(default='./wandb', metadata={'help': 'The dir where wandb metadata will be stored.'})
+
+@dataclass
+class DistillationTrainingArguments(Seq2SeqTrainingArguments):
+    freeze_encoder: Optional[bool] = field(default=False, metadata={'help': 'Whether to freeze the entire encoder model. Only recommended when the entire encoder has been copied from the teacher model.'})
+    freeze_decoder: Optional[bool] = field(default=False, metadata={'help': 'Whether to freeze the entire decoder model. Note that the decoder input embeddings are **not** frozen, since they are tied to the LM head.'})
+    freeze_embed_positions: Optional[bool] = field(default=False, metadata={'help': 'Whether to freeze the decoder embedding positions.'})
+    temperature: Optional[float] = field(default=2.0, metadata={'help': 'Temperature to anneal the logits when computing the softmax.'})
+    kl_weight: Optional[float] = field(default=1.0, metadata={'help': 'Weighting assigned to the MSE loss in the KD formulation. MSE loss is computed between the teacher-student hidden states and attentions.'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'The data type (dtype) in which to run training. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    save_best_total_limit: Optional[int] = field(default=1, metadata={'help': 'Number of best models to be saved.'})
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+    decoder_start_token_id: int
+    decoder_prev_token_id: int
+    input_padding: Union[bool, str] = 'max_length'
+    target_padding: Union[bool, str] = 'max_length'
+    max_target_length: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], np.ndarray]]]) -> Dict[str, np.ndarray]:
+        input_features = {'input_features': [feature['input_features'] for feature in features]}
+        label_features = {'input_ids': [feature['labels'] for feature in features]}
+        batch = self.processor.feature_extractor.pad(input_features, padding=self.input_padding, return_tensors='pt')
+        labels_batch = self.processor.tokenizer.pad(label_features, max_length=self.max_target_length, padding=self.target_padding, return_tensors='pt')
+        labels = labels_batch['input_ids']
+        decoder_input_ids = labels[:, :-1]
+        labels = labels[:, 1:]
+        labels_mask = labels_batch.attention_mask[:, 1:]
+        labels = labels.masked_fill(labels_mask.ne(1), -100)
+        bos_index = torch.argmax((labels == self.decoder_start_token_id).long(), dim=1)
+        bos_index = torch.where(bos_index > 0, bos_index + 1, bos_index)
+        prompt_mask = torch.arange(labels.shape[1]) < bos_index[:, None]
+        labels = torch.where(prompt_mask, -100, labels)
+        batch['labels'] = labels
+        batch['decoder_input_ids'] = decoder_input_ids
+        return batch
+
+def log_metric(accelerator, metrics: Dict, train_time: float, step: int, epoch: int, learning_rate: float=None, prefix: str='train'):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    log_metrics[f'{prefix}/epoch'] = epoch
+    if learning_rate is not None:
+        log_metrics[f'{prefix}/learning_rate'] = learning_rate
+    accelerator.log(log_metrics, step=step)
+
+def log_pred(accelerator, pred_str: List[str], label_str: List[str], norm_pred_str: List[str], norm_label_str: List[str], step: int, prefix: str='eval', num_lines: int=200000):
+    if accelerator.is_main_process:
+        wandb_tracker = accelerator.get_tracker('wandb')
+        cur_step_pretty = f'{int(step // 1000)}k' if step > 1000 else step
+        prefix_pretty = prefix.replace('/', '-')
+        str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+        wandb_tracker.log_table(table_name=f'predictions/{prefix_pretty}-step-{cur_step_pretty}', columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data[:num_lines], step=step)
+        str_data = np.asarray(str_data)
+        str_data_incorrect = str_data[str_data[:, -2] != str_data[:, -1]]
+        wandb_tracker.log_table(table_name=f'incorrect_predictions/{prefix_pretty}-step-{cur_step_pretty}', columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data_incorrect[:num_lines], step=step)
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_samples=None, default_split='train') -> List[Dict]:
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        dataset_config_names = dataset_config_names.split('+') if dataset_config_names is not None else None
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_samples = dataset_samples.split('+') if dataset_samples is not None else None
+    if dataset_config_names is not None and len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_samples is not None:
+        if len(dataset_samples) != len(dataset_names):
+            raise ValueError(f'Ensure one sample is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_samples)} samples.')
+        dataset_samples = [float(ds_sample) for ds_sample in dataset_samples]
+    else:
+        dataset_samples = [None] * len(dataset_names)
+    dataset_config_names = dataset_config_names if dataset_config_names is not None else ['default' for _ in range(len(dataset_names))]
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'samples': dataset_samples[i]})
+    return dataset_names_dict
+
+def load_multiple_datasets(dataset_names: Union[List, str], dataset_config_names: Union[List, str], splits: Optional[Union[List, str]]=None, text_column_names: Optional[List]=None, sampling_rate: Optional[int]=16000, stopping_strategy: Optional[str]='first_exhausted', dataset_samples: Optional[Union[List, np.array]]=None, streaming: Optional[bool]=True, seed: Optional[int]=None, accelerator: Optional[Accelerator]=None, use_pseudo_labels: float=None, **kwargs) -> IterableDataset:
+    dataset_names_dict = convert_dataset_str_to_list(dataset_names, dataset_config_names, splits, text_column_names, dataset_samples)
+    if dataset_samples is not None:
+        dataset_samples = [ds_dict['samples'] for ds_dict in dataset_names_dict]
+        probabilities = np.array(dataset_samples) / np.sum(dataset_samples)
+    else:
+        probabilities = None
+    all_datasets = []
+    for dataset_dict in tqdm(dataset_names_dict, desc='Combining datasets...', disable=not accelerator.is_local_main_process if accelerator is not None else False):
+        dataset = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], streaming=streaming, **kwargs)
+        dataset = dataset.cast_column('audio', datasets.features.Audio(sampling_rate))
+        dataset_features = dataset.features.keys()
+        columns_to_keep = {'audio', 'text'}
+        if dataset_dict['text_column_name'] not in dataset_features:
+            raise ValueError(f"Text column name {dataset_dict['text_column_name']} not found in dataset '{dataset_dict['name']}'. Make sure to set `--text_column_name` to the correct text column - one of {', '.join(dataset_features)}.")
+        if dataset_dict['text_column_name'] != 'text':
+            dataset = dataset.rename_column(dataset_dict['text_column_name'], 'text')
+        if use_pseudo_labels:
+            if 'whisper_transcript' not in dataset_features:
+                raise ValueError(f"Pseudo-label column `whisper_transcript` not found in dataset {dataset_dict['name']}. Ensurepseudo-labels are present in the dataset under this column name, or train directly on the text labels by setting `--use_pseudo_labels=False` and defining the appropriate `--text_column_name`.")
+            columns_to_keep.add('whisper_transcript')
+        if 'condition_on_prev' in dataset_features:
+            columns_to_keep.add('condition_on_prev')
+        dataset_features = dataset.features.keys()
+        dataset = dataset.remove_columns(set(dataset_features - columns_to_keep))
+        all_datasets.append(dataset)
+    if len(all_datasets) == 1:
+        return all_datasets[0]
+    if streaming:
+        interleaved_dataset = interleave_datasets(all_datasets, stopping_strategy=stopping_strategy, probabilities=probabilities, seed=seed)
+    else:
+        interleaved_dataset = concatenate_datasets(all_datasets)
+    return interleaved_dataset
+
+def sorted_checkpoints(output_dir=None, checkpoint_prefix='checkpoint') -> List[str]:
+    ordering_and_checkpoint_path = []
+    glob_checkpoints = [str(x) for x in Path(output_dir).glob(f'{checkpoint_prefix}-*') if os.path.isdir(x)]
+    glob_checkpoints = [path for path in glob_checkpoints if 'val-wer' not in path]
+    for path in glob_checkpoints:
+        regex_match = re.match(f'.*{checkpoint_prefix}-([0-9]+)', path)
+        if regex_match is not None and regex_match.groups() is not None:
+            ordering_and_checkpoint_path.append((int(regex_match.groups()[0]), path))
+    checkpoints_sorted = sorted(ordering_and_checkpoint_path)
+    checkpoints_sorted = [checkpoint[1] for checkpoint in checkpoints_sorted]
+    return checkpoints_sorted
+
+def sorted_best_checkpoints(output_dir=None, checkpoint_prefix='checkpoint'):
+    ordering_and_checkpoint_path = []
+    glob_checkpoints = [str(x) for x in Path(output_dir).glob(f'{checkpoint_prefix}-*') if os.path.isdir(x)]
+    for path in glob_checkpoints:
+        regex_match = re.search('val-wer-([0-9]+\\.[0-9]+)', path)
+        if regex_match is not None and regex_match.groups() is not None:
+            ordering_and_checkpoint_path.append((regex_match.groups(1), path))
+    checkpoints_sorted = sorted(ordering_and_checkpoint_path, reverse=True)
+    checkpoints_sorted = [checkpoint[1] for checkpoint in checkpoints_sorted]
+    return checkpoints_sorted
+
+def rotate_checkpoints(save_total_limit=None, output_dir=None, checkpoint_prefix='checkpoint', sorting_fn=sorted_checkpoints) -> None:
+    if save_total_limit is None or save_total_limit <= 0:
+        return
+    checkpoints_sorted = sorting_fn(output_dir=output_dir, checkpoint_prefix=checkpoint_prefix)
+    if len(checkpoints_sorted) <= save_total_limit:
+        return
+    number_of_checkpoints_to_delete = max(0, len(checkpoints_sorted) - save_total_limit)
+    checkpoints_to_be_deleted = checkpoints_sorted[:number_of_checkpoints_to_delete]
+    for checkpoint in checkpoints_to_be_deleted:
+        logger.info(f'Deleting older checkpoint [{checkpoint}].')
+        shutil.rmtree(checkpoint, ignore_errors=True)
+_RE_CHECKPOINT = re.compile('^checkpoint-(\\d+)-epoch-(\\d+)$')
+
+def get_last_checkpoint(folder):
+    content = os.listdir(folder)
+    checkpoints = [path for path in content if _RE_CHECKPOINT.search(path) is not None and os.path.isdir(os.path.join(folder, path))]
+    if len(checkpoints) == 0:
+        return
+    return os.path.join(folder, max(checkpoints, key=lambda x: int(_RE_CHECKPOINT.search(x).groups()[0])))
+
+def get_parameter_names(model, forbidden_layer_types, forbidden_module=None):
+    result = []
+    for (name, child) in model.named_children():
+        result += [f'{name}.{n}' for n in get_parameter_names(child, forbidden_layer_types, forbidden_module) if not (isinstance(child, tuple(forbidden_layer_types)) or (child in tuple(forbidden_module) if forbidden_module is not None else False))]
+    result += list(model._parameters.keys())
+    return result
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, DistillationTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    if training_args.dtype == 'float16':
+        mixed_precision = 'fp16'
+        teacher_dtype = torch.float16
+    elif training_args.dtype == 'bfloat16':
+        mixed_precision = 'bf16'
+        teacher_dtype = torch.bfloat16
+    else:
+        mixed_precision = 'no'
+        teacher_dtype = torch.float32
+    accelerator = Accelerator(gradient_accumulation_steps=training_args.gradient_accumulation_steps, mixed_precision=mixed_precision, log_with=training_args.report_to, project_dir=training_args.output_dir)
+    accelerator.init_trackers(project_name=data_args.wandb_project, init_kwargs={'wandb': {'name': data_args.wandb_name, 'dir': data_args.wandb_dir}})
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
+    logger.warning(f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, distributed training: {training_args.parallel_mode.value == 'distributed'}, 16-bits training: {training_args.fp16}")
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Training/evaluation parameters %s', training_args)
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and (not training_args.overwrite_output_dir):
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(f'Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome.')
+        elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
+            logger.info(f'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change the `--output_dir` or add `--overwrite_output_dir` to train from scratch.')
+    if accelerator.is_main_process:
+        if training_args.push_to_hub:
+            if training_args.hub_model_id is None:
+                repo_name = get_full_repo_name(Path(training_args.output_dir).absolute().name, token=training_args.hub_token)
+            else:
+                repo_name = training_args.hub_model_id
+            create_repo(repo_name, exist_ok=True, token=training_args.hub_token)
+            with open(os.path.join(training_args.output_dir, '.gitignore'), 'w+') as gitignore:
+                if 'wandb' not in gitignore:
+                    gitignore.write('wandb\n')
+        elif training_args.output_dir is not None:
+            os.makedirs(training_args.output_dir, exist_ok=True)
+    accelerator.wait_for_everyone()
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    set_seed(training_args.seed)
+    if training_args.do_train:
+        raw_datasets['train'] = load_multiple_datasets(data_args.train_dataset_name, data_args.train_dataset_config_name, splits=data_args.train_split_name, text_column_names=data_args.text_column_name, use_pseudo_labels=data_args.use_pseudo_labels, streaming=data_args.streaming, dataset_samples=data_args.train_dataset_samples, seed=training_args.seed, accelerator=accelerator, cache_dir=data_args.dataset_cache_dir, token=model_args.token)
+        raw_datasets_train_features = list(raw_datasets['train'].features.keys())
+    if training_args.do_eval:
+        dataset_names_dict = convert_dataset_str_to_list(data_args.eval_dataset_name if data_args.eval_dataset_name else data_args.train_dataset_name, data_args.eval_dataset_config_name if data_args.eval_dataset_config_name else data_args.train_dataset_config_name, splits=data_args.eval_split_name, text_column_names=data_args.eval_text_column_name)
+        all_eval_splits = []
+        if len(dataset_names_dict) == 1:
+            dataset_dict = dataset_names_dict[0]
+            all_eval_splits.append('eval')
+            raw_datasets['eval'] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, token=model_args.token, streaming=data_args.streaming)
+            if data_args.eval_text_column_name != 'text':
+                raw_datasets['eval'] = raw_datasets['eval'].rename_column(data_args.eval_text_column_name, 'text')
+        else:
+            for dataset_dict in dataset_names_dict:
+                if dataset_dict['name'] == 'esb/diagnostic-dataset':
+                    pretty_name = f"{dataset_dict['config']}-diagnostic/{dataset_dict['split']}"
+                else:
+                    pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+                all_eval_splits.append(pretty_name)
+                raw_datasets[pretty_name] = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, token=model_args.token, streaming=data_args.streaming)
+                if dataset_dict['text_column_name'] != 'text':
+                    raw_datasets[pretty_name] = raw_datasets[pretty_name].rename_column(dataset_dict['text_column_name'], 'text')
+                raw_datasets[pretty_name] = raw_datasets[pretty_name].remove_columns(set(raw_datasets[pretty_name].features.keys()) - {'audio', 'text'})
+    if not training_args.do_train and (not training_args.do_eval):
+        raise ValueError('Cannot not train and not do evaluation. At least one of training or evaluation has to be performed.')
+    config = WhisperConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=model_args.token)
+    feature_extractor = WhisperFeatureExtractor.from_pretrained(model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=model_args.token)
+    tokenizer = WhisperTokenizerFast.from_pretrained(model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_fast=model_args.use_fast_tokenizer, revision=model_args.model_revision, token=model_args.token)
+    timestamps = [AddedToken('<|%.2f|>' % (i * 0.02), lstrip=False, rstrip=False) for i in range(1500 + 1)]
+    tokenizer.add_tokens(timestamps)
+    teacher_model = WhisperForConditionalGeneration.from_pretrained(model_args.teacher_model_name_or_path, cache_dir=model_args.cache_dir, token=model_args.token, low_cpu_mem_usage=True, torch_dtype=teacher_dtype, attn_implementation=model_args.attn_implementation)
+    student_model = WhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, cache_dir=model_args.cache_dir, revision=model_args.model_revision, subfolder=model_args.subfolder, token=model_args.token, low_cpu_mem_usage=True, attn_implementation=model_args.attn_implementation)
+    if student_model.config.decoder_start_token_id is None or teacher_model.config.decoder_start_token_id is None:
+        raise ValueError(f'Make sure that `config.decoder_start_token_id` is correctly defined for both the student and teacher model. Got {student_model.config.decoder_start_token_id} for the student and {teacher_model.config.decoder_start_token_id} for the teacher.')
+    if training_args.gradient_checkpointing:
+        student_model.gradient_checkpointing_enable()
+
+    def set_trainable_parameters(module, requires_grad=False):
+        for param in module.parameters():
+            param.requires_grad = requires_grad
+        module._requires_grad = requires_grad
+    if training_args.freeze_encoder:
+        set_trainable_parameters(student_model.model.encoder, requires_grad=False)
+        student_model.model.encoder.gradient_checkpointing = False
+    if training_args.freeze_decoder:
+        set_trainable_parameters(student_model.model.decoder, requires_grad=False)
+        student_model.model.decoder.gradient_checkpointing = False
+        set_trainable_parameters(student_model.proj_out, requires_grad=True)
+    if training_args.freeze_embed_positions:
+        set_trainable_parameters(student_model.model.decoder.embed_positions, requires_grad=False)
+        if student_model.model.decoder.gradient_checkpointing:
+            logger.info("Disabling gradient checkpointing in the decoder since it's incompatible with `freeze_embed_positions`.")
+    logger.info(f'Number of trainable parameters: {sum((p.numel() for p in student_model.parameters() if p.requires_grad)):.3e}')
+    share_hidden_states = training_args.freeze_encoder and student_model.config.d_model == teacher_model.config.d_model
+    if share_hidden_states:
+        teacher_model.model.encoder = student_model.model.encoder
+    if hasattr(teacher_model.generation_config, 'is_multilingual') and teacher_model.generation_config.is_multilingual:
+        is_multilingual = True
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task, predict_timestamps=False)
+        student_model.generation_config.update(**{'language': data_args.language, 'task': data_args.task})
+    elif data_args.language is not None:
+        raise ValueError('Setting language token for an English-only checkpoint is not permitted. The language argument should only be set for multilingual checkpoints.')
+    else:
+        is_multilingual = False
+    if accelerator.is_main_process:
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+        student_model.generation_config.save_pretrained(training_args.output_dir)
+    accelerator.wait_for_everyone()
+    processor = WhisperProcessor.from_pretrained(training_args.output_dir)
+    sampling_rate = feature_extractor.sampling_rate
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=sampling_rate))
+    max_input_length = int(data_args.max_duration_in_seconds * sampling_rate)
+    min_input_length = int(data_args.min_duration_in_seconds * sampling_rate)
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else student_model.config.max_length
+    timestamp_probability = data_args.timestamp_probability
+    condition_on_prev_probability = data_args.condition_on_prev_probability
+    return_timestamps = data_args.return_timestamps if timestamp_probability > 0 else False
+    timestamp_ids = tokenizer.timestamp_ids()
+    timestamp_begin = tokenizer.all_special_ids[-1]
+    timestamp_position = 3 if is_multilingual else 1
+    decoder_start_token_id = student_model.config.decoder_start_token_id
+    decoder_prev_token_id = tokenizer.all_special_ids[-3]
+    prompt_cutoff_length = max_label_length // 2
+    num_workers = data_args.preprocessing_num_workers
+    dataloader_num_workers = training_args.dataloader_num_workers
+    prefetch_factor = training_args.dataloader_prefetch_factor
+    metric = evaluate.load('wer')
+    normalizer = BasicTextNormalizer() if data_args.language is not None else EnglishTextNormalizer(tokenizer.english_spelling_normalizer)
+    wer_threshold = data_args.wer_threshold
+    use_pseudo_labels = data_args.use_pseudo_labels
+    train_text_column_name = 'whisper_transcript' if use_pseudo_labels else 'text'
+    if training_args.do_train and data_args.max_train_samples is not None:
+        raw_datasets['train'] = raw_datasets['train'].take(data_args.max_train_samples) if data_args.streaming else raw_datasets['train'].select(range(data_args.max_train_samples))
+    if training_args.do_eval and data_args.max_eval_samples is not None:
+        for eval_split in all_eval_splits:
+            raw_datasets[eval_split] = raw_datasets[eval_split].take(data_args.max_eval_samples) if data_args.streaming else raw_datasets[eval_split].select(range(data_args.max_eval_samples))
+
+    def is_wer_in_range(ground_truth, whisper_transcript):
+        norm_ground_truth = normalizer(ground_truth)
+        if whisper_transcript is not None and whisper_transcript.upper() == whisper_transcript:
+            return False
+        elif len(norm_ground_truth) > 0 and whisper_transcript is not None:
+            norm_whisper_transcript = normalizer(whisper_transcript)
+            wer = 100 * metric.compute(predictions=[norm_whisper_transcript], references=[norm_ground_truth])
+            return wer < wer_threshold
+        else:
+            return False
+    filter_by_wer_threshold = partial(raw_datasets['train'].filter, function=is_wer_in_range, input_columns=['text', 'whisper_transcript'])
+    if wer_threshold is not None and use_pseudo_labels:
+        with accelerator.main_process_first():
+            raw_datasets['train'] = filter_by_wer_threshold(num_proc=num_workers, desc='filtering train dataset by wer') if not data_args.streaming else filter_by_wer_threshold()
+
+    def prepare_train_dataset(batch):
+        audio = [sample['array'] for sample in batch['audio']]
+        inputs = feature_extractor(audio, sampling_rate=sampling_rate)
+        batch['input_features'] = inputs.input_features
+        batch['input_length'] = [len(sample) for sample in audio]
+        input_str_batched = batch[train_text_column_name]
+        condition_on_prev_batched = batch.get('condition_on_prev', len(input_str_batched) * [None])
+        all_token_ids = []
+        all_token_ids_unprompted = []
+        for (prev_ids, input_str) in zip(condition_on_prev_batched, input_str_batched):
+            token_ids = tokenizer(input_str, add_special_tokens=not use_pseudo_labels).input_ids
+            has_timestamps = len(set(token_ids) & set(timestamp_ids)) > 0
+            if has_timestamps:
+                predict_timestamps = bool(np.random.binomial(1, timestamp_probability))
+                if not predict_timestamps:
+                    token_ids = [token for token in token_ids if token < timestamp_begin]
+                    token_ids.insert(timestamp_position, timestamp_begin)
+            all_token_ids_unprompted.append(token_ids)
+            condition_on_prev = bool(np.random.binomial(1, condition_on_prev_probability))
+            if not condition_on_prev:
+                prev_ids = None
+            elif 'condition_on_prev' not in batch and len(all_token_ids_unprompted) > 1:
+                prev_ids = all_token_ids_unprompted[-2]
+            if prev_ids is not None:
+                if has_timestamps and (not predict_timestamps):
+                    prev_ids = [token for token in prev_ids if token < timestamp_begin]
+                if len(prev_ids) > prompt_cutoff_length:
+                    prev_ids = prev_ids[-prompt_cutoff_length + 1:]
+                    prev_ids = [decoder_prev_token_id] + prev_ids
+                if len(prev_ids + token_ids) > max_label_length:
+                    trim_length = len(prev_ids + token_ids) - max_label_length + 1
+                    prev_ids = prev_ids[trim_length:]
+                    prev_ids = [decoder_prev_token_id] + prev_ids
+                token_ids = prev_ids + token_ids
+            all_token_ids.append(token_ids)
+        batch['labels'] = all_token_ids
+        return batch
+
+    def prepare_eval_dataset(batch):
+        sample = batch['audio']
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch['input_features'] = inputs.input_features[0]
+        batch['input_length'] = len(sample['array'])
+        input_str = batch['text']
+        batch['labels'] = tokenizer(input_str).input_ids
+        return batch
+    vectorized_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    if training_args.do_train:
+        map_fn_train = partial(raw_datasets['train'].map, function=prepare_train_dataset, remove_columns=raw_datasets_train_features, batched=True, batch_size=data_args.preprocessing_batch_size)
+        with accelerator.main_process_first():
+            vectorized_datasets['train'] = map_fn_train(num_proc=num_workers, desc='preprocess train dataset') if not data_args.streaming else map_fn_train()
+    if training_args.do_eval:
+        for eval_split in all_eval_splits:
+            raw_datasets_eval_features = list(raw_datasets[eval_split].features.keys())
+            map_fn_eval = partial(raw_datasets[eval_split].map, function=prepare_eval_dataset, remove_columns=raw_datasets_eval_features)
+            with accelerator.main_process_first():
+                vectorized_datasets[eval_split] = map_fn_eval(num_proc=num_workers, desc='preprocess eval dataset') if not data_args.streaming else map_fn_eval()
+
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+    filter_by_audio_fn = partial(vectorized_datasets.filter, function=is_audio_in_length_range, input_columns=['input_length'])
+    with accelerator.main_process_first():
+        vectorized_datasets = filter_by_audio_fn(num_proc=num_workers, desc='filtering train dataset by audio length') if not data_args.streaming else filter_by_audio_fn()
+
+    def is_labels_in_length_range(labels):
+        return 0 < len(labels) <= max_label_length
+    filter_by_labels_fn = partial(vectorized_datasets.filter, function=is_labels_in_length_range, input_columns=['labels'])
+    with accelerator.main_process_first():
+        vectorized_datasets = filter_by_labels_fn(num_proc=num_workers, desc='filtering train dataset') if not data_args.streaming else filter_by_labels_fn()
+    if data_args.preprocessing_only:
+        if data_args.streaming:
+            raise ValueError('When using streaming mode, dataset pre-processing is performed on the fly, hence there is no notionof a cached pre-processed dataset. Remove the argument `--preprocessing_only` to run pre-processing on the fly with streaming mode.')
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+
+    def compute_metrics(preds, labels):
+        for idx in range(len(labels)):
+            labels[idx][labels[idx] == -100] = tokenizer.pad_token_id
+        pred_str = tokenizer.batch_decode(preds, skip_special_tokens=True, decode_with_timestamps=return_timestamps)
+        label_str = tokenizer.batch_decode(labels, skip_special_tokens=True)
+        wer_ortho = 100 * metric.compute(predictions=pred_str, references=label_str)
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return ({'wer': wer, 'wer_ortho': wer_ortho}, pred_str, label_str, norm_pred_str, norm_label_str)
+    per_device_train_batch_size = int(training_args.per_device_train_batch_size)
+    train_batch_size = per_device_train_batch_size * accelerator.num_processes
+    gradient_accumulation_steps = int(training_args.gradient_accumulation_steps)
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    if not data_args.streaming and training_args.max_steps < 0:
+        num_epochs = int(training_args.num_train_epochs)
+        steps_per_epoch = len(vectorized_datasets['train']) // (train_batch_size * gradient_accumulation_steps)
+        total_train_steps = steps_per_epoch * num_epochs
+    elif training_args.max_steps > 0:
+        logger.info('max_steps is given, it will override any value given in num_train_epochs')
+        total_train_steps = int(training_args.max_steps)
+        if not data_args.streaming:
+            steps_per_epoch = len(vectorized_datasets['train']) // (train_batch_size * gradient_accumulation_steps)
+            num_epochs = int(np.ceil(total_train_steps / steps_per_epoch))
+        else:
+            num_epochs = sys.maxsize
+            steps_per_epoch = total_train_steps
+    else:
+        raise ValueError('max_steps must be specified when training with a streaming (iterable) dataset')
+    if training_args.eval_steps is None:
+        logger.info(f"eval_steps is not set, evaluating at the end of {('each epoch' if not data_args.streaming else 'training')}")
+        eval_steps = steps_per_epoch
+    else:
+        eval_steps = training_args.eval_steps
+    forbidden_module = [module for (module, flag) in [(student_model.model.encoder, training_args.freeze_encoder), (student_model.model.decoder, training_args.freeze_decoder)] if flag] or None
+    decay_parameters = get_parameter_names(student_model, [nn.LayerNorm], forbidden_module=forbidden_module)
+    decay_parameters = [name for name in decay_parameters if 'bias' not in name]
+    optimizer_grouped_parameters = [{'params': [param for (name, param) in student_model.named_parameters() if name in decay_parameters], 'weight_decay': training_args.weight_decay}, {'params': [param for (name, param) in student_model.named_parameters() if name not in decay_parameters], 'weight_decay': 0.0}]
+    optimizer = torch.optim.AdamW(params=optimizer_grouped_parameters, lr=training_args.learning_rate, betas=(training_args.adam_beta1, training_args.adam_beta2), eps=training_args.adam_epsilon)
+    lr_scheduler = get_scheduler(name=training_args.lr_scheduler_type, optimizer=optimizer, num_warmup_steps=training_args.warmup_steps * accelerator.num_processes, num_training_steps=total_train_steps * accelerator.num_processes)
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor, decoder_start_token_id=decoder_start_token_id, decoder_prev_token_id=decoder_prev_token_id, input_padding='longest', target_padding='max_length', max_target_length=max_label_length)
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else getattr(student_model.generation_config, 'num_beams', 1)
+    gen_kwargs = {'max_length': max_label_length, 'num_beams': num_beams, 'return_timestamps': return_timestamps}
+    if is_multilingual:
+        gen_kwargs.update({'language': data_args.language, 'task': data_args.task})
+    (student_model, teacher_model, optimizer, lr_scheduler) = accelerator.prepare(student_model, teacher_model, optimizer, lr_scheduler)
+
+    def kl_divergence(target_distribution, log_predicted_distribution, labels):
+        kl_loss = nn.KLDivLoss(reduction='none')
+        divergence = kl_loss(log_predicted_distribution, target_distribution)
+        padding_mask = labels >= 0
+        padding_mask = padding_mask.unsqueeze(-1)
+        divergence = divergence * padding_mask
+        divergence = divergence.sum() / padding_mask.sum()
+        return divergence
+
+    def train_step(batch, temperature=2.0):
+        student_model.train()
+        teacher_model.eval()
+        student_outputs = student_model(**batch)
+        with torch.no_grad():
+            if share_hidden_states:
+                encoder_outputs = BaseModelOutput(student_outputs.encoder_last_hidden_state.to(dtype=teacher_dtype))
+                teacher_outputs = teacher_model(encoder_outputs=encoder_outputs, labels=batch['labels'])
+            else:
+                teacher_outputs = teacher_model(**batch)
+        ce_loss = student_outputs.loss
+        teacher_distribution = nn.functional.softmax(teacher_outputs.logits / temperature, dim=-1)
+        student_distribution = nn.functional.log_softmax(student_outputs.logits / temperature, dim=-1)
+        kl_loss = kl_divergence(teacher_distribution, student_distribution, batch['labels']) * temperature ** 2
+        loss = 0.8 * ce_loss + training_args.kl_weight * kl_loss
+        metrics = {'loss': loss, 'ce_loss': ce_loss, 'kl_loss': kl_loss}
+        return (loss, metrics)
+
+    def eval_step(batch):
+        student_model.eval()
+        teacher_model.eval()
+        with torch.no_grad():
+            student_outputs = student_model(**batch)
+            if share_hidden_states:
+                encoder_outputs = BaseModelOutput(student_outputs.encoder_last_hidden_state.to(dtype=teacher_dtype))
+                teacher_outputs = teacher_model(encoder_outputs=encoder_outputs, labels=batch['labels'])
+            else:
+                teacher_outputs = teacher_model(**batch)
+        ce_loss = student_outputs.loss
+        student_distribution = nn.functional.log_softmax(student_outputs.logits, dim=-1)
+        teacher_distribution = nn.functional.softmax(teacher_outputs.logits, dim=-1)
+        kl_loss = kl_divergence(teacher_distribution, student_distribution, batch['labels'])
+        loss = 0.8 * ce_loss + training_args.kl_weight * kl_loss
+        metrics = {'loss': loss, 'ce_loss': ce_loss, 'kl_loss': kl_loss}
+        return metrics
+
+    def generate_step(batch):
+        student_model.eval()
+        output_ids = accelerator.unwrap_model(student_model).generate(batch['input_features'], **gen_kwargs)
+        output_ids = accelerator.pad_across_processes(output_ids, dim=1, pad_index=tokenizer.pad_token_id)
+        return output_ids
+    logger.info('***** Running training *****')
+    logger.info(f'  Num examples = {total_train_steps * train_batch_size * gradient_accumulation_steps}')
+    if not data_args.streaming:
+        logger.info(f'  Num epochs = {num_epochs}')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_train_batch_size}')
+    logger.info(f'  Gradient accumulation steps = {gradient_accumulation_steps}')
+    logger.info(f'  Total train batch size (w. parallel & distributed) = {train_batch_size * gradient_accumulation_steps}')
+    logger.info(f'  Total optimization steps = {total_train_steps}')
+    train_time = 0
+    train_start = time.time()
+    steps_trained_progress_bar = tqdm(range(total_train_steps), desc='Train steps ... ', position=0, disable=not accelerator.is_local_main_process)
+    continue_training = True
+    epochs_trained = 0
+    cur_step = 0
+    best_val_wer = np.inf
+    checkpoint = None
+    if training_args.resume_from_checkpoint is not None:
+        checkpoint = training_args.resume_from_checkpoint
+    elif last_checkpoint is not None:
+        checkpoint = last_checkpoint
+    if checkpoint is not None:
+        accelerator.load_state(checkpoint)
+        pattern = 'checkpoint-(\\d+)-epoch-(\\d+)'
+        match = re.search(pattern, checkpoint)
+        cur_step = int(match.group(1))
+        epochs_trained = int(match.group(2))
+        logger.info('  Continuing training from checkpoint, will skip to saved global_step')
+        logger.info(f'  Continuing training from epoch {epochs_trained}')
+        logger.info(f'  Continuing training from global step {cur_step}')
+        steps_trained_progress_bar.update(cur_step)
+        for epoch in range(0, epochs_trained):
+            vectorized_datasets['train'] = vectorized_datasets['train'].shuffle(training_args.seed)
+        if not data_args.streaming and training_args.max_steps < 0:
+            resume_step = (cur_step - epochs_trained * steps_per_epoch) * gradient_accumulation_steps
+        else:
+            resume_step = None
+            vectorized_datasets['train'] = vectorized_datasets['train'].shuffle(training_args.seed)
+    else:
+        resume_step = None
+    for epoch in range(epochs_trained, num_epochs):
+        vectorized_datasets['train'] = vectorized_datasets['train'].shuffle(training_args.seed)
+        train_dataloader = DataLoader(vectorized_datasets['train'], collate_fn=data_collator, batch_size=per_device_train_batch_size, num_workers=dataloader_num_workers, prefetch_factor=prefetch_factor, pin_memory=training_args.dataloader_pin_memory)
+        train_dataloader = accelerator.prepare(train_dataloader)
+        if hasattr(train_dataloader, 'dataset') and isinstance(train_dataloader.dataset, IterableDataset):
+            train_dataloader.dataset.set_epoch(epoch)
+        if resume_step is not None:
+            train_dataloader = accelerator.skip_first_batches(train_dataloader, resume_step)
+            resume_step = None
+        for batch in train_dataloader:
+            with accelerator.accumulate(student_model):
+                (loss, train_metric) = train_step(batch, temperature=training_args.temperature)
+                accelerator.backward(loss)
+                if accelerator.sync_gradients:
+                    accelerator.clip_grad_norm_(student_model.parameters(), training_args.max_grad_norm)
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+            if accelerator.sync_gradients:
+                steps_trained_progress_bar.update(1)
+                cur_step += 1
+                if cur_step % training_args.logging_steps == 0:
+                    steps_trained_progress_bar.write(f"Step... ({cur_step} / {total_train_steps} | Loss: {train_metric['loss']}, Learning Rate: {lr_scheduler.get_last_lr()[0]})")
+                    log_metric(accelerator, metrics=train_metric, learning_rate=lr_scheduler.get_last_lr()[0], train_time=train_time + time.time() - train_start, step=cur_step, epoch=epoch, prefix='train')
+                if cur_step % training_args.save_steps == 0 or cur_step == total_train_steps:
+                    intermediate_dir = os.path.join(training_args.output_dir, f'checkpoint-{cur_step}-epoch-{epoch}')
+                    accelerator.save_state(output_dir=intermediate_dir)
+                    feature_extractor.save_pretrained(intermediate_dir)
+                    tokenizer.save_pretrained(intermediate_dir)
+                    config.save_pretrained(intermediate_dir)
+                    student_model.generation_config.save_pretrained(intermediate_dir)
+                    accelerator.wait_for_everyone()
+                    if accelerator.is_main_process:
+                        rotate_checkpoints(training_args.save_total_limit, output_dir=training_args.output_dir)
+                        if training_args.push_to_hub:
+                            upload_folder(folder_path=training_args.output_dir, repo_id=repo_name, repo_type='model', commit_message=f'Saving train state of step {cur_step}')
+                if training_args.do_eval and (cur_step % eval_steps == 0 or cur_step == total_train_steps):
+                    train_time += time.time() - train_start
+                    student_model.eval()
+                    (wer_l, labels_l) = ([], [])
+                    for eval_split in all_eval_splits:
+                        eval_metrics = []
+                        eval_preds = []
+                        eval_labels = []
+                        eval_start = time.time()
+                        validation_dataloader = DataLoader(vectorized_datasets[eval_split], collate_fn=data_collator, batch_size=per_device_eval_batch_size, drop_last=False, num_workers=dataloader_num_workers, prefetch_factor=prefetch_factor, pin_memory=training_args.dataloader_pin_memory)
+                        validation_dataloader = accelerator.prepare(validation_dataloader)
+                        for batch in tqdm(validation_dataloader, desc=f'Evaluating {eval_split}...', position=2, disable=not accelerator.is_local_main_process):
+                            eval_metric = eval_step(batch)
+                            eval_metric = accelerator.gather_for_metrics(eval_metric)
+                            eval_metrics.append(eval_metric)
+                            if training_args.predict_with_generate:
+                                generated_ids = generate_step(batch)
+                                (generated_ids, labels) = accelerator.gather_for_metrics((generated_ids, batch['labels']))
+                                eval_preds.extend(generated_ids)
+                                eval_labels.extend(labels)
+                        eval_time = time.time() - eval_start
+                        eval_metrics = {key: torch.mean(torch.stack([d[key] for d in eval_metrics])) for key in eval_metrics[0]}
+                        wer_desc = ''
+                        if training_args.predict_with_generate:
+                            (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str) = compute_metrics(eval_preds, eval_labels)
+                            eval_metrics.update(wer_metric)
+                            wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in wer_metric.items()])
+                            log_pred(accelerator, pred_str, label_str, norm_pred_str, norm_label_str, step=cur_step, prefix=eval_split)
+                        steps_trained_progress_bar.write(f"Eval results for step ({cur_step} / {total_train_steps} | Eval Loss: {eval_metrics['loss']} | {wer_desc})")
+                        wer_l.append(wer_metric)
+                        labels_l.append(norm_label_str)
+                        log_metric(accelerator, metrics=eval_metrics, train_time=eval_time, step=cur_step, epoch=epoch, prefix=eval_split)
+                    train_start = time.time()
+                    numerators = [wer['wer'] * len(labs) for (wer, labs) in zip(wer_l, labels_l)]
+                    val_wer = sum(numerators) / sum((len(labs) for labs in labels_l))
+                    if val_wer < best_val_wer:
+                        intermediate_dir = os.path.join(training_args.output_dir, f'checkpoint-{cur_step}-epoch-{epoch}-val-wer-{val_wer:.3f}')
+                        logger.info(f'Saving new best model, validation WER: {val_wer:.3f}')
+                        accelerator.save_state(output_dir=intermediate_dir)
+                        feature_extractor.save_pretrained(intermediate_dir)
+                        tokenizer.save_pretrained(intermediate_dir)
+                        config.save_pretrained(intermediate_dir)
+                        student_model.generation_config.save_pretrained(intermediate_dir)
+                        accelerator.wait_for_everyone()
+                        if accelerator.is_main_process:
+                            rotate_checkpoints(training_args.save_best_total_limit, output_dir=training_args.output_dir, sorting_fn=sorted_best_checkpoints)
+                            accelerator.unwrap_model(student_model).save_pretrained(training_args.output_dir)
+                            if training_args.push_to_hub:
+                                upload_folder(folder_path=training_args.output_dir, repo_id=repo_name, repo_type='model', commit_message=f'Saving best state, step {cur_step}, val wer {val_wer:.3f}')
+                        best_val_wer = val_wer
+                if cur_step == total_train_steps:
+                    final_weights_dir = os.path.join(training_args.output_dir, 'end-of-training-weights')
+                    feature_extractor.save_pretrained(final_weights_dir)
+                    tokenizer.save_pretrained(final_weights_dir)
+                    config.save_pretrained(final_weights_dir)
+                    student_model.generation_config.save_pretrained(final_weights_dir)
+                    student_model = accelerator.unwrap_model(student_model)
+                    student_model.save_pretrained(final_weights_dir)
+                    if training_args.push_to_hub:
+                        upload_folder(folder_path=training_args.output_dir, repo_id=repo_name, repo_type='model', commit_message=f'Saving final weights of step {cur_step}')
+                    continue_training = False
+                    break
+        if not continue_training:
+            break
+    accelerator.end_training()
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/run_eval.py
+""""""
+import json
+import logging
+import os
+import sys
+import tempfile
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+import datasets
+import evaluate
+import numpy as np
+import torch
+import transformers
+from datasets import DatasetDict, IterableDatasetDict, load_dataset
+from tqdm import tqdm
+from transformers import HfArgumentParser, WhisperForConditionalGeneration, WhisperProcessor, is_wandb_available, pipeline, set_seed
+from transformers.models.whisper.english_normalizer import EnglishTextNormalizer, BasicTextNormalizer
+from transformers.modeling_outputs import BaseModelOutput
+from transformers.models.whisper.modeling_whisper import WhisperForCausalLM
+from transformers.models.whisper.tokenization_whisper import TO_LANGUAGE_CODE
+from transformers.utils import check_min_version, is_accelerate_available
+from transformers.utils.versions import require_version
+check_min_version('4.34.0.dev0')
+require_version('datasets>=2.14.6', 'To fix: `pip install --upgrade datasets`')
+logger = logging.getLogger(__name__)
+PIPELINE_BATCH_SIZE = 16
+
+@dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': "The name of the dataset to use (via the datasets library). Load and combine multiple datasets by separating dataset hours by a '+' symbol."})
+    model_name_or_path: str = field(default=None, metadata={'help': 'The name of the model to use (via the transformers library). '})
+    subfolder: str = field(default='', metadata={'help': 'If specified load weights from a subfolder in the model repository'})
+    model_variant: str = field(default=None, metadata={'help': 'If specified load weights from `variant` filename, *e.g.* pytorch_model.<variant>.bin. '})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    assistant_model_name_or_path: str = field(default=None, metadata={'help': 'The name of the assistant model to use to do speculative decoding. If None, no speculative decoding will be done.'})
+    dtype: Optional[str] = field(default='float16', metadata={'help': 'Floating-point format in which the model weights should be initialized and the computations run. Choose one of `[float32, float16, bfloat16]`.'})
+    use_pipeline: bool = field(default=False, metadata={'help': 'Whether to evaluate with Transformers pipeline'})
+    chunk_length_s: float = field(default=30.0, metadata={'help': 'Chunk length to use when `use_pipeline` is enabled.'})
+    return_timestamps: bool = field(default=True, metadata={'help': 'Whether to decode with timestamps. This can help for improved WER for long form evaluation.'})
+    language: str = field(default=None, metadata={'help': 'Language for multilingual evaluation. This argument should be set for multilingual evaluation only. For English speech recognition, it should be left as `None`.'})
+    task: str = field(default='transcribe', metadata={'help': 'Task, either `transcribe` for speech recognition or `translate` for speech translation.This argument should be set for multilingual evaluation only. For English speech recognition, it should be left as `None`.'})
+    attn_implementation: Optional[str] = field(default=None, metadata={'help': "Which attn type to use: ['eager', 'sdpa', 'flash_attention_2']"})
+    batch_size: int = field(default=1, metadata={'help': 'The batch size to be used for generation.'})
+    num_beams: int = field(default=1, metadata={'help': 'The beam size to be used for evaluation. Set to 1 for greedy, or >1 for beam search.'})
+    temperature_fallback: bool = field(default=True, metadata={'help': 'Whether to use temperature fallback for evaluation.'})
+    logprob_threshold: float = field(default=-1.0, metadata={'help': 'Whether to use temperature fallback for evaluation.'})
+    no_speech_threshold: float = field(default=0.6, metadata={'help': "Only relevant for long-form transcription. If defined, the 'no-speech' token combined with the `logprob_threshold`is used to determine whether a segment contains only silence. In this case, the transcription for this segmentis skipped."})
+    compression_ratio_threshold: float = field(default=1.35, metadata={'help': 'Only relevant for long-form transcription. If defined, the zlib compression rate of each segment will be computed. If the compression rate ofa segment is higher than `compression_ratio_threshold`, temperature fallback is activated: the generated segment is discarded and the generation isrepeated using a higher temperature. The intuition behind this feature is that segments with very high compression ratessuffer from a lot of repetition. The unwanted repetition can be reduced by injecting more randomness by increasing the temperature. If `compression_ratio_threshold` is defined make sure that `temperature` is a list of values. The default value for `compression_ratio_threshold` is 1.35.'})
+    condition_on_prev_tokens: bool = field(default=False, metadata={'help': 'Whether to condition on previous tokens or not'})
+    samples_per_dataset: Optional[int] = field(default=None, metadata={'help': 'Number of samples per dataset used to measure speed.'})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_split_name: Optional[str] = field(default=None, metadata={'help': 'The split name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default=None, metadata={'help': 'The name of the dataset column containing the text data. Defaults to `text`.'})
+    generation_max_length: int = field(default=256, metadata={'help': 'Generate up until `generation_max_length` tokens.'})
+    log_predictions: Optional[bool] = field(default=True, metadata={'help': 'Whether or not to log the ground truths / pred text to the wandb logger.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    wandb_project: str = field(default='distil-whisper-speed-benchmark', metadata={'help': 'The name of the wandb project.'})
+    wandb_name: str = field(default=None, metadata={'help': 'The name of the wandb run.'})
+    wandb_job_type: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb job type.'})
+    wandb_dir: str = field(default=None, metadata={'help': 'The absolute path to save the wandb logs.'})
+    save_code_to_wandb: bool = field(default=False, metadata={'help': 'Whether to save main script to wandb. This is valuable for improving experiment reproducibility and to diff code across experiments in the UI.'})
+    streaming: bool = field(default=True, metadata={'help': "Whether to use Datasets' streaming mode to load and the data."})
+    max_eval_samples: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of eval examples to this value if set.'})
+    seed: int = field(default=42, metadata={'help': 'RNG seed for reproducibility.'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    prompt_text: str = field(default=None, metadata={'help': 'Text prompt to condition the generation on. Useful for controlling the style of transcription and predicting named entities.'})
+    precise_tok_per_s: bool = field(default=False, metadata={'help': 'If True, compute tok/sec by forcing the number of generated token ids to num_tokens on dummy batches. If False, computes tok/sec over the entire dataset with variable number of generated tokens.'})
+    num_tokens: int = field(default=20, metadata={'help': 'Number of tokens to generate if computing tok/sec with precise_tok_per_s.'})
+    num_batches: int = field(default=100, metadata={'help': 'Number of batches for the tok/sec calculation with precise_tok_per_s'})
+    only_short_form: bool = field(default=False, metadata={'help': 'Whether the evaluation should be only short form (filter out samples > 30sec).'})
+    only_long_form: bool = field(default=False, metadata={'help': 'Whether the evaluation should be only long form (filter out samples <= 30sec).'})
+
+def write_metric(summary_writer, eval_metrics, step, prefix='eval'):
+    for (metric_name, value) in eval_metrics.items():
+        summary_writer.scalar(f'{prefix}/{metric_name}', value, step)
+
+def write_wandb_metric(wandb_logger, metrics, prefix):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    wandb_logger.log(log_metrics)
+
+def write_wandb_pred(wandb_logger, pred_str, label_str, norm_pred_str, norm_label_str, wer_per_sample, prefix='eval'):
+    columns = ['WER', 'Target', 'Pred', 'Norm Target', 'Norm Pred']
+    str_data = [[wer_per_sample[i], label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+    wandb_logger.log({f'{prefix}/predictions': wandb_logger.Table(columns=columns, data=str_data)})
+
+def convert_dataset_str_to_list(dataset_names, dataset_config_names, splits=None, text_column_names=None, dataset_hours=None, default_split='train'):
+    if isinstance(dataset_names, str):
+        dataset_names = dataset_names.split('+')
+        for i in range(len(dataset_names)):
+            ds_name = dataset_names[i]
+            dataset_names[i] = f'distil-whisper/{ds_name}' if '/' not in ds_name else ds_name
+        dataset_config_names = dataset_config_names.split('+') if dataset_config_names is not None else None
+        splits = splits.split('+') if splits is not None else None
+        text_column_names = text_column_names.split('+') if text_column_names is not None else None
+        dataset_hours = dataset_hours.split('+') if dataset_hours is not None else None
+    if dataset_config_names is not None and len(dataset_names) != len(dataset_config_names):
+        raise ValueError(f'Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_config_names)} configs.')
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(f'Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.')
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(f'Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and {len(text_column_names)} text column names.')
+    if dataset_hours is not None:
+        if len(dataset_hours) != len(dataset_names):
+            raise ValueError(f'Ensure one probability is passed for each dataset, got {len(dataset_names)} datasets and {len(dataset_hours)} hours.')
+        dataset_hours = [float(ds_hours) for ds_hours in dataset_hours]
+    else:
+        dataset_hours = [None] * len(dataset_names)
+    dataset_config_names = dataset_config_names if dataset_config_names is not None else ['default' for _ in range(len(dataset_names))]
+    text_column_names = text_column_names if text_column_names is not None else ['text' for _ in range(len(dataset_names))]
+    splits = splits if splits is not None else [default_split for _ in range(len(dataset_names))]
+    dataset_names_dict = []
+    for (i, ds_name) in enumerate(dataset_names):
+        dataset_names_dict.append({'name': ds_name, 'config': dataset_config_names[i], 'split': splits[i], 'text_column_name': text_column_names[i], 'hours': dataset_hours[i]})
+    return dataset_names_dict
+
+def language_to_id(language: str, generation_config) -> str:
+    language = language.lower()
+    if language in generation_config.lang_to_id.keys():
+        language_token = language
+    elif language in TO_LANGUAGE_CODE.keys():
+        language_token = f'<|{TO_LANGUAGE_CODE[language]}|>'
+    elif language in TO_LANGUAGE_CODE.values():
+        language_token = f'<|{language}|>'
+    else:
+        is_language_code = len(language) == 2
+        raise ValueError(f'Unsupported language: {language}. Language should be one of: {(list(TO_LANGUAGE_CODE.values()) if is_language_code else list(TO_LANGUAGE_CODE.keys()))}.')
+    if language_token not in generation_config.lang_to_id:
+        raise ValueError(f'{language_token} is not supported by this specific model as it is not in the `generation_config.lang_to_id`.(You should just add it to the generation config)')
+    return language_token
+
+def main():
+    parser = HfArgumentParser([DataTrainingArguments])
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        data_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))[0]
+    else:
+        data_args = parser.parse_args_into_dataclasses()[0]
+    logger.setLevel(logging.INFO)
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', handlers=[logging.StreamHandler(sys.stdout)])
+    set_seed(data_args.seed)
+    if data_args.use_pipeline and data_args.batch_size > 1:
+        raise ValueError('Make sure that `batch_size` is set to 1 when `use_pipeline=True`.')
+    has_wandb = is_wandb_available()
+    if has_wandb:
+        import wandb
+        import wandb as wandb_logger
+        generation_arguments = {'torch_version': str(torch.__version__), 'transformers_version': str(transformers.__version__), 'attn_implementation': data_args.attn_implementation, 'model_name_or_path': data_args.model_name_or_path, 'subfolder': data_args.subfolder, 'assistant_model_name_or_path': data_args.assistant_model_name_or_path, 'seed': data_args.seed, 'batch_size': data_args.batch_size, 'num_beams': data_args.num_beams, 'return_timestamps': data_args.return_timestamps, 'condition_on_prev_tokens': data_args.condition_on_prev_tokens, 'temperature_fallback': data_args.temperature_fallback, 'logprob_threshold': data_args.logprob_threshold, 'no_speech_threshold': data_args.no_speech_threshold, 'use_pipeline': data_args.use_pipeline, 'chunk_length_s': data_args.chunk_length_s}
+        wandb_logger.init(project=data_args.wandb_project, name=data_args.wandb_name, job_type=data_args.wandb_job_type, dir=data_args.wandb_dir, save_code=data_args.save_code_to_wandb, config=generation_arguments)
+    else:
+        raise ValueError('Wandb logging requires wandb to be installed. Run `pip install wandb` to enable.')
+    raw_datasets = IterableDatasetDict()
+    dataset_names_dict = convert_dataset_str_to_list(data_args.dataset_name, data_args.dataset_config_name, splits=data_args.dataset_split_name, text_column_names=data_args.text_column_name)
+    for dataset_dict in tqdm(dataset_names_dict, desc='Loading datasets...'):
+        sub_dataset = load_dataset(dataset_dict['name'], dataset_dict['config'], split=dataset_dict['split'], cache_dir=data_args.dataset_cache_dir, streaming=data_args.streaming, num_proc=data_args.preprocessing_num_workers)
+        if data_args.only_short_form:
+            sub_dataset = sub_dataset.filter(lambda x: len(x['audio']['array']) / x['audio']['sampling_rate'] <= 30)
+        if data_args.only_long_form:
+            sub_dataset = sub_dataset.filter(lambda x: len(x['audio']['array']) / x['audio']['sampling_rate'] > 30)
+        if dataset_dict['text_column_name'] not in list(sub_dataset.features.keys()):
+            raise ValueError(f"`--text_column_name` {dataset_dict['text_column_name']} not found in the evaluation dataset {dataset_dict['name']}. Ensure `text_column_name` is set to the correct column for the target text. Should be one of {' '.join(list(sub_dataset.features.keys()))}")
+        if dataset_dict['text_column_name'] != 'text':
+            sub_dataset = sub_dataset.rename_column(dataset_dict['text_column_name'], 'text')
+        if not data_args.streaming:
+            sub_dataset = sub_dataset.to_iterable_dataset()
+        pretty_name = f"{dataset_dict['name'].split('/')[-1]}/{dataset_dict['split'].replace('.', '-')}"
+        raw_datasets[pretty_name] = sub_dataset
+    processor = WhisperProcessor.from_pretrained(data_args.model_name_or_path, subfolder=data_args.subfolder, cache_dir=data_args.cache_dir, use_fast=data_args.use_fast_tokenizer)
+    dtype = getattr(torch, data_args.dtype)
+    model = WhisperForConditionalGeneration.from_pretrained(data_args.model_name_or_path, subfolder=data_args.subfolder, torch_dtype=dtype, attn_implementation=data_args.attn_implementation, low_cpu_mem_usage=is_accelerate_available(), cache_dir=data_args.cache_dir, variant=data_args.model_variant)
+    model.to('cuda:0', dtype=dtype)
+    model_pipeline = None
+    if data_args.use_pipeline:
+        model_pipeline = pipeline('automatic-speech-recognition', model=model, tokenizer=processor.tokenizer, feature_extractor=processor.feature_extractor, torch_dtype=dtype, device=model.device, chunk_length_s=data_args.chunk_length_s)
+        model_pipeline_forward = model_pipeline._forward
+    assistant_model = None
+    if data_args.assistant_model_name_or_path is not None:
+        logger.info('Loading assistant model...')
+        if data_args.assistant_model_name_or_path.startswith('openai'):
+            assistant_model = WhisperForConditionalGeneration.from_pretrained(data_args.assistant_model_name_or_path, torch_dtype=dtype, attn_implementation=data_args.attn_implementation, low_cpu_mem_usage=is_accelerate_available(), cache_dir=data_args.cache_dir)
+        else:
+            assistant_model = WhisperForCausalLM.from_pretrained(data_args.assistant_model_name_or_path, torch_dtype=dtype, attn_implementation=data_args.attn_implementation, low_cpu_mem_usage=is_accelerate_available(), cache_dir=data_args.cache_dir)
+        assistant_model.cuda()
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=processor.feature_extractor.sampling_rate))
+    audio_column_name = data_args.audio_column_name
+    language = language_to_id(data_args.language, model.generation_config) if data_args.language else None
+    if language is None or language == '<|en|>':
+        normalizer = EnglishTextNormalizer(processor.tokenizer.english_spelling_normalizer)
+    else:
+        normalizer = BasicTextNormalizer()
+    sampling_rate = processor.feature_extractor.sampling_rate
+    if data_args.samples_per_dataset is not None:
+        for split in raw_datasets:
+            raw_datasets[split] = raw_datasets[split].take(data_args.samples_per_dataset)
+
+    def prepare_dataset(batch):
+        audio = [sample['array'].astype(np.float32) for sample in batch[audio_column_name]]
+        if model_pipeline is None:
+            inputs = processor.feature_extractor(audio, sampling_rate=sampling_rate, return_tensors='pt', truncation=False, padding='longest', return_attention_mask=True)
+            if inputs.input_features.shape[-1] < 3000:
+                inputs = processor.feature_extractor(audio, sampling_rate=sampling_rate, return_tensors='pt', return_attention_mask=True)
+            batch['input_features'] = inputs.input_features.to(dtype)
+            batch['attention_mask'] = inputs.attention_mask
+        else:
+            batch['input_features'] = audio
+        batch['length_in_s'] = [len(sample) / sampling_rate for sample in audio]
+        batch['reference'] = batch['text']
+        return batch
+    vectorized_datasets = IterableDatasetDict()
+    for split in raw_datasets:
+        raw_datasets_features = list(raw_datasets[split].features.keys())
+        vectorized_datasets[split] = raw_datasets[split].map(function=prepare_dataset, remove_columns=raw_datasets_features, batch_size=data_args.batch_size, batched=True)
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    metric = evaluate.load('wer')
+
+    def compute_metrics(pred_str, label_str):
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return wer
+    gen_kwargs = {'max_length': data_args.generation_max_length, 'return_timestamps': data_args.return_timestamps, 'num_beams': data_args.num_beams, 'top_k': 0}
+    if hasattr(model.generation_config, 'is_multilingual') and model.generation_config.is_multilingual:
+        gen_kwargs['language'] = data_args.language
+        gen_kwargs['task'] = data_args.task
+    elif data_args.language is not None:
+        raise ValueError('Setting language token for an English-only checkpoint is not permitted. The language argument should only be set for multilingual checkpoints.')
+    if assistant_model is not None:
+        gen_kwargs['assistant_model'] = assistant_model
+    if data_args.prompt_text is not None:
+        gen_kwargs['prompt_ids'] = processor.get_prompt_ids(data_args.prompt_text, return_tensors='pt').to('cuda:0')
+    long_form_gen_kwargs = {'condition_on_prev_tokens': data_args.condition_on_prev_tokens, 'compression_ratio_threshold': data_args.compression_ratio_threshold, 'temperature': (0.0, 0.2, 0.4, 0.6, 0.8, 1.0) if data_args.temperature_fallback else 0, 'logprob_threshold': data_args.logprob_threshold, 'no_speech_threshold': data_args.no_speech_threshold}
+    forced_decoder_ids = processor.get_decoder_prompt_ids(task=data_args.task, language=data_args.language, no_timestamps=not data_args.return_timestamps)
+
+    def benchmark(batch):
+        if model_pipeline is None:
+            inputs = torch.stack(batch['input_features'], dim=0).cuda()
+            attention_mask = torch.stack(batch['attention_mask'], dim=0).cuda()
+            (inner_batch_size, num_mels, seq_len) = inputs.shape
+            if seq_len == 3000:
+                batch_gen_kwargs = gen_kwargs
+            else:
+                batch_gen_kwargs = {**gen_kwargs, **long_form_gen_kwargs}
+            set_seed(data_args.seed)
+            start_time = time.time()
+            output_ids = model.generate(inputs, attention_mask=attention_mask, **batch_gen_kwargs)
+            gen_time = time.time() - start_time
+            batch['time'] = inner_batch_size * [gen_time / inner_batch_size]
+            if not data_args.precise_tok_per_s:
+                n_generated_tokens = output_ids.numel() - inner_batch_size * len(forced_decoder_ids)
+                batch['tokens_per_sec'] = inner_batch_size * [n_generated_tokens / gen_time / inner_batch_size]
+            batch['transcription'] = processor.batch_decode(output_ids, skip_special_tokens=True, decode_with_timestamps=data_args.return_timestamps)
+        else:
+            inputs = batch['input_features']
+            time_result = []
+            n_generated_tokens = []
+
+            def _forward_time(*args, **kwargs):
+                start_time = time.time()
+                result = model_pipeline_forward(*args, **kwargs)
+                end_time = time.time() - start_time
+                time_result.append(end_time)
+                for toks in result['tokens']:
+                    n_generated_tokens.append(len(toks) - len(forced_decoder_ids))
+                return result
+            model_pipeline._forward = _forward_time
+            result = model_pipeline(inputs, batch_size=PIPELINE_BATCH_SIZE, generate_kwargs={**gen_kwargs})[0]['text']
+            if not data_args.precise_tok_per_s:
+                n_generated_tokens = sum(n_generated_tokens)
+                gen_time = time_result[0]
+                batch['tokens_per_sec'] = [n_generated_tokens / gen_time]
+            batch['transcription'] = [result]
+            batch['time'] = [sum(time_result)]
+        batch['num_words'] = [len(r.split()) for r in batch['reference']]
+        return batch
+    result_datasets = DatasetDict()
+    for split in vectorized_datasets:
+        result_datasets[split] = vectorized_datasets[split].map(function=benchmark, remove_columns=['input_features'], batch_size=data_args.batch_size, batched=True)
+    stats_dataset = DatasetDict()
+    all_stats = {'rtf': 0, 'wer': 0, 'tokens_per_sec': 0}
+    rtf_stats = {'times_audio_total': 0, 'times_transcription_total': 0}
+
+    def benchmark_gen(num_batches):
+        tokens_per_secs = []
+        for _ in range(num_batches):
+            dummy_encoder_outputs = BaseModelOutput(torch.randn((data_args.batch_size, model.config.max_source_positions, model.config.d_model), dtype=model.dtype, device=model.device))
+            n_tokens = data_args.num_tokens
+            if model_pipeline is None:
+                start_time = time.time()
+                _ = model.generate(encoder_outputs=dummy_encoder_outputs, min_new_tokens=n_tokens, max_new_tokens=n_tokens, **gen_kwargs)
+                gen_time = time.time() - start_time
+            else:
+                start_time = time.time()
+                _ = model_pipeline.model.generate(encoder_outputs=dummy_encoder_outputs, min_new_tokens=n_tokens, max_new_tokens=n_tokens, **gen_kwargs)
+                gen_time = time.time() - start_time
+            n_generated_tokens = n_tokens * data_args.batch_size
+            tokens_per_secs.append(n_generated_tokens / gen_time)
+        return tokens_per_secs
+    logger.info('***** Running Evaluation *****')
+    for key in generation_arguments:
+        logger.info(f'  {key}: {generation_arguments[key]}')
+    datasets_evaluated_progress_bar = tqdm(result_datasets, desc='Datasets', position=0)
+    for split in datasets_evaluated_progress_bar:
+        transcriptions = []
+        references = []
+        stats = {}
+        times_audio_total = 0
+        times_transcription_total = 0
+        tokens_per_secs = []
+        if data_args.precise_tok_per_s:
+            tokens_per_secs = benchmark_gen(data_args.num_batches)
+        datasets_evaluated_progress_bar.write(f'Start benchmarking {split}...')
+        result_iter = iter(result_datasets[split])
+        for result in tqdm(result_iter, desc='Samples', position=1):
+            times_audio_total += result['length_in_s']
+            times_transcription_total += result['time']
+            if data_args.prompt_text is not None:
+                result['transcription'] = result['transcription'].replace(data_args.prompt_text, '')
+            transcriptions.append(result['transcription'])
+            references.append(result['reference'])
+            if not data_args.precise_tok_per_s:
+                tokens_per_secs.append(result['tokens_per_sec'])
+        norm_transcriptions = [normalizer(pred) for pred in transcriptions]
+        norm_references = [normalizer(label) for label in references]
+        transcriptions = [transcriptions[i] for i in range(len(transcriptions)) if len(norm_references[i]) > 0]
+        references = [references[i] for i in range(len(references)) if len(norm_references[i]) > 0]
+        norm_transcriptions = [norm_transcriptions[i] for i in range(len(norm_transcriptions)) if len(norm_references[i]) > 0]
+        norm_references = [norm_references[i] for i in range(len(norm_references)) if len(norm_references[i]) > 0]
+        stats['wer'] = compute_metrics(norm_transcriptions, norm_references)
+        wer_per_sample = []
+        for (pred, ref) in zip(norm_transcriptions, norm_references):
+            wer_per_sample.append(compute_metrics([pred], [ref]))
+        stats['rtf'] = times_audio_total / times_transcription_total
+        stats['tokens_per_sec'] = sum(tokens_per_secs) / len(tokens_per_secs)
+        stats_dataset[split] = stats
+        wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in stats.items()])
+        datasets_evaluated_progress_bar.write(wer_desc)
+        write_wandb_metric(wandb_logger, stats, prefix=split)
+        if data_args.log_predictions:
+            write_wandb_pred(wandb_logger, transcriptions, references, norm_transcriptions, norm_references, wer_per_sample, prefix=split)
+        rtf_stats['times_audio_total'] += times_audio_total
+        rtf_stats['times_transcription_total'] += times_transcription_total
+        all_stats['wer'] += stats['wer']
+        all_stats['tokens_per_sec'] += stats['tokens_per_sec']
+    all_stats['wer'] = all_stats['wer'] / len(result_datasets)
+    all_stats['rtf'] = rtf_stats['times_audio_total'] / rtf_stats['times_transcription_total']
+    all_stats['tokens_per_sec'] = all_stats['tokens_per_sec'] / len(result_datasets)
+    stats_dataset['all'] = all_stats
+    write_wandb_metric(wandb_logger, all_stats, prefix='all')
+    benchmark_artifact = wandb.Artifact('Benchmark', type='datasets')
+    with tempfile.TemporaryDirectory() as temp_dir:
+        for split in stats_dataset:
+            file_name = os.path.join(temp_dir, f"{'_'.join(split.split('/'))}.json")
+            with open(file_name, 'w') as json_file:
+                json.dump(stats_dataset[split], json_file)
+            benchmark_artifact.add_file(file_name, split)
+        wandb_logger.log_artifact(benchmark_artifact)
+if __name__ == '__main__':
+    main()
+
+# File: distil-whisper-main/training/run_pseudo_labelling.py
+""""""
+import csv
+import logging
+import os
+import sys
+import time
+import warnings
+from dataclasses import dataclass, field
+from datetime import timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import datasets
+import evaluate
+import numpy as np
+import torch
+import transformers
+from accelerate import Accelerator, InitProcessGroupKwargs
+from accelerate.logging import get_logger
+from datasets import DatasetDict, IterableDatasetDict, load_dataset
+from huggingface_hub import HfFolder, create_repo, get_full_repo_name, snapshot_download, upload_folder
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from soundfile import LibsndfileError
+from datasets.arrow_dataset import table_iter
+from transformers import HfArgumentParser, Seq2SeqTrainingArguments, WhisperConfig, WhisperFeatureExtractor, WhisperForConditionalGeneration, WhisperProcessor, WhisperTokenizerFast
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer, EnglishTextNormalizer
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+check_min_version('4.34.0.dev0')
+require_version('datasets>=2.14.6', 'To fix: `pip install --upgrade datasets`')
+logger = get_logger(__name__)
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: str = field(metadata={'help': 'Path to pretrained Whisper model or model identifier from huggingface.co/models'})
+    config_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained config name or path if not the same as model_name'})
+    tokenizer_name: Optional[str] = field(default=None, metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'})
+    feature_extractor_name: Optional[str] = field(default=None, metadata={'help': 'feature extractor name or path if not the same as model_name'})
+    processor_name: Optional[str] = field(default=None, metadata={'help': 'processor name or path if not the same as model_name'})
+    cache_dir: Optional[str] = field(default=None, metadata={'help': 'Where to store the pretrained models downloaded from huggingface.co'})
+    use_fast_tokenizer: bool = field(default=True, metadata={'help': 'Whether to use one of the fast tokenizer (backed by the tokenizers library) or not.'})
+    model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'})
+    subfolder: str = field(default='', metadata={'help': 'In case the relevant files are located inside a subfolder of the model repo on huggingface.co, you canspecify the folder name here.'})
+    token: str = field(default=None, metadata={'help': 'The token to use as HTTP bearer authorization for remote files. If not specified, will use the token generated when running `huggingface-cli login` (stored in `~/.huggingface`).'})
+    dtype: Optional[str] = field(default='float32', metadata={'help': 'The data type (dtype) in which to load the model weights. One of `float32` (full-precision), `float16` or `bfloat16` (both half-precision).'})
+    attn_implementation: Optional[str] = field(default=None, metadata={'help': 'Which attention implementation to use in the encoder and decoder attention layers. Can be one of:\n1. `eager` or `None`: default Transformers attention implementation.\n2. `sdpa`: Flash Attention through PyTorch SDPA. Requires `torch>=2.1`. Recommended for hardware where Flash Attention 2 is not supported, e.g. Turing GPUs, (T4, RTX 2080).\n3. `flash_attn_2`: Flash Attention 2 through the Flash Attention package https://github.com/Dao-AILab/flash-attention. **Always** recommended on supported hardware (Ampere, Ada, or Hopper GPUs, e.g., A100, RTX 3090, RTX 4090, H100).'})
+    attn_type: Optional[str] = field(default=None, metadata={'help': 'Deprecated. Use `attn_implementation` instead.'})
+
+    def __post_init__(self):
+        if self.attn_type is not None and self.attn_implementation is None:
+            if self.attn_type == 'flash_attn':
+                self.attn_implementation = 'sdpa'
+            elif self.attn_type == 'flash_attn_2':
+                self.attn_implementation = 'flash_attention_2'
+            elif self.attn_type in [None, 'eager', 'sdpa', 'flash_attention_2']:
+                self.attn_implementation = self.attn_type
+            else:
+                raise ValueError(f'Argument `--attn_type` is deprecated, and set to an invalid option `{self.attn_type}`. You should omit the argument `--attn_type`, and instead set `-attention_implementation` to one of the following:\n1. `eager` or `None`: default Transformers attention implementation.\n2. `sdpa`: Flash Attention through PyTorch SDPA. Requires `torch>=2.1`. Recommended for hardware where Flash Attention 2 is not supported, e.g. Turing GPUs, (T4, RTX 2080).\n3. `flash_attn_2`: Flash Attention 2 through the Flash Attention package https://github.com/Dao-AILab/flash-attention. **Always** recommended on supported hardware (Ampere, Ada, or Hopper GPUs, e.g., A100, RTX 3090, RTX 4090, H100).')
+            warnings.warn(f'Argument `--attn_type` is deprecated. Use `--attn_implementation` instead. Inferring `--attn_implementation={self.attn_implementation} from argument `--attn_type={self.attn_type}`.')
+        elif self.attn_type is not None and self.attn_implementation is not None:
+            raise ValueError('`--attn_type` and `--attn_implementation` are both specified. Only the argument `--attn_implementation`.')
+
+@dataclass
+class DataTrainingArguments:
+    dataset_name: str = field(default=None, metadata={'help': 'The name of the dataset to use (via the datasets library).'})
+    dataset_config_name: Optional[str] = field(default=None, metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
+    dataset_cache_dir: Optional[str] = field(default=None, metadata={'help': 'Path to cache directory for saving and loading datasets'})
+    overwrite_cache: bool = field(default=False, metadata={'help': 'Overwrite the cached training and evaluation sets'})
+    preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'})
+    preprocessing_batch_size: Optional[int] = field(default=500, metadata={'help': 'The batch size to use for the dataset pre-processing.'})
+    audio_column_name: str = field(default='audio', metadata={'help': "The name of the dataset column containing the audio data. Defaults to 'audio'"})
+    text_column_name: str = field(default='text', metadata={'help': "The name of the dataset column containing the text data. Defaults to 'text'."})
+    id_column_name: str = field(default='id', metadata={'help': "The name of the dataset column containing the id data. Defaults to 'id'"})
+    speaker_id_column_name: str = field(default=None, metadata={'help': 'The name of the dataset column containing the speaker id data. Defaults to None.'})
+    max_duration_in_seconds: float = field(default=30.0, metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'})
+    max_label_length: int = field(default=256, metadata={'help': 'Truncate transcriptions that are longer `max_label_length` tokens.'})
+    concatenate_audio: bool = field(default=True, metadata={'help': 'Whether or not to concatenate the audio samples to `max_duration_in_seconds`.'})
+    preprocessing_only: bool = field(default=False, metadata={'help': 'Whether to only do data preprocessing and skip training. This is especially useful when data preprocessing errors out in distributed training due to timeout. In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` so that the cached datasets can consequently be loaded in distributed training'})
+    dataset_split_name: str = field(default='train+validation+test', metadata={'help': "The name of the data set splits to use (via the datasets library). Defaults to 'train+validation+test'. Multiple splits can be passed by splitting a list through the '+' character, e.g. 'train+validation' will pseudo-label both the 'train' and 'validation' splits sequentially."})
+    wandb_project: str = field(default='distil-whisper', metadata={'help': 'The name of the wandb project.'})
+    streaming: bool = field(default=False, metadata={'help': "Whether to use dataset's streaming mode to load and pre-process the data."})
+    max_samples_per_split: Optional[int] = field(default=None, metadata={'help': 'For debugging purposes, truncate the number of examples per split to this value if set.'})
+    return_timestamps: bool = field(default=False, metadata={'help': 'Whether to return the timestamps with the text. This enables the `FlaxWhisperTimestampsLogitsProcessor`.'})
+    language: str = field(default=None, metadata={'help': 'Language for multilingual distillation. This argument should be set for multilingual distillation only. For English speech recognition, it should be left as `None`.'})
+    task: str = field(default='transcribe', metadata={'help': 'Task, either `transcribe` for speech recognition or `translate` for speech translation.This argument should be set for multilingual distillation only. For English speech recognition, it should be left as `None`.'})
+    decode_token_ids: bool = field(default=True, metadata={'help': 'Deprecated. The predicted token ids should always be decoded to text transcriptions.'})
+    private_dataset: bool = field(default=False, metadata={'help': 'Whether or not to create a private dataset for the pseudo-labelled data.'})
+
+    def __post_init__(self):
+        if not self.decode_token_ids:
+            raise ValueError('The argument `--decode_token_ids` is deprecated. The token ids are now always decoded to their corresponding text string. This is following a fix to the merges of the Whisper tokenizeron the Hugging Face Hub: https://huggingface.co/openai/whisper-large-v2/discussions/100. You should either omit the argument `--decode_token_ids`, or set it to True explicitly.')
+
+def shift_tokens_right(label_ids: np.array, decoder_start_token_id: int) -> np.ndarray:
+    shifted_label_ids = np.zeros_like(label_ids)
+    shifted_label_ids[:, 1:] = label_ids[:, :-1]
+    shifted_label_ids[:, 0] = decoder_start_token_id
+    return shifted_label_ids
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+    decoder_start_token_id: int
+    input_padding: Union[bool, str] = 'max_length'
+    target_padding: Union[bool, str] = 'max_length'
+    max_target_length: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], np.ndarray]]]) -> Dict[str, np.ndarray]:
+        model_input_name = self.processor.model_input_names[0]
+        input_features = {model_input_name: [feature[model_input_name] for feature in features]}
+        label_features = {'input_ids': [feature['labels'] for feature in features]}
+        batch = self.processor.feature_extractor.pad(input_features, padding=self.input_padding, return_tensors='pt')
+        labels_batch = self.processor.tokenizer.pad(label_features, max_length=self.max_target_length, padding=self.target_padding, return_tensors='pt')
+        labels = labels_batch['input_ids'].masked_fill(labels_batch.attention_mask.ne(1), -100)
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+        batch['labels'] = labels
+        return batch
+
+def log_metric(accelerator, metrics: Dict, train_time: float, prefix: str='eval'):
+    log_metrics = {}
+    for (k, v) in metrics.items():
+        log_metrics[f'{prefix}/{k}'] = v
+    log_metrics[f'{prefix}/time'] = train_time
+    accelerator.log(log_metrics)
+
+def log_pred(accelerator, pred_str: List[str], label_str: List[str], norm_pred_str: List[str], norm_label_str: List[str], prefix: str='eval', num_lines: int=200000):
+    if accelerator.is_main_process:
+        wandb_tracker = accelerator.get_tracker('wandb')
+        prefix = prefix.replace('/', '-')
+        str_data = [[label_str[i], pred_str[i], norm_label_str[i], norm_pred_str[i]] for i in range(len(pred_str))]
+        wandb_tracker.log_table(table_name=f'{prefix}/all_predictions', columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data[:num_lines])
+        str_data = np.asarray(str_data)
+        str_data_incorrect = str_data[str_data[:, -2] != str_data[:, -1]]
+        wandb_tracker.log_table(table_name=f'{prefix}/incorrect_predictions', columns=['Target', 'Pred', 'Norm Target', 'Norm Pred'], data=str_data_incorrect[:num_lines])
+
+def main():
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith('.json'):
+        (model_args, data_args, training_args) = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        (model_args, data_args, training_args) = parser.parse_args_into_dataclasses()
+    if model_args.dtype == 'float16':
+        mixed_precision = 'fp16'
+        torch_dtype = torch.float16
+    elif model_args.dtype == 'bfloat16':
+        mixed_precision = 'bf16'
+        torch_dtype = torch.bfloat16
+    else:
+        mixed_precision = 'no'
+        torch_dtype = torch.float32
+    kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=7200))
+    accelerator = Accelerator(gradient_accumulation_steps=training_args.gradient_accumulation_steps, mixed_precision=mixed_precision, log_with=training_args.report_to, project_dir=training_args.output_dir, kwargs_handlers=[kwargs])
+    accelerator.init_trackers(project_name=data_args.wandb_project)
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
+    logger.warning(f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, distributed training: {training_args.parallel_mode.value == 'distributed'}, 16-bits training: {training_args.fp16}")
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+    logger.info('Training/evaluation parameters %s', training_args)
+    raw_datasets = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    token = model_args.token if model_args.token is not None else HfFolder().get_token()
+    data_splits = data_args.dataset_split_name.split('+')
+    for split in data_splits:
+        with accelerator.main_process_first():
+            raw_datasets[split] = load_dataset(data_args.dataset_name, data_args.dataset_config_name, split=split, cache_dir=data_args.dataset_cache_dir, token=token, streaming=data_args.streaming, num_proc=data_args.preprocessing_num_workers if not data_args.streaming else None)
+    if data_args.audio_column_name not in next(iter(raw_datasets.values())).column_names:
+        raise ValueError(f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. Make sure to set `--audio_column_name` to the correct audio column - one of {', '.join(next(iter(raw_datasets.values())).column_names)}.")
+    if data_args.text_column_name not in next(iter(raw_datasets.values())).column_names:
+        raise ValueError(f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. Make sure to set `--text_column_name` to the correct text column - one of {', '.join(next(iter(raw_datasets.values())).column_names)}.")
+    config = WhisperConfig.from_pretrained(model_args.config_name if model_args.config_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=token)
+    feature_extractor = WhisperFeatureExtractor.from_pretrained(model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=token)
+    tokenizer = WhisperTokenizerFast.from_pretrained(model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_fast=model_args.use_fast_tokenizer, revision=model_args.model_revision, token=token)
+    processor = WhisperProcessor.from_pretrained(model_args.processor_name if model_args.processor_name else model_args.model_name_or_path, cache_dir=model_args.cache_dir, revision=model_args.model_revision, token=token)
+    model = WhisperForConditionalGeneration.from_pretrained(model_args.model_name_or_path, config=config, cache_dir=model_args.cache_dir, revision=model_args.model_revision, subfolder=model_args.subfolder, token=token, low_cpu_mem_usage=True, torch_dtype=torch_dtype, attn_implementation=model_args.attn_implementation)
+    model.eval()
+    if model.config.decoder_start_token_id is None:
+        raise ValueError('Make sure that `config.decoder_start_token_id` is correctly defined')
+    return_timestamps = data_args.return_timestamps
+    if hasattr(model.generation_config, 'is_multilingual') and model.generation_config.is_multilingual:
+        is_multilingual = True
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task, predict_timestamps=return_timestamps)
+    elif data_args.language is not None:
+        raise ValueError('Setting language token for an English-only checkpoint is not permitted. The language argument should only be set for multilingual checkpoints.')
+    else:
+        is_multilingual = False
+    raw_datasets = raw_datasets.cast_column(data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate))
+    max_input_length = int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate)
+    max_label_length = data_args.max_label_length if data_args.max_label_length is not None else model.config.max_length
+    audio_column_name = data_args.audio_column_name
+    sampling_rate = feature_extractor.sampling_rate
+    preprocessing_batch_size = data_args.preprocessing_batch_size
+    num_workers = data_args.preprocessing_num_workers
+    dataloader_num_workers = training_args.dataloader_num_workers
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    id_column_name = data_args.id_column_name
+    speaker_id_column_name = data_args.speaker_id_column_name
+    normalizer = BasicTextNormalizer() if data_args.language is not None else EnglishTextNormalizer(tokenizer.english_spelling_normalizer)
+    timestamp_position = 3 if is_multilingual else 1
+    decoder_prev_token_id = tokenizer.convert_tokens_to_ids('<|startofprev|>')
+    decoder_eot_token_id = tokenizer.eos_token_id
+    if data_args.max_samples_per_split is not None:
+        for split in data_splits:
+            raw_datasets[split] = raw_datasets[split].take(data_args.max_samples_per_split) if data_args.streaming else raw_datasets[split].select(range(data_args.max_samples_per_split))
+    if speaker_id_column_name is not None:
+        raw_datasets = raw_datasets.sort(speaker_id_column_name)
+
+    def concatenate_dataset(batch):
+        (audio_arrays, texts, speaker_ids) = ([], [], [])
+        for row in table_iter(batch.pa_table, batch_size=1):
+            row = batch.formatter.format_row(row)
+            try:
+                sample_audio = row[audio_column_name]['array']
+                sample_text = row[text_column_name]
+                sample_speaker_id = row[speaker_id_column_name] if speaker_id_column_name else None
+            except LibsndfileError:
+                logger.warning(f'{row[id_column_name]} is corrupted! Skipping sample.')
+                continue
+            audio_arrays.append(sample_audio)
+            texts.append(sample_text)
+            speaker_ids.append(sample_speaker_id)
+        concat_audio = [audio_arrays[0]]
+        concat_text = [texts[0]]
+        concat_speaker_id = [speaker_ids[0]]
+        condition_on_prev = [0]
+        for (audio_array, text, speaker_id) in zip(audio_arrays[1:], texts[1:], speaker_ids[1:]):
+            is_same_speaker = speaker_id == concat_speaker_id[-1]
+            is_concatenable = len(audio_array) + len(concat_audio[-1]) <= max_input_length
+            if is_same_speaker and is_concatenable:
+                concat_audio[-1] = np.append(concat_audio[-1], audio_array)
+                concat_text[-1] = concat_text[-1] + ' ' + text
+            else:
+                concat_audio.append(audio_array)
+                concat_text.append(text)
+                concat_speaker_id.append(speaker_id)
+                condition_on_prev.append(1 if is_same_speaker else 0)
+        batch[audio_column_name] = [{'array': array, 'sampling_rate': sampling_rate} for array in concat_audio]
+        batch[text_column_name] = concat_text
+        batch[id_column_name] = concat_speaker_id
+        batch['condition_on_prev'] = condition_on_prev
+        return batch
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    if data_args.concatenate_audio and (not data_args.streaming):
+        with accelerator.main_process_first():
+            raw_datasets = raw_datasets.map(concatenate_dataset, batched=True, batch_size=preprocessing_batch_size, num_proc=num_workers, remove_columns=set(raw_datasets_features) - {audio_column_name, text_column_name, id_column_name, 'condition_on_prev'}, desc='Concatenating dataset...')
+        raw_datasets = raw_datasets.cast_column(audio_column_name, datasets.features.Audio(sampling_rate=sampling_rate))
+        pretty_name = data_args.dataset_name.split('/')[-1]
+
+        def postprocess_ids(speaker_ids, indices):
+            speaker_ids_formatted = []
+            for (speaker, idx) in zip(speaker_ids, indices):
+                formatted_idx = f'{pretty_name}-{speaker}-{idx}' if speaker is not None else f'{pretty_name}-{idx}'
+                speaker_ids_formatted.append(formatted_idx)
+            return {id_column_name: speaker_ids_formatted}
+        with accelerator.main_process_first():
+            raw_datasets = raw_datasets.map(postprocess_ids, input_columns=[id_column_name], with_indices=True, desc='Setting sample idxs...', batched=True, batch_size=preprocessing_batch_size, num_proc=num_workers)
+    elif data_args.concatenate_audio and data_args.streaming:
+        raise ValueError('Streaming mode is not yet compatible with concatenating audios to `max_duration_in_seconds`.Either set `--streaming=False` and download the audios locally, or open an issue on the Distil-Whisper repo to request this feature.')
+
+    def prepare_dataset(batch):
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample['array'], sampling_rate=sample['sampling_rate'])
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        input_str = batch[text_column_name]
+        batch['labels'] = tokenizer(input_str, max_length=max_label_length, truncation=True).input_ids
+        return batch
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    file_ids_dataset = IterableDatasetDict() if data_args.streaming else DatasetDict()
+    for split in raw_datasets:
+        file_ids_dataset[split] = raw_datasets[split][id_column_name]
+    if data_args.streaming:
+        with accelerator.main_process_first():
+            vectorized_datasets = raw_datasets.map(prepare_dataset, remove_columns=raw_datasets_features)
+    else:
+        with accelerator.main_process_first():
+            vectorized_datasets = raw_datasets.map(prepare_dataset, remove_columns=raw_datasets_features, num_proc=num_workers, desc='preprocess dataset')
+    if data_args.preprocessing_only:
+        cache = {k: v.cache_files for (k, v) in vectorized_datasets.items()}
+        logger.info(f'Data preprocessing finished. Files cached at {cache}.')
+        return
+    if data_args.streaming and dataloader_num_workers > 0:
+        logger.warning('Using multiple dataloader num workers with streaming mode will result in different shards of data being transcribed in parallel. This is not advised if you want to preserve the order of the audio-text data.')
+    output_dir = training_args.output_dir
+    if accelerator.is_main_process:
+        if training_args.push_to_hub:
+            if training_args.hub_model_id is None:
+                repo_name = get_full_repo_name(Path(output_dir).absolute().name, token=training_args.hub_token)
+            else:
+                repo_name = training_args.hub_model_id
+            create_repo(repo_name, repo_type='dataset', exist_ok=True, token=training_args.hub_token)
+            snapshot_download(repo_id=repo_name, local_dir=output_dir)
+            with open(os.path.join(output_dir, '.gitattributes'), 'r+') as f:
+                git_lfs_extensions = f.read()
+                if '*.csv' not in git_lfs_extensions:
+                    f.write('*.csv filter=lfs diff=lfs merge=lfs -text')
+        elif output_dir is not None:
+            os.makedirs(output_dir, exist_ok=True)
+    accelerator.wait_for_everyone()
+    metric = evaluate.load('wer')
+
+    def compute_metrics(preds, labels, file_ids):
+        for idx in range(len(labels)):
+            labels[idx][labels[idx] == -100] = tokenizer.pad_token_id
+        pred_str = tokenizer.batch_decode(preds, skip_special_tokens=False, decode_with_timestamps=return_timestamps)
+        label_str = tokenizer.batch_decode(labels, skip_special_tokens=True)
+        norm_pred_str = [normalizer(pred) for pred in pred_str]
+        norm_label_str = [normalizer(label) for label in label_str]
+        pred_str = [pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        label_str = [label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        file_ids = [file_ids[i] for i in range(len(file_ids)) if len(norm_label_str[i]) > 0]
+        norm_pred_str = [norm_pred_str[i] for i in range(len(norm_pred_str)) if len(norm_label_str[i]) > 0]
+        norm_label_str = [norm_label_str[i] for i in range(len(norm_label_str)) if len(norm_label_str[i]) > 0]
+        wer = 100 * metric.compute(predictions=norm_pred_str, references=norm_label_str)
+        return ({'wer': wer}, pred_str, label_str, norm_pred_str, norm_label_str, file_ids)
+
+    def filter_eot_tokens(preds):
+        for idx in range(len(preds)):
+            token_ids = [token for token in preds[idx] if token != decoder_eot_token_id]
+            token_ids = token_ids + [decoder_eot_token_id]
+            preds[idx] = token_ids
+        return preds
+    per_device_eval_batch_size = int(training_args.per_device_eval_batch_size)
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor, decoder_start_token_id=model.config.decoder_start_token_id, input_padding='longest', target_padding='max_length', max_target_length=max_label_length)
+    num_beams = training_args.generation_num_beams if training_args.generation_num_beams is not None else getattr(model.generation_config, 'num_beams', 1)
+    gen_kwargs = {'max_length': max_label_length, 'num_beams': num_beams, 'return_timestamps': return_timestamps}
+    if hasattr(model.generation_config, 'is_multilingual') and model.generation_config.is_multilingual:
+        gen_kwargs.update({'language': data_args.language, 'task': data_args.task})
+    model.generation_config.forced_decoder_ids = None
+    model.config.forced_decoder_ids = None
+    model = accelerator.prepare(model)
+
+    def eval_step_with_save(split='eval'):
+        eval_preds = []
+        eval_labels = []
+        eval_ids = []
+        pred_str = []
+        eval_start = time.time()
+        eval_loader = DataLoader(vectorized_datasets[split], batch_size=per_device_eval_batch_size, collate_fn=data_collator, num_workers=dataloader_num_workers, pin_memory=True)
+        file_loader = DataLoader(file_ids_dataset[split], batch_size=per_device_eval_batch_size * accelerator.num_processes, num_workers=dataloader_num_workers)
+        eval_loader = accelerator.prepare(eval_loader)
+        batches = tqdm(eval_loader, desc=f'Evaluating {split}...', disable=not accelerator.is_local_main_process)
+        split = split.replace('.', '-').split('/')[-1]
+        output_csv = os.path.join(output_dir, f'{split}-transcription.csv')
+        for (step, (batch, file_ids)) in enumerate(zip(batches, file_loader)):
+            generate_fn = model.module.generate if accelerator.num_processes > 1 else model.generate
+            generated_ids = generate_fn(batch['input_features'].to(dtype=torch_dtype), **gen_kwargs)
+            generated_ids = accelerator.pad_across_processes(generated_ids, dim=1, pad_index=tokenizer.pad_token_id)
+            (generated_ids, labels) = accelerator.gather_for_metrics((generated_ids, batch['labels']))
+            eval_preds.extend(generated_ids.cpu().numpy())
+            eval_labels.extend(labels.cpu().numpy())
+            eval_ids.extend(file_ids)
+            if step % training_args.logging_steps == 0 and step > 0:
+                batches.write(f'Saving transcriptions for split {split} step {step}')
+                accelerator.wait_for_everyone()
+                pred_ids = eval_preds[-(len(eval_preds) - len(pred_str)):]
+                pred_ids = filter_eot_tokens(pred_ids)
+                pred_str.extend(tokenizer.batch_decode(pred_ids, skip_special_tokens=False, decode_with_timestamps=return_timestamps))
+                csv_data = [[eval_ids[i], pred_str[i]] for i in range(len(eval_preds))]
+                with open(output_csv, 'w', encoding='UTF8', newline='') as f:
+                    writer = csv.writer(f)
+                    writer.writerow(['file_id', 'whisper_transcript'])
+                    writer.writerows(csv_data)
+                if training_args.push_to_hub and accelerator.is_main_process:
+                    upload_folder(folder_path=output_dir, repo_id=repo_name, repo_type='dataset', commit_message=f'Saving transcriptions for split {split} step {step}.')
+        accelerator.wait_for_everyone()
+        eval_time = time.time() - eval_start
+        wer_desc = ''
+        if 'validation' in split or 'test' in split:
+            eval_preds = filter_eot_tokens(eval_preds)
+            (wer_metric, pred_str, label_str, norm_pred_str, norm_label_str, eval_ids) = compute_metrics(eval_preds, eval_labels, eval_ids)
+            wer_desc = ' '.join([f'Eval {key}: {value} |' for (key, value) in wer_metric.items()])
+            log_metric(accelerator, metrics=wer_metric, train_time=eval_time, prefix=split)
+            log_pred(accelerator, pred_str, label_str, norm_pred_str, norm_label_str, prefix=split)
+        else:
+            pred_ids = eval_preds[-(len(eval_preds) - len(pred_str)):]
+            pred_ids = filter_eot_tokens(pred_ids)
+            pred_str.extend(tokenizer.batch_decode(pred_ids, skip_special_tokens=False, decode_with_timestamps=return_timestamps))
+        batches.write(f'Saving final transcriptions for split {split}.')
+        csv_data = [[eval_ids[i], eval_preds[i]] for i in range(len(eval_preds))]
+        with open(output_csv, 'w', encoding='UTF8', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow(['file_id', 'whisper_transcript'])
+            writer.writerows(csv_data)
+        logger.info(wer_desc)
+        if not data_args.streaming:
+            raw_datasets[split] = raw_datasets[split].add_column('whisper_transcript', pred_str)
+            raw_datasets[split] = raw_datasets[split].add_column('eval_preds', eval_preds)
+
+            def add_concatenated_text(eval_preds, condition_on_prev):
+                concatenated_prev = [None]
+                for (token_ids, condition) in zip(eval_preds[:-1], condition_on_prev[1:]):
+                    if condition is False:
+                        concatenated_prev.append(None)
+                    else:
+                        prompt_ids = [token for token in token_ids if token != decoder_eot_token_id]
+                        prompt_ids = [decoder_prev_token_id] + prompt_ids[timestamp_position:]
+                        concatenated_prev.append(prompt_ids)
+                return {'condition_on_prev': concatenated_prev}
+            if data_args.concatenate_audio:
+                with accelerator.main_process_first():
+                    raw_datasets[split] = raw_datasets[split].map(add_concatenated_text, input_columns=['eval_preds', 'condition_on_prev'], remove_columns=['eval_preds'], desc='Setting condition on prev...', batched=True, batch_size=preprocessing_batch_size, num_proc=num_workers)
+    logger.info('***** Running Labelling *****')
+    logger.info(f'  Instantaneous batch size per device = {training_args.per_device_eval_batch_size}')
+    logger.info(f'  Total eval batch size (w. parallel & distributed) = {training_args.per_device_eval_batch_size * accelerator.num_processes}')
+    logger.info(f'  Predict labels with timestamps = {return_timestamps}')
+    for split in data_splits:
+        eval_step_with_save(split=split)
+        accelerator.wait_for_everyone()
+        if training_args.push_to_hub and accelerator.is_main_process:
+            upload_folder(folder_path=output_dir, repo_id=repo_name, repo_type='dataset', commit_message=f"Saving final transcriptions for split {split.replace('.', '-').split('/')[-1]}")
+    if not data_args.streaming and accelerator.is_main_process:
+        raw_datasets.save_to_disk(output_dir, num_proc=num_workers)
+        if training_args.push_to_hub:
+            raw_datasets.push_to_hub(repo_name, config_name=data_args.dataset_config_name)
+    accelerator.end_training()
+if __name__ == '__main__':
+    main()
+