# Whisper [Whisper](https://huggingface.co/papers/2212.04356) — это трансформер с архитектурой «кодировщик-декодер» (sequence-to-sequence), предварительно обученный на 680 000 часов размеченных аудиоданных. Такой объём данных для предварительного обучения обеспечивает работу в режиме zero-shot на задачах обработки аудио на английском и многих других языках. Декодер позволяет Whisper преобразовывать представления речи, полученные кодировщиком, в полезные результаты, например текст, без дополнительного дообучения. Whisper готов к работе сразу после установки. Все исходные контрольные точки Whisper можно найти в коллекции [Whisper](https://huggingface.co/collections/openai/whisper-release-6501bba2cf999715fd953013). > [!TIP] > Щёлкните по моделям Whisper в боковой панели справа, чтобы увидеть больше примеров применения Whisper к различным задачам обработки аудио. > > Установите `use_kernels=True` в [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained), чтобы заменить поддерживаемые слои на оптимизированные ядра из Hub. Подробнее см. в разделе [Загрузка ядер](../kernel_doc/loading_kernels). Приведённый ниже пример показывает, как автоматически преобразовать речь в текст с помощью [Pipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline) или класса [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel). ```python from transformers import pipeline pipeline = pipeline( task="automatic-speech-recognition", model="openai/whisper-large-v3-turbo", device=0 ) pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac") ``` ```python # pip install datasets from datasets import load_dataset from transformers import AutoProcessor, WhisperForConditionalGeneration processor = AutoProcessor.from_pretrained( "openai/whisper-large-v3-turbo", ) model = WhisperForConditionalGeneration.from_pretrained( "openai/whisper-large-v3-turbo", device_map="auto", attn_implementation="sdpa" ) ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") audio_sample = ds[0]["audio"] input_features = processor( audio_sample["array"], sampling_rate=audio_sample["sampling_rate"], return_tensors="pt" ).input_features input_features = input_features.to(model.device, dtype=model.dtype) predicted_ids = model.generate(input_features, cache_implementation="static") transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True) transcription[0] ``` ## Примечания - Whisper использует собственный `generate` для инференса, обязательно ознакомьтесь с документацией ниже. - Объект [WhisperProcessor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperProcessor) используется для подготовки аудио и декодирования предсказанных идентификаторов обратно в текст. ## WhisperConfig[[transformers.WhisperConfig]] #### transformers.WhisperConfig[[transformers.WhisperConfig]] ```python transformers.WhisperConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, vocab_size: int = 51865, num_mel_bins: int = 80, encoder_layers: int = 4, encoder_attention_heads: int = 6, decoder_layers: int = 4, decoder_attention_heads: int = 6, decoder_ffn_dim: int = 1536, encoder_ffn_dim: int = 1536, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, decoder_start_token_id: int = 50257, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 384, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, scale_embedding: bool = False, max_source_positions: int = 1500, max_target_positions: int = 448, pad_token_id: int | None = 50256, bos_token_id: int | None = 50256, eos_token_id: int | list[int] | None = 50256, suppress_tokens: list | None = None, begin_suppress_tokens: list[int] | tuple[int, ...] | None = (220, 50256), use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, apply_spec_augment: bool = False, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, median_filter_width: int = 7, tie_word_embeddings: bool = True) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/configuration_whisper.py#L50) **Параметры:** is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера. vocab_size (`int`, *необязательный*, по умолчанию `51865`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`. num_mel_bins (`int`, *optional*, по умолчанию `80`) : Количество мел-признаков, используемых на входной кадр. Должно соответствовать значению, используемому в классе `AutoFeatureExtractor`. encoder_layers (`int`, *optional*, по умолчанию `4`) : Количество скрытых слоев в кодере Transformer. Если не задано, будет использовано то же значение, что и у `num_layers`. encoder_attention_heads (`int`, *необязательный*, по умолчанию `6`) : Количество головок внимания для каждого слоя внимания в кодере Transformer. decoder_layers (`int`, *optional*, по умолчанию `4`) : Количество скрытых слоев в декодере Transformer. Если не задано, будет использовано то же значение, что и у `num_layers`. decoder_attention_heads (`int`, *необязательный*, по умолчанию `6`) : Количество головок внимания для каждого слоя внимания в декодере Transformer. decoder_ffn_dim (`int`, *optional*, по умолчанию `1536`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в декодере. encoder_ffn_dim (`int`, *optional*, по умолчанию `1536`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в энкодере. encoder_layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop для энкодера. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556). decoder_layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop для декодера. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556). decoder_start_token_id (`int`, *optional*, по умолчанию `50257`) : Если модель с кодировщиком-декодировщиком начинает декодирование с токена, отличного от `bos`, идентификатор этого токена. use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером. activation_function (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. d_model (`int`, *необязательный*, по умолчанию `384`) : Размер слоев кодировщика и пулера. dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент для всех слоёв dropout. attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания. activation_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для активаций внутри полносвязного слоя. init_std (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. scale_embedding (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли масштабировать эмбеддинги, деля их на sqrt(d_model). max_source_positions (`int`, *optional*, по умолчанию 1500) : Максимальная длина последовательности признаков log-mel filter-bank, с которой может использоваться данная модель. max_target_positions (`int`, *optional*, по умолчанию 448) : Максимальная длина последовательности, с которой эта модель может использоваться. Как правило, стоит задать достаточно большое значение на всякий случай (например, 512, 1024 или 2048). pad_token_id (`int`, *необязательный*, по умолчанию `50256`) : Идентификатор токена, используемый для выравнивания в словаре. bos_token_id (`int`, *необязательный*, по умолчанию `50256`) : Идентификатор токена, используемый для обозначения начала потока в словаре. eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `50256`) : Идентификатор токена, используемый для обозначения конца потока в словаре. suppress_tokens (`list[int]`, *optional*) : Список, содержащий неречевые токены, которые будут использоваться процессором логитов в функции `generate`. NON_SPEECH_TOKENS и NON_SPEECH_TOKENS_MULTI соответствуют моделям `english-only` и `multilingual` соответственно. begin_suppress_tokens (`list[int]`, *необязательный*, по умолчанию `[220,50256]`) : Список токенов, которые будут подавляться в начале процесса выборки. Инициализируется как токен для `" "` (`blank_token_id`) и `eos_token_id` use_weighted_layer_sum (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли взвешенное среднее выходов слоёв с обучаемыми весами. Актуально только при использовании экземпляра [WhisperForAudioClassification](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperForAudioClassification). classifier_proj_size (`int`, *optional*, по умолчанию 256) : Размерность проекции перед усреднением токенов для классификации. Актуально только при использовании экземпляра [WhisperForAudioClassification](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperForAudioClassification). apply_spec_augment (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять аугментацию данных *SpecAugment* к выходным данным кодировщика признаков. Для справки см. [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779). mask_time_prob (`float`, *optional*, по умолчанию 0.05) : Доля (от 0 до 1) всех векторов признаков вдоль временной оси, которые будут замаскированы. Процедура маскирования генерирует `mask_time_prob*len(time_axis)/mask_time_length` независимых масок вдоль оси. Если рассуждать с точки зрения вероятности того, что каждый вектор признаков будет выбран в качестве начала векторного диапазона для маскирования, *mask_time_prob* должно быть равно `prob_vector_start*mask_time_length`. Обратите внимание, что перекрытие может уменьшить фактическую долю замаскированных векторов. Это имеет значение только в том случае, если `apply_spec_augment == True`. mask_time_length (`int`, *optional*, по умолчанию 10) : Длина векторного охвата вдоль временной оси. mask_time_min_masks (`int`, *optional*, по умолчанию 2), : минимальное количество масок длины `mask_feature_length`, генерируемых вдоль временной оси, на каждом шаге времени, независимо от `mask_feature_prob`. Актуально только если ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks'' mask_feature_prob (`float`, *optional*, по умолчанию 0.0) : Доля (от 0 до 1) всех векторов признаков вдоль оси признаков, которые будут замаскированы. Процедура маскирования генерирует `mask_feature_prob*len(feature_axis)/mask_time_length` независимых масок вдоль оси. Если рассуждать с точки зрения вероятности того, что каждый вектор признаков будет выбран в качестве начала векторного диапазона для маскирования, *mask_feature_prob* должно быть равно `prob_vector_start*mask_feature_length`. Обратите внимание, что перекрытие может уменьшить фактическую долю замаскированных векторов. Это имеет значение только в том случае, если `apply_spec_augment is True`. mask_feature_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Процент (от 0 до 1) всех векторов признаков вдоль оси признаков, которые будут замаскированы. Процедура маскирования генерирует `mask_feature_prob*len(feature_axis)/mask_time_length` независимых масок вдоль оси. Если рассуждать с точки зрения вероятности того, что каждый вектор признаков будет выбран в качестве начала векторного диапазона для маскирования, *mask_feature_prob* должен быть равен `prob_vector_start*mask_feature_length`. Обратите внимание, что перекрытие может уменьшить фактический процент замаскированных векторов. Это имеет значение только в том случае, если `apply_spec_augment` равно `True`. mask_feature_length (`int`, *optional*, по умолчанию 10) : Длина векторного охвата вдоль оси признаков. mask_feature_min_masks (`int`, *optional*, по умолчанию 0) : минимальное количество масок длины `mask_feature_length`, генерируемых вдоль оси признаков на каждом шаге времени, независимо от `mask_feature_prob`. Актуально только если `mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks`. median_filter_width (`int`, *optional*, по умолчанию 7) : Ширина медианного фильтра, используемого для сглаживания выходов кросс-внимания при вычислении временных меток токенов. Должно быть нечётным числом. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. Это класс конфигурации для хранения настроек модели WhisperModel. Он используется для создания экземпляра модели Whisper в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [openai/whisper-tiny](https://huggingface.co/openai/whisper-tiny) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```python >>> from transformers import WhisperConfig, WhisperModel >>> # Initializing a Whisper tiny style configuration >>> configuration = WhisperConfig() >>> # Initializing a model (with random weights) from the tiny style configuration >>> model = WhisperModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## WhisperTokenizer[[transformers.WhisperTokenizer]] #### transformers.WhisperTokenizer[[transformers.WhisperTokenizer]] ```python transformers.WhisperTokenizer(vocab: str | dict[str, int] | None = None, merges = None, normalizer_file = None, unk_token = '<|endoftext|>', bos_token = '<|endoftext|>', eos_token = '<|endoftext|>', add_prefix_space = False, language = None, task = None, predict_timestamps = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L163) **Параметры:** vocab_file (`str`, *необязательный*) : Путь к файлу словаря. merges_file (`str`, *необязательный*) : Путь к файлу слияний. normalizer_file (`str`, *необязательный*) : Путь к файлу normalizer_file. tokenizer_file (`str`, *необязательный*) : Путь к файлу [tokenizers](https://github.com/huggingface/tokenizers) (обычно с расширением .json), содержащему всё необходимое для загрузки токенизатора. unk_token (`str`, *необязательный*, по умолчанию `"<|endoftext|>"`) : Токен неизвестного слова. Токен, отсутствующий в словаре, не может быть преобразован в ID, вместо этого ему присваивается данный токен. bos_token (`str`, *необязательный*, по умолчанию `"<|endoftext|>"`) : Токен начала последовательности. `decoder_start_token_id` используется для установки первого токена как `"<|startoftranscript|>"` при генерации. eos_token (`str`, *необязательный*, по умолчанию `"<|endoftext|>"`) : Токен конца последовательности. add_prefix_space (`bool`, *необязательный*, по умолчанию `False`) : Добавлять ли начальный пробел к входным данным. Это позволяет обрабатывать первое слово так же, как и любое другое. (Токенизатор Whisper определяет начало слов по предшествующему пробелу). language (`str`, *optional*) : Язык текста транскрипции. Соответствующий токен идентификатора языка добавляется в начало последовательности для задач многоязычного распознавания речи и перевода речи, например, для испанского языка в начало последовательности добавляется токен `"<|es|>"`. Это следует использовать только для многоязычной дообучения. task (`str`, *optional*) : Идентификатор задачи, добавляемый в начало последовательности (если требуется). Используется для многоязычной дообучения: `"transcribe"` для распознавания речи и `"translate"` для перевода речи. predict_timestamps (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли опускать токен `<|notimestamps|>` в начале последовательности. Создайте «быстрый» токенизатор Whisper (на базе библиотеки *tokenizers* от HuggingFace). Этот токенизатор наследуется от [PreTrainedTokenizerFast](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend), который содержит большинство основных методов. Для получения дополнительной информации об этих методах пользователям следует обратиться к этому суперклассу. #### set_prefix_tokens[[transformers.WhisperTokenizer.set_prefix_tokens]] ```python set_prefix_tokens(language: str | None = None, task: str | None = None, predict_timestamps: bool | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L585) **Параметры:** language (`str`, *необязательный*, по умолчанию `None`) : Язык текста транскрипции. task (`str`, *необязательный*, по умолчанию `None`) : Идентификатор задачи, который добавляется в начало последовательности (если он есть). predict_timestamps (`bool`, *необязательный*, по умолчанию `None`) : Указывает, следует ли опускать токен `<|notimestamps|>` в начале последовательности. Переопределяет префиксные токены, добавляемые в начало последовательности меток. Этот метод можно использовать самостоятельно, чтобы обновляйте префиксные токены по мере необходимости при дообучении. Пример: ```python >>> # instantiate the tokenizer and set the prefix token to Spanish >>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish") >>> # now switch the prefix token from Spanish to French >>> tokenizer.set_prefix_tokens(language="french") ``` #### get_special_tokens_mask[[transformers.WhisperTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L669) **Параметры:** token_ids_0 (`list[int]`) : Список идентификаторов. token_ids_1 (`list[int]`, *необязательный*) : Необязательный второй список идентификаторов для пар последовательностей. already_has_special_tokens (`bool`, *необязательный*, по умолчанию `False`) : Указывает, является ли список токенов уже отформатированным со специальными токенами для модели. **Возвращает:** `list[int]` Список целых чисел в диапазоне [0, 1]: 1 для специального токена, 0 для токена последовательности. Получить идентификаторы последовательностей из списка токенов, в который не добавлены специальные токены. Этот метод вызывается при добавлении специальных токенов с помощью метода `prepare_for_model` токенизатора. #### save_vocabulary[[transformers.WhisperTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L555) #### batch_decode[[transformers.WhisperTokenizer.batch_decode]] ```python batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2933) **Параметры:** sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Список идентификаторов токенизированного входа. Может быть получен с помощью метода `__call__`. skip_special_tokens (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли удалять специальные токены при декодировании. clean_up_tokenization_spaces (`bool`, *необязательный*) : Указывает, следует ли очищать пробелы токенизации. Если `None`, по умолчанию используется `self.clean_up_tokenization_spaces`. kwargs (дополнительные аргументы ключ-значение, *необязательные*): будут переданы в специфичный для базовой модели метод декодирования. **Возвращает:** `list[str]` Список декодированных предложений. Преобразуйте список списков идентификаторов токенов в список строк, вызвав decode. Этот метод предоставляется в целях обратной совместимости. Метод `decode` теперь нативно обрабатывает пакетный ввод, поэтому вы можете использовать `decode` напрямую вместо `batch_decode`. #### decode[[transformers.WhisperTokenizer.decode]] ```python decode(token_ids, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_offsets: bool = False, time_precision: float = 0.02, decode_with_timestamps: bool = False, normalize: bool = False, basic_normalize: bool = False, remove_diacritics: bool = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L432) **Параметры:** token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : Список идентификаторов токенизированного входа. Может быть получен с помощью метода `__call__`. skip_special_tokens (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли удалять специальные токены при декодировании. Если предыдущие токены (до промпта) присутствуют, они также будут удалены. clean_up_tokenization_spaces (`bool`, *необязательный*) : Нужно ли очищать пробелы токенизации. Если `None`, по умолчанию используется `self.clean_up_tokenization_spaces` (доступно в `tokenizer_config`). output_offsets (`bool`, *необязательный*, по умолчанию `False`) : Включает или отключает вывод смещений токенов. Этот параметр следует устанавливать только в том случае, если модель предсказала временные метки. Если есть предыдущие токены (до промпта) для декодирования, они появятся в декодированном тексте только в том случае, если содержат токены временных меток. time_precision (`float`, *необязательный*, по умолчанию 0.02) : Коэффициент времени для преобразования из токенов во время. decode_with_timestamps (`bool`, *необязательный*, по умолчанию `False`) : Включать или нет временные метки в исходный текст при декодировании. normalize (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять нормализатор английского текста к декодированному тексту. Применимо только в том случае, если целевой текст на английском языке. В противном случае следует применять базовый нормализатор текста. basic_normalize (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять нормализатор Basic к декодированному тексту. Применимо к многоязычному целевому тексту. remove_diacritics (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли удалять диакритические знаки при применении базового нормализатора текста. Удаление диакритики может привести к потере информации в декодированном тексте, поэтому используйте эту опцию с осторожностью. kwargs (дополнительные аргументы ключ-значение, *необязательные*): будут переданы в специфичный для базовой модели метод декодирования. **Возвращает:** `str` Расшифрованное предложение. Преобразует последовательность идентификаторов в строку, используя токенизатор и словарь, с опциями для удаления специальных токенов и очистки пробелов токенизации. Аналогично выполнению `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`. #### basic_normalize[[transformers.WhisperTokenizer.basic_normalize]] ```python basic_normalize(text, remove_diacritics = False) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L546) Нормализуйте заданную строку с помощью класса `BasicTextNormalizer`, который выполняет базовые преобразования для многоязычного текста. #### normalize[[transformers.WhisperTokenizer.normalize]] ```python normalize(text) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/tokenization_whisper.py#L538) Нормализуйте заданную строку с помощью класса `EnglishTextNormalizer`, который выполняет стандартные преобразования английского текста. ## WhisperFeatureExtractor[[transformers.WhisperFeatureExtractor]] #### transformers.WhisperFeatureExtractor[[transformers.WhisperFeatureExtractor]] ```python transformers.WhisperFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/feature_extraction_whisper.py#L33) **Параметры:** feature_size (`int`, *optional*, по умолчанию 80) : Размерность признаков извлекаемых фич. sampling_rate (`int`, *optional*, по умолчанию 16000) : Частота дискретизации, с которой аудиофайлы должны быть оцифрованы, выраженная в герцах (Гц). hop_length (`int`, *optional*, по умолчанию 160) : Длина перекрывающихся окон для STFT, используемой для получения коэффициентов Мел-частот. chunk_length (`int`, *optional*, по умолчанию 30) : Максимальное количество фрагментов по `sampling_rate` выборок, используемых для обрезки и дополнения более длинных или коротких аудиопоследовательностей. n_fft (`int`, *необязательный*, по умолчанию 400) : Размер преобразования Фурье. padding_value (`float`, *optional*, по умолчанию 0.0) : Значение, используемое для дополнения аудио. Должно соответствовать тишине. dither (`float`, *optional*, по умолчанию 0.0) : Добавляет диттеринг. Иными словами, добавляет небольшой гауссов шум к каждому кадру. Например, значение 0.0001 добавляет диттеринг с нормальным распределением, центрированным вокруг 0.0 и со стандартным отклонением 0.0001 (при условии диапазона [-1,+1] для raw_speech). Значение 0.0 означает отсутствие диттеринга. Диттеринг оказывает аналогичный эффект, что и `spectrogram(mel_floor=...)`. Он снижает высокие значения log_mel_fbank для сигналов с участками, где значения строго равны нулю, если в сигнале присутствует порог VAD. Создаёт экстрактор признаков Whisper. Этот экстрактор признаков наследуется от [SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), который содержит большинство основных методов. За дополнительной информацией о них следует обращаться к этому суперклассу. Этот класс извлекает характеристики банка мел-фильтров из исходной речи с помощью собственной реализации `Short Time Fourier Transform` на numpy, которая должна совпадать с эквивалентом `torch.stft` в pytorch. #### __call__[[transformers.WhisperFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = None, padding: str | None = 'max_length', max_length: int | None = None, sampling_rate: int | None = None, do_normalize: bool | None = None, device: str | None = 'cpu', **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/feature_extraction_whisper.py#L193) **Параметры:** raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Последовательность или батч последовательностей, для которых требуется выравнивание. Каждая последовательность может быть массивом numpy, списком значений float, списком массивов numpy или списком списков значений float. Аудио должно быть моноканальным, а не стерео, то есть одно значение float на временной шаг. truncation (`bool`, *необязательный*, по умолчанию `True`) : Включает усечение, чтобы обрезать входные последовательности длиннее *max_length* до *max_length*. pad_to_multiple_of (`int`, *optional*, по умолчанию None) : Если задано, последовательность будет дополнена нулями до кратного указанного значения. Это особенно полезно для использования Tensor Cores на оборудовании NVIDIA с вычислительной способностью `>= 7.5` (Volta) или на TPU, где производительность повышается при длине последовательности, кратной 128. return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры вместо списка целых чисел Python. Допустимые значения: - `'pt'`: Возвращает объекты `torch.Tensor` PyTorch. - `'np'`: Возвращает объекты `np.ndarray` Numpy. return_attention_mask (`bool`, *необязательный*) : Нужно ли возвращать маску внимания. Если значение не указано, маска внимания будет возвращена в соответствии со значением по умолчанию конкретного feature_extractor. [Что такое маски внимания?](../glossary#attention-mask) Для моделей Whisper параметр `attention_mask` следует всегда передавать при пакетном выводе, чтобы избежать тонких ошибок. padding (`str` или [PaddingStrategy](/docs/transformers/main/ru/internal/file_utils#transformers.utils.PaddingStrategy), *необязательный*, по умолчанию `'max_length'`) : Включает и управляет выравниванием. Принимает следующие значения: - `'longest'`: Выравнивание до самой длинной последовательности в батче (или без выравнивания, если предоставлена только одна последовательность). - `'max_length'` (по умолчанию): Выравнивание до максимальной длины, указанной в аргументе `max_length`, или до максимально допустимой входной длины для модели, если этот аргумент не указан. - `'do_not_pad'`: Без выравнивания (т. е. может выдать батч с последовательностями разной длины). max_length (`int`, *optional*) : Управляет максимальной длиной, используемой одним из параметров усечения/дополнения. Если значение не задано или равно `None`, будет использована предопределённая максимальная длина модели, если один из параметров усечения/дополнения требует указания максимальной длины. Если у модели нет конкретной максимальной длины входных данных (как у XLNet), усечение/дополнение до максимальной длины будет отключено. sampling_rate (`int`, *optional*) : Частота дискретизации, с которой вход `raw_speech` был оцифрован. Настоятельно рекомендуется передавать `sampling_rate` при вызове forward, чтобы избежать скрытых ошибок и обеспечить работу конвейера автоматического распознавания речи. do_normalize (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли нормализовать входные данные до нулевого среднего и единичной дисперсии. Нормализация может значительно повысить производительность модели. device (`str`, *необязательный*, по умолчанию `'cpu'`) : Указывает устройство для вычисления лог-мел-спектрограммы аудиосигналов в методе `_torch_extract_fbank_features`. (например, "cpu", "cuda") - ****kwargs** : Не поддерживается в WhisperFeatureExtractor.__call__() и игнорируется. Основной метод для извлечения признаков и подготовки одной или нескольких последовательностей для модели. Реализация использует PyTorch для вычисления STFT, если он доступен, в противном случае — более медленный вариант на основе NumPy. ## WhisperProcessor[[transformers.WhisperProcessor]] #### transformers.WhisperProcessor[[transformers.WhisperProcessor]] ```python transformers.WhisperProcessor(feature_extractor, tokenizer) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/processing_whisper.py#L23) **Параметры:** feature_extractor (`WhisperFeatureExtractor`) : Извлечение признаков является обязательным входом. tokenizer (`WhisperTokenizer`) : Токенизатор является обязательным входным параметром. Создаёт WhisperProcessor, который объединяет feature extractor и tokenizer в единый processor. [WhisperProcessor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperProcessor) предоставляет все возможности [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor) и [WhisperTokenizer](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperTokenizer). Подробнее см. в разделах [~WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor) и [~WhisperTokenizer](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperTokenizer). #### __call__[[transformers.WhisperProcessor.__call__]] ```python __call__(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/processing_whisper.py#L30) **Параметры:** return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения: - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy. #### from_pretrained[[transformers.WhisperProcessor.from_pretrained]] ```python from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1750) **Параметры:** pretrained_model_name_or_path (`str` или `os.PathLike`) : Может быть одним из следующих: - строка, *model id* предобученного feature_extractor, размещенного в репозитории моделей на huggingface.co. - путь к *каталогу*, содержащему файл feature extractor, сохраненный с помощью метода [save_pretrained()](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), например, `./my_model_directory/`. - путь к сохраненному JSON-*файлу* feature extractor, например, `./my_model_directory/preprocessor_config.json`. - ****kwargs** : Дополнительные именованные аргументы, передаваемые как в [from_pretrained()](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained), так и в `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`. Создайте экземпляр процессора, связанного с предобученной моделью. Этот метод класса просто вызывает метод [from_pretrained()](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) экстрактора признаков, метод [ImageProcessingMixin](/docs/transformers/main/ru/internal/image_processing_utils#transformers.ImageProcessingMixin) процессора изображений и метод `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained` токенизатора. Более подробную информацию см. в строках документации указанных методов. #### save_pretrained[[transformers.WhisperProcessor.save_pretrained]] ```python save_pretrained(save_directory, push_to_hub: bool = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1165) **Параметры:** save_directory (`str` или `os.PathLike`) : Каталог, в котором будут сохранены JSON-файл экстрактора признаков и файлы токенизатора (каталог будет создан, если он не существует). push_to_hub (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли после сохранения модели загрузить её в Hugging Face model hub. Репозиторий, в который нужно загрузить модель, можно указать с помощью `repo_id` (по умолчанию используется имя `save_directory` в вашем пространстве имён). kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод [push_to_hub()](/docs/transformers/main/ru/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). Сохраняет атрибуты этого процессора (извлекатель признаков, токенизатор и т. д.) в указанную директорию, чтобы его можно было загрузить снова с помощью метода [from_pretrained()](/docs/transformers/main/ru/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained). Этот метод класса просто вызывает [save_pretrained()](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) и [save_pretrained()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Подробности см. в строках документации указанных выше методов. #### batch_decode[[transformers.WhisperProcessor.batch_decode]] ```python batch_decode(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2005) Этот метод передаёт все свои аргументы в [batch_decode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) класса PreTrainedTokenizer. Подробности см. в docstring этого метода. #### decode[[transformers.WhisperProcessor.decode]] ```python decode(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2014) Этот метод передаёт все свои аргументы в [decode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) класса PreTrainedTokenizer. Подробности см. в docstring этого метода. ## WhisperModel[[transformers.WhisperModel]] #### transformers.WhisperModel[[transformers.WhisperModel]] ```python transformers.WhisperModel(config: WhisperConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L826) **Параметры:** config ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Whisper без дополнительных слоёв, выводящая необработанные скрытые состояния. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.WhisperModel.forward]] ```python forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: tuple[torch.Tensor] | None = None, decoder_position_ids: tuple[torch.LongTensor] | None = None, use_cache: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L891) **Параметры:** input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor). Подробности см. в [WhisperFeatureExtractor.__call__()](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) ([WhisperProcessor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperProcessor) использует [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor) для обработки аудио). attention_mask (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательно*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью [WhisperTokenizer](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы декодера?](../glossary#decoder-input-ids) Whisper использует `decoder_start_token_id` в качестве начального токена для генерации `decoder_input_ids`. Если используется `past_key_values`, необязательно вводить только последние `decoder_input_ids` (см. `past_key_values`). decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Поведение по умолчанию: генерирует тензор, игнорирующий токены заполнения в `decoder_input_ids`. По умолчанию также будет использоваться каузальная маска. Если вы хотите изменить поведение при заполнении, прочитайте `modeling_whisper._prepare_decoder_attention_mask` и измените его под свои нужды. Подробнее о стратегии по умолчанию см. на рисунке 1 в [статьи о BART](https://huggingface.co/papers/1910.13461). encoder_outputs (`tuple[tuple[torch.Tensor]]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. decoder_inputs_embeds (`tuple[torch.Tensor]` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход необходимо передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. decoder_position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое position IDs?](../glossary#position-ids) use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** [Seq2SeqModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) или `tuple(torch.Tensor)` Объект [Seq2SeqModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) и входных данных. Метод forward класса [WhisperModel](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя декодера модели. Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`. - **past_key_values** (`EncoderDecoderCache`, *необязательный*, возвращается при передаче `use_cache=True` или при `config.use_cache=True`) -- это экземпляр [EncoderDecoderCache](/docs/transformers/main/ru/internal/generation_utils#transformers.EncoderDecoderCache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также необязательные выходные значения начального эмбеддинга. - **decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния энкодера на выходе каждого слоя, а также необязательные выходные значения начального эмбеддинга. - **encoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Пример: ```python >>> import torch >>> from transformers import AutoFeatureExtractor, WhisperModel >>> from datasets import load_dataset >>> model = WhisperModel.from_pretrained("openai/whisper-base") >>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id >>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state >>> list(last_hidden_state.shape) [1, 2, 512] ``` #### _mask_input_features[[transformers.WhisperModel._mask_input_features]] ```python _mask_input_features(input_features: Tensor, attention_mask: typing.Optional[torch.LongTensor] = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L848) Маски скрывают признаки вдоль временной оси и/или вдоль оси признаков в соответствии с [SpecAugment](https://huggingface.co/papers/1904.08779). ## WhisperForConditionalGeneration[[transformers.WhisperForConditionalGeneration]] #### transformers.WhisperForConditionalGeneration[[transformers.WhisperForConditionalGeneration]] ```python transformers.WhisperForConditionalGeneration(config: WhisperConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L990) **Параметры:** config ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Whisper с головой языковой модели. Может использоваться для автоматического распознавания речи. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.WhisperForConditionalGeneration.forward]] ```python forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: tuple[torch.Tensor] | None = None, decoder_position_ids: tuple[torch.LongTensor] | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L1034) **Параметры:** input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor). Подробности см. в [WhisperFeatureExtractor.__call__()](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) ([WhisperProcessor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperProcessor) использует [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor) для обработки аудио). attention_mask (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательно*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью [WhisperTokenizer](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы декодера?](../glossary#decoder-input-ids) Whisper использует `decoder_start_token_id` в качестве начального токена для генерации `decoder_input_ids`. Если используется `past_key_values`, необязательно вводить только последние `decoder_input_ids` (см. `past_key_values`). decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Поведение по умолчанию: генерирует тензор, игнорирующий токены заполнения в `decoder_input_ids`. По умолчанию также будет использоваться каузальная маска. Если вы хотите изменить поведение при заполнении, прочитайте `modeling_whisper._prepare_decoder_attention_mask` и измените его под свои нужды. Подробнее о стратегии по умолчанию см. на рисунке 1 в [статьи о BART](https://huggingface.co/papers/1910.13461). encoder_outputs (`tuple[tuple[torch.Tensor]]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. decoder_inputs_embeds (`tuple[torch.Tensor]` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход необходимо передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. decoder_position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое position IDs?](../glossary#position-ids) labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь языковой модели. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. `sequence_length` должен быть меньше или равен `config.max_target_positions`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** [Seq2SeqLMOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) или `tuple(torch.Tensor)` Объект [Seq2SeqLMOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) и входных данных. Метод forward класса [WhisperForConditionalGeneration](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperForConditionalGeneration) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели. - **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax). - **past_key_values** (`EncoderDecoderCache`, *необязательный*, возвращается при передаче `use_cache=True` или при `config.use_cache=True`) -- это экземпляр [EncoderDecoderCache](/docs/transformers/main/ru/internal/generation_utils#transformers.EncoderDecoderCache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания. - **decoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания декодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний. - **encoder_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Пример: ```python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> generated_ids = model.generate(inputs=input_features) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> transcription ' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.' ``` #### generate[[transformers.WhisperForConditionalGeneration.generate]] ```python generate(input_features: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool = False, return_timestamps: bool | None = None, task: str | None = None, language: str | list[str] | None = None, is_multilingual: bool | None = None, prompt_ids: typing.Optional[torch.Tensor] = None, prompt_condition_type: str | None = None, condition_on_prev_tokens: bool | None = None, temperature: float | tuple[float, ...] | None = None, compression_ratio_threshold: float | None = None, logprob_threshold: float | None = None, no_speech_threshold: float | None = None, num_segment_frames: int | None = None, attention_mask: typing.Optional[torch.Tensor] = None, time_precision: float = 0.02, time_precision_features: float = 0.01, return_token_timestamps: bool | None = None, return_segments: bool = False, return_dict_in_generate: bool | None = None, force_unique_generate_call: bool | None = None, monitor_progress: collections.abc.Callable[[torch.Tensor], None] | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/generation_whisper.py#L383) **Параметры:** input_features (`torch.Tensor` формы `(batch_size, feature_size, sequence_length)`, *необязательно*) : Значения типа float для log-mel-признаков, извлечённых из исходной речевой волны. Исходную речевую волну можно получить, загрузив аудиофайл `.flac` или `.wav` в массив типа `list[float]`, `numpy.ndarray` или `torch.Tensor`, *например* с помощью библиотеки torchcodec (`pip install torchcodec`) или библиотеки soundfile (`pip install soundfile`). Для подготовки массива в `input_features` следует использовать [AutoFeatureExtractor](/docs/transformers/main/ru/model_doc/auto#transformers.AutoFeatureExtractor) для извлечения mel-признаков, дополнения (padding) и преобразования в тензор типа `torch.Tensor`. Подробности см. в [__call__()](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__). generation_config ([GenerationConfig](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationConfig), *optional*) : Конфигурация генерации, используемая в качестве базовой параметризации для вызова генерации. Аргументы `**kwargs`, переданные в generate и совпадающие с атрибутами `generation_config`, переопределяют их. Если `generation_config` не предоставлен, будет использован вариант по умолчанию, который имеет следующий приоритет загрузки: 1) из файла модели `generation_config.json`, если он существует; 2) из конфигурации модели. Обратите внимание, что не указанные параметры наследуют значения по умолчанию из [GenerationConfig](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationConfig), документация по которым должна быть проверена для параметризации генерации. logits_processor (`LogitsProcessorList`, *необязательный*) : Пользовательские обработчики логитов, дополняющие стандартные обработчики логитов, создаваемые на основе аргументов и конфигурации генерации. Если передан обработчик логитов, который уже был создан с использованием аргументов или конфигурации генерации, возникает ошибка. Эта функция предназначена для опытных пользователей. stopping_criteria (`StoppingCriteriaList`, *необязательный*) : Пользовательские критерии остановки, дополняющие критерии остановки по умолчанию, созданные на основе аргументов и конфигурации генерации. Если передан критерий остановки, который уже был создан с использованием аргументов или конфигурации генерации, возникает ошибка. Эта функция предназначена для опытных пользователей. prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *необязательный*) : Если указан, эта функция ограничивает поиск луча (beam search) только разрешёнными токенами на каждом шаге. Если не указан, ограничения не применяются. Эта функция принимает 2 аргумента: идентификатор батча `batch_id` и `input_ids`. Она должна возвращать список разрешённых токенов для следующего шага генерации, обусловленный идентификатором батча `batch_id` и ранее сгенерированными токенами `inputs_ids`. Этот аргумент полезен для ограниченной генерации, обусловленной префиксом, как описано в [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904). synced_gpus (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли продолжать выполнение цикла while до достижения max_length (необходимо для предотвращения блокировок при использовании `FullyShardedDataParallel` и DeepSpeed ZeRO Stage 3). return_timestamps (`bool`, *необязательный*) : Нужно ли возвращать временные метки вместе с текстом. Это активирует `WhisperTimestampsLogitsProcessor`. Для аудио длительностью более 30 секунд необходимо установить `return_timestamps=True`. task (`str`, *необязательный*) : Задача, используемая для генерации, — «translate» или «transcribe». language (`str` или список `str`, *необязательно*) : Токен языка для использования при генерации, может быть в форме `<|en|>`, `en` или `english`. Для пакетной генерации можно передать список токенов языка. Все возможные токены языков можно найти в словаре `model.generation_config.lang_to_id`. is_multilingual (`bool`, *необязательный*) : Указывает, является ли модель многоязычной. prompt_ids (`torch.Tensor`, *optional*) : Тензор ранга 1 с идентификаторами токенов, созданный путём передачи текста в `get_prompt_ids()`, который используется как промпт для каждого фрагмента. Это позволяет задавать контекст для транскрипции или «настраивать промпт», например, указывая пользовательский словарь или имена собственные, чтобы повысить вероятность их корректного распознавания. Невозможно использовать совместно с `decoder_start_token_id`, так как переопределяет это значение. prompt_condition_type (`str`, *optional*) : Актуально только для транскрипции длинных форм. Тип условия для `prompt_ids`. 'first-segment' означает, что только первый сегмент обусловлен `prompt_ids`. 'all-segments' означает, что каждый сегмент обусловлен `prompt_ids`. Убедитесь, что для 'all-segments' включено `condition_on_prev_tokens`. По умолчанию установлено значение 'first-segment'. Для транскрипции коротких форм возможно только 'first-segment'. condition_on_prev_tokens (`bool`, *optional*) : Актуально только для транскрипции длинных форм. Определяет, следует ли использовать предыдущий сегмент как условие для текущего. Как показано в [статьи Whisper](https://cdn.openai.com/papers/whisper.pdf), это может помочь улучшить качество работы. temperature (`float` или список `float`, *необязательно*) : Температура, используемая для генерации. Передача одного значения `float` и `do_sample=True` активирует генерацию с использованием выборки. Для транскрипции длинных текстов можно активировать резервную температуру, передав список значений float, например (0.0, 0.2, 0.4, 0.6, 0.8, 1.0). Как показано в [статьи Whisper](https://cdn.openai.com/papers/whisper.pdf), это может помочь улучшить производительность. compression_ratio_threshold (`float`, *optional*) : Актуально только для транскрипции длинных форм. Если значение определено, для каждого сегмента будет вычислена степень сжатия zlib. Если степень сжатия сегмента превышает `compression_ratio_threshold`, активируется откат температуры: сгенерированный сегмент отбрасывается, а генерация повторяется с более высокой температурой. Смысл этой функции в том, что сегменты с очень высокой степенью сжатия страдают от большого количества повторов. Нежелательные повторы можно уменьшить, внося больше случайности путём повышения температуры. Если `compression_ratio_threshold` определено, убедитесь, что `temperature` является списком значений. Типичное значение для `compression_ratio_threshold` — 1.35. Как показано в [статьи Whisper](https://cdn.openai.com/papers/whisper.pdf), это может помочь улучшить производительность. logprob_threshold (`float`, *optional*) : Актуально только для транскрипции длинных форм. Если значение определено, будет вычислена средняя логарифмическая вероятность каждого сегмента. Если логарифмическая вероятность данного сегмента ниже `logprob_threshold`, активируется механизм отката температуры: сгенерированный сегмент отбрасывается, а генерация повторяется с более высокой температурой. Смысл этой функции в том, что сегменты с низкой логарифмической вероятностью можно улучшить, внося больше случайности путём повышения температуры. Если `logprob_threshold` определено, убедитесь, что `temperature` является списком значений. Типичное значение для `logprob_threshold` — -1.0. Как показано в [статьи Whisper](https://cdn.openai.com/papers/whisper.pdf), это может помочь повысить качество работы. no_speech_threshold (`float`, *optional*) : Актуально только для транскрипции длинных форм. Если определено, то токен "no-speech" в сочетании с `logprob_threshold` используется для определения, содержит ли сегмент только тишину. В этом случае транскрипция данного сегмента пропускается. Как показано в [статьи Whisper](https://cdn.openai.com/papers/whisper.pdf), это может помочь улучшить производительность. num_segment_frames (`int`, *optional*) : Количество кадров, из которых состоит один сегмент. Если не задано, `num_segment_frames` по умолчанию равно шагу модели, умноженному на максимальную длину входных данных. attention_mask (`torch.Tensor`, *необязательный*) : `attention_mask` необходимо передавать при выполнении транскрипции длинных форм с размером батча > 1. time_precision (`int`, *необязательный*, по умолчанию 0.02) : Длительность вывода токена в секундах. *Например*, 0.02 означает, что сгенерированный токен в среднем занимает 20 мс. time_precision_features (`int`, *optional*, по умолчанию 0.01) : Длительность, которую представляет кадр признака, в секундах. return_token_timestamps (`bool`, *необязательный*) : Нужно ли возвращать временные метки на уровне токенов вместе с текстом. Это можно использовать как с опцией `return_timestamps`, так и без неё. Чтобы получить временные метки на уровне слов, используйте токенизатор для группировки токенов в слова. return_segments (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли дополнительно возвращать список всех сегментов. Обратите внимание, что этот параметр можно включить только при транскрипции длинных форм. return_dict_in_generate (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо просто сгенерированных токенов. Обратите внимание, что при транскрипции длинных текстов `return_dict_in_generate` можно включить только в том случае, если `return_segments` установлен в True. В этом случае выходные данные генерации каждого сегмента добавляются к соответствующему сегменту. force_unique_generate_call (`bool`, *необязательный*) : Указывает, следует ли принудительно выполнять единственный вызов метода [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) базового класса GenerationMixin. Это полезно для assisted decoding и тестирования, чтобы гарантировать, что вызов [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) выполняется только один раз, и, следовательно, возвращаются идентификаторы входных токенов декодера и идентификаторы токенов eos. monitor_progress (`Callable[[torch.Tensor], None]`, *необязательный*) : Если указан, этот вызываемый объект может использоваться для отчёта о ходе транскрибации аудио. Функция принимает аргумент-тензор `p` формы `(n, 2)`, где `n` — размер батча. `p[i, 0]` содержит индекс аудиокадра, который в данный момент транскрибируется для элемента батча `i`. `p[i, 1]` содержит общее количество кадров для элемента батча `i`. Возвращаемое значение не ожидается. kwargs (`dict[str, Any]`, *необязательный*) : Произвольная параметризация `generate_config` и/или дополнительные специфичные для модели kwargs, которые будут переданы в функцию `forward` модели. Если модель является моделью с кодировщиком-декодировщиком, kwargs, специфичные для кодировщика, не должны иметь префикса, а kwargs, специфичные для декодера, должны иметь префикс *decoder_*. **Возвращает:** [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) или `dict[str, Any]` или `torch.LongTensor` Одно из следующих: - [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput), если `return_dict_in_generate=True` и (`return_timestamps=False` или `force_unique_generate_call=True`), включая входные идентификаторы декодера и идентификатор конца последовательности. - `dict[str, Any]`, если (`return_dict_in_generate=True` и `return_timestamps=True`) или `return_segments=True` или `return_token_timestamps=True`. - `torch.LongTensor` во всех остальных случаях, за исключением идентификаторов входных данных декодера и идентификатора конца последовательности. Возможные типы [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput): - [GenerateEncoderDecoderOutput](/docs/transformers/main/ru/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput) - [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/ru/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput) `segments` — это список списков (по одному списку на элемент батча) объектов `segment`. Объект `segment` представляет собой словарь с ключами `start`, `end`, `tokens`, `idxs` и `result`. - `start`: начальное время сегмента. - `end`: конечная метка времени сегмента. - `tokens`: токены сегмента, за исключением идентификаторов входных данных декодера и идентификатора конца последовательности. - `idxs`: начальный (включительно) и конечный (не включительно) индексы `tokens` сегмента в исходном вызове [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) GenerationMixin (присутствуют в `result`). - `result`: результат базового вызова [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) в GenerationMixin. Если `return_timestamps=True`, то `return_dict_in_generate=True` применяется к каждому вызову метода [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) базового класса GenerationMixin, при этом результаты сохраняются в `result` каждого `segment`. Транскрибирует или переводит входные лог-мел-фичи в последовательность токен-идентификаторов, генерируемых авто-регрессивно. Большинство параметров, управляющих генерацией, задаются в `generation_config`, который, если не передан явно, принимает значение конфигурации генерации по умолчанию для модели. Вы можете переопределить любые параметры `generation_config`, передав соответствующие аргументы в generate(), например, `.generate(inputs, num_beams=4, do_sample=True)`. Для обзора стратегий генерации и примеров кода см. [следующее руководство](../generation_strategies). Пример: - *Транскрибация длинных записей*: чтобы транскрибировать или переводить аудио длительностью более 30 секунд, обрабатывайте аудиофайлы без усечения и передавайте все mel-фичи сразу в generate. Необходимо установить `return_timestamps=True`. Действительно, транскрипция длинных записей использует последовательный алгоритм, основанный на предсказании временных меток, с эвристиками, такими как порог коэффициента сжатия, порог логарифмической вероятности и резервное значение температуры. Этот алгоритм описан в [оригинальной статье Whisper](https://cdn.openai.com/papers/whisper.pdf), раздел *3.8. Long-form Transcription*. ```python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset, Audio >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> model.cuda() >>> # load audios > 30 seconds >>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"] >>> # resample to 16kHz >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> # take first 8 audios and retrieve array >>> audio = ds[:8]["audio"] >>> audio = [x["array"] for x in audio] >>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio >>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000) >>> inputs = inputs.to("cuda", torch.float32) >>> # transcribe audio to ids >>> generated_ids = model.generate(**inputs, return_timestamps=True) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True) >>> transcription[0] " Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile." ``` Колбэк `monitor_progress` можно использовать для отслеживания хода транскрибации: ```python >>> from tqdm import tqdm >>> # prepare inputs like above >>> # define a callback to monitor the progress of the transcription. >>> with tqdm(desc="Progress") as pbar: >>> def monitor_progress(p_batch): >>> i = torch.argmax(p_batch[:, 1]) >>> p = p_batch[i].detach().cpu() >>> pbar.total = int(p[1]) >>> pbar.n = int(p[0]) >>> pbar.update() >>> # transcribe audio to ids >>> generated_ids = model.generate(**inputs, return_timestamps=True, monitor_progress=monitor_progress) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True) >>> transcription[0] Progress: 95%|█████████████████████████████████████████████████████████████████████████████████████████████████▎ | 8497/8901 [00:04<00:00, 2052.79it/s] " Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile." ``` - *Короткая транскрипция*: если переданные входные mel-признаки имеют длительность <= 30 секунд, возможны два варианта: - `return_timestamps=False`: весь аудиофайл будет распознан за один вызов [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) из GenerationMixin. - `return_timestamps=True`: аудио будет транскрибировано с использованием той же логики, что и при транскрипции длинных форматов. ```python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> generated_ids = model.generate(inputs=input_features) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> transcription ' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.' ``` ## WhisperForCausalLM[[transformers.WhisperForCausalLM]] #### transformers.WhisperForCausalLM[[transformers.WhisperForCausalLM]] ```python transformers.WhisperForCausalLM(config: WhisperConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L1171) **Параметры:** config ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Декодер Whisper с головой моделирования языка сверху (линейный слой с весами, связанными с входными эмбеддингами). Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.WhisperForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L1197) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) encoder_outputs (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) или `tuple(torch.Tensor)` Объект [CausalLMOutputWithCrossAttentions](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) и входных данных. Метод forward класса [WhisperForCausalLM](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperForCausalLM) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели (для предсказания следующего токена). - **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса кросс-внимания после softmax-функции внимания, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. Пример: ```python >>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor >>> import torch >>> from datasets import load_dataset >>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2") >>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> sample = ds[0]["audio"] >>> input_features = processor( ... sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt" ... ).input_features >>> predicted_ids = model.generate(input_features, assistant_model=assistant_model) >>> # decode token ids to text >>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0] >>> transcription ' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.' ``` ## WhisperForAudioClassification[[transformers.WhisperForAudioClassification]] #### transformers.WhisperForAudioClassification[[transformers.WhisperForAudioClassification]] ```python transformers.WhisperForAudioClassification(config: WhisperConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L1279) **Параметры:** config ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Whisper Encoder с головой для классификации последовательностей (линейный слой поверх агрегированного вывода) для задач, таких как SUPERB Keyword Spotting. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.WhisperForAudioClassification.forward]] ```python forward(input_features: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/whisper/modeling_whisper.py#L1306) **Параметры:** input_features (`torch.LongTensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor). Подробности см. в [WhisperFeatureExtractor.__call__()](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor.__call__) ([WhisperProcessor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperProcessor) использует [WhisperFeatureExtractor](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperFeatureExtractor) для обработки аудио). encoder_outputs (`tuple[tuple[torch.Tensor]]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия). **Возвращает:** [SequenceClassifierOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или `tuple(torch.Tensor)` Объект [SequenceClassifierOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([WhisperConfig](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperConfig)) и входных данных. Метод forward класса [WhisperForAudioClassification](/docs/transformers/main/ru/model_doc/whisper#transformers.WhisperForAudioClassification) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1). - **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Пример: ```python >>> import torch >>> from transformers import AutoFeatureExtractor, WhisperForAudioClassification >>> from datasets import load_dataset >>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id") >>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id") >>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True) >>> sample = next(iter(ds)) >>> inputs = feature_extractor( ... sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt" ... ) >>> input_features = inputs.input_features >>> with torch.no_grad(): ... logits = model(input_features).logits >>> predicted_class_ids = torch.argmax(logits).item() >>> predicted_label = model.config.id2label[predicted_class_ids] >>> predicted_label 'Afrikaans' ```