Transformers documentation
HuBERT
Este modelo foi publicado no HF papers em 2021-06-14 e contribuído para o Hugging Face Transformers em 2021-06-16.
HuBERT
HuBERT é um modelo de fala auto-supervisionado que agrupa rótulos-alvo alinhados para uma perda de predição semelhante à do BERT e aplica a perda de predição apenas sobre as regiões mascaradas, forçando o modelo a aprender tanto modelagem acústica quanto modelagem de linguagem sobre entradas contínuas. Ele aborda os desafios de múltiplas unidades sonoras por fala, ausência de léxico durante o pré-treinamento e unidades sonoras de comprimento variável sem segmentação explícita.
Você pode encontrar todos os checkpoints originais do HuBERT na coleção HuBERT.
Este modelo foi contribuído por patrickvonplaten.
Clique nos modelos HuBERT na barra lateral à direita para ver mais exemplos de como aplicar o HuBERT a diferentes tarefas de áudio.
O exemplo abaixo demonstra como transcrever automaticamente fala em texto com Pipeline ou a classe AutoModel.
from transformers import pipeline
pipeline = pipeline(
task="automatic-speech-recognition",
model="facebook/hubert-large-ls960-ft",
device=0
)
pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")import torch
from datasets import load_dataset
from transformers import AutoModelForCTC, AutoProcessor
dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation").sort("id")
sampling_rate = dataset.features["audio"].sampling_rate
processor = AutoProcessor.from_pretrained("facebook/hubert-base-ls960")
model = AutoModelForCTC.from_pretrained("facebook/hubert-base-ls960", device_map="auto", attn_implementation="sdpa")
inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt").to(model.device)
with torch.no_grad():
logits = model(**inputs).logits
predicted_ids = torch.argmax(logits, dim=-1)
transcription = processor.batch_decode(predicted_ids)
print(transcription[0])Quantização
A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de Quantização para mais backends de quantização disponíveis.
O exemplo abaixo usa bitsandbytes para quantizar os pesos em 4 bits.
import torch
from datasets import load_dataset
from transformers import AutoModelForCTC, AutoProcessor, BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
load_in_8bit=True,
llm_int8_threshold=6.0
)
dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation").sort("id")
sampling_rate = dataset.features["audio"].sampling_rate
processor = AutoProcessor.from_pretrained("facebook/hubert-base-ls960")
model = AutoModelForCTC.from_pretrained("facebook/hubert-base-ls960", quantization_config=bnb_config, device_map="auto", attn_implementation="sdpa")
inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt").to(model.device)
with torch.no_grad():
logits = model(**inputs).logits
predicted_ids = torch.argmax(logits, dim=-1)
transcription = processor.batch_decode(predicted_ids)
print(transcription[0])Observações
- Os modelos HuBERT esperam uma entrada de áudio bruto como um array float unidimensional amostrado a 16 kHz.
HubertConfig
classe transformers.HubertConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 32hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1feat_proj_layer_norm: bool = Truefeat_proj_dropout: float | int = 0.0final_dropout: float | int = 0.1layerdrop: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05feat_extract_norm: str = 'group'feat_extract_activation: str = 'gelu'conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512)conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2)conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2)conv_bias: bool = Falsenum_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16conv_pos_batch_norm: bool = Falsedo_stable_layer_norm: bool = Falseapply_spec_augment: bool = Truemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0ctc_loss_reduction: str = 'sum'ctc_zero_infinity: bool = Falseuse_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 256pad_token_id: int | None = 0bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2 )
Parâmetros
- vocab_size (
int, opcional, padrão32) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão768) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão12) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - intermediate_size (
int, opcional, padrão3072) — Dimensão das representações do MLP. - hidden_act (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - hidden_dropout (
Union[float, int], opcional, padrão0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler. - activation_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - attention_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - feat_proj_layer_norm (
bool, opcional, padrãoTrue) — Indica se o LayerNorm deve ser aplicado à saída do codificador de recursos. - feat_proj_dropout (
float, opcional, padrão 0.0) — A probabilidade de dropout para a saída do codificador de recursos. - final_dropout (
float, opcional, padrão 0.1) — A probabilidade de dropout para a camada de projeção final de Wav2Vec2ForCTC. - layerdrop (
Union[float, int], opcional, padrão0.1) — A probabilidade do LayerDrop. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização de camada. - feat_extract_norm (
str, opcional, padrão"group") — A normalização a ser aplicada às camadas convolucionais 1D no codificador de recursos. Pode ser"group"para normalização por grupo apenas da primeira camada convolucional 1D ou"layer"para normalização por camada de todas as camadas convolucionais 1D. - feat_extract_activation (
str,optional, defaults to“gelu”) -- The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string,“gelu”,“relu”,“selu”and“gelu_new”` are supported. - conv_dim (
tuple[int], opcional, padrão(512, 512, 512, 512, 512, 512, 512)) — Uma tupla de inteiros que define o número de canais de entrada e saída de cada camada de convolução 1D no codificador de recursos. O comprimento de conv_dim define o número de camadas de convolução 1D. - conv_stride (
tuple[int], opcional, padrão(5, 2, 2, 2, 2, 2, 2)) — Uma tupla de inteiros que define o stride de cada camada convolucional 1D no codificador de recursos. O comprimento de conv_stride define o número de camadas convolucionais e deve corresponder ao comprimento de conv_dim. - conv_kernel (
tuple[int], opcional, padrão(10, 3, 3, 3, 3, 3, 3)) — Uma tupla de inteiros que define o tamanho do kernel de cada camada convolucional 1D no codificador de recursos. O tamanho de conv_kernel define o número de camadas convolucionais e deve corresponder ao tamanho de conv_dim. - conv_bias (
bool, opcional, padrãoFalse) — Indica se as camadas de convolução 1D possuem viés. - num_conv_pos_embeddings (
int, opcional, padrão 128) — Número de embeddings posicionais convolucionais. Define o tamanho do kernel da camada de embeddings posicionais convolucionais 1D. - num_conv_pos_embedding_groups (
int, opcional, padrão 16) — Número de grupos da camada de embeddings posicionais convolucionais 1D. - conv_pos_batch_norm (
bool, opcional, padrãoFalse) — Se deve usar batch norm em vez de weight norm em conv_pos - do_stable_layer_norm (
bool, opcional, padrãoFalse) — Indica se deve aplicar a arquitetura de layer norm estável do codificador Transformer.do_stable_layer_norm is Truecorresponde à aplicação do layer norm antes da camada de atenção, enquantodo_stable_layer_norm is Falsecorresponde à aplicação do layer norm depois da camada de atenção. - apply_spec_augment (
bool, opcional, padrãoTrue) — Indica se a ampliação de dados SpecAugment deve ser aplicada às saídas do codificador de recursos. Para referência, consulte SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition. - mask_time_prob (
float, optional, defaults to 0.05) — Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates ”mask_time_problen(time_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_time_prob should be `prob_vector_startmask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant ifapply_spec_augment is True`. - mask_time_length (
int, opcional, padrão 10) — Comprimento da extensão do vetor ao longo do eixo do tempo. - mask_time_min_masks (
int, opcional, padrão 2), — O número mínimo de máscaras de comprimentomask_feature_lengthgeradas ao longo do eixo do tempo, em cada passo de tempo, independentemente demask_feature_prob. Relevante apenas se ”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” - mask_feature_prob (
float, optional, defaults to 0.0) — Percentage (between 0 and 1) of all feature vectors along the feature axis which will be masked. The masking procedure generates ”mask_feature_problen(feature_axis)/mask_time_length” independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, mask_feature_prob should be `prob_vector_startmask_feature_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant ifapply_spec_augment is True`. - mask_feature_prob (
Union[float, int], opcional, padrão0.0) — Porcentagem (entre 0 e 1) de todos os vetores de recursos ao longo do eixo de recursos que serão mascarados. O procedimento de mascaramento geramask_feature_prob*len(feature_axis)/mask_time_lengthmáscaras independentes sobre o eixo. Se o raciocínio for feito a partir da probabilidade de cada vetor de recurso ser escolhido como o início do espano de vetores a ser mascarado, mask_feature_prob deve serprob_vector_start*mask_feature_length. Observe que a sobreposição pode diminuir a porcentagem real de vetores mascarados. Isso é relevante apenas seapply_spec_augmentforTrue. - mask_feature_length (
int, opcional, padrão 10) — Comprimento da extensão do vetor ao longo do eixo de recursos. - mask_feature_min_masks (
int, opcional, padrão 0), — O número mínimo de máscaras de comprimentomask_feature_lengthgeradas ao longo do eixo de recursos, a cada passo de tempo, independentemente demask_feature_prob. Relevante apenas se ”mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks” - ctc_loss_reduction (
str, opcional, padrão"sum") — Especifica a redução a ser aplicada à saída detorch.nn.CTCLoss. Relevante apenas ao treinar uma instância de HubertForCTC. - ctc_loss_reduction (
str, opcional, padrãosum) — Especifica a redução a ser aplicada à saída detorch.nn.CTCLoss. Relevante apenas durante o treinamento. - ctc_zero_infinity (
bool, opcional, padrãoFalse) — Se deve zerar perdas infinitas e os gradientes associados detorch.nn.CTCLoss. Perdas infinitas ocorrem principalmente quando as entradas são curtas demais para serem alinhadas aos alvos. Relevante apenas ao treinar uma instância de HubertForCTC. - use_weighted_layer_sum (
bool, opcional, padrãoFalse) — Se deve usar uma média ponderada das saídas das camadas com pesos aprendidos. Relevante apenas ao usar uma instância de HubertForSequenceClassification. - classifier_proj_size (
int, opcional, padrão 256) — Dimensão da projeção antes do token mean-pooling para classificação. - pad_token_id (
int, opcional, padrão0) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão1) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário.
Esta é a classe de configuração para armazenar a configuração de um HubertModel. Ela é usada para instanciar um modelo Hubert de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do facebook/hubert-base-ls960
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> from transformers import HubertModel, HubertConfig
>>> # Initializing a Hubert facebook/hubert-base-ls960 style configuration
>>> configuration = HubertConfig()
>>> # Initializing a model from the facebook/hubert-base-ls960 style configuration
>>> model = HubertModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configHubertModel
classe transformers.HubertModel
< source >( config: HubertConfig )
Parâmetros
- config (HubertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo Hubert básico que gera estados ocultos brutos, sem nenhum cabeçalho específico no topo.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutput or tuple(torch.Tensor)
Parâmetros
- input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- mask_time_indices (
torch.BoolTensorde forma(batch_size, sequence_length), opcional) — Índices para mascarar os recursos extraídos para a perda contrastiva. Quando em modo de treinamento, o modelo aprende a prever os recursos extraídos mascarados no espaço config.proj_codevector_dim. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
BaseModelOutput ou tuple(torch.Tensor)
Um BaseModelOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (HubertConfig) e das entradas.
O método forward do HubertModel substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoProcessor, HubertModel
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertModel.from_pretrained("facebook/hubert-large-ls960-ft")
>>> def map_to_array(example):
... example["speech"] = example["audio"]["array"]
... return example
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="pt").input_values # Batch size 1
>>> hidden_states = model(input_values).last_hidden_stateHubertForCTC
classe transformers.HubertForCTC
< source >( config: HubertConfigtarget_lang: str | None = None )
Parâmetros
- config (HubertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
- target_lang (
str, opcional) — Idioma dos pesos do adaptador. Os pesos do adaptador são armazenados no formato adapter..safetensors ou adapter. .bin. Relevante apenas ao usar uma instância de HubertForCTC com adaptadores. Usa ‘eng’ por padrão.
Modelo Hubert com uma cabeça de language modeling no topo para Connectionist Temporal Classification (CTC).
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.Tensor)
Parâmetros
- input_values (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. Consulte Wav2Vec2Processor.call() para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- labels (
torch.LongTensorde forma(batch_size, target_length), opcional) — Rótulos para classificação temporal conexionista. Observe quetarget_lengthdeve ser menor ou igual ao comprimento da sequência dos logits de saída. Os índices são selecionados em[-100, 0, ..., config.vocab_size - 1]. Todos os rótulos definidos como-100são ignorados (mascarados); a perda é calculada apenas para rótulos em[0, ..., config.vocab_size - 1].
Retorna
CausalLMOutput ou tuple(torch.Tensor)
Um CausalLMOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (HubertConfig) e das entradas.
O método forward de HubertForCTC sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> from transformers import AutoProcessor, HubertForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForCTC.from_pretrained("facebook/hubert-base-ls960")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...HubertForSequenceClassification
classe transformers.HubertForSequenceClassification
< source >( config: HubertConfig )
Parâmetros
- config (HubertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
Modelo Hubert com uma cabeça de classificação de sequência no topo (uma camada linear sobre a saída agregada) para tarefas como SUPERB Keyword Spotting.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_values: typing.Optional[torch.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)
Parâmetros
- input_values (
torch.Tensorde forma(batch_size, sequence_length)) — Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio.flacou.wavem um array do tipolist[float], umnumpy.ndarrayou umtorch.Tensor, por exemplo, por meio da biblioteca torchcodec (pip install torchcodec) ou da biblioteca soundfile (pip install soundfile). Para preparar o array parainput_values, o AutoProcessor deve ser usado para padding e conversão em um tensor do tipotorch.Tensor. ConsulteHubertProcessor.__call__para mais detalhes. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
Retorna
SequenceClassifierOutput ou tuple(torch.Tensor)
Um SequenceClassifierOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (HubertConfig) e das entradas.
O método forward de HubertForSequenceClassification substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação (ou regressão se config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo de classificação de rótulo único:
>>> import torch
>>> from transformers import AutoTokenizer, HubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Exemplo de classificação multirótulo:
>>> import torch
>>> from transformers import AutoTokenizer, HubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = HubertForSequenceClassification.from_pretrained(
... "facebook/hubert-base-ls960", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss