# Salidas del modelo

Todos los modelos tienen salidas que son instancias de subclases de [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput). Estas son estructuras de datos que contienen toda la información devuelta por el modelo, pero que también pueden usarse como tuplas o diccionarios.

Veamos cómo se ve en un ejemplo:

```python
from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)  # Batch size 1
outputs = model(**inputs, labels=labels)
```

El objeto `outputs` es un [SequenceClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput); como se puede ver en la documentación de esa clase a continuación, significa que tiene un `loss` opcional, un `logits`, un `hidden_states` opcional y un atributo `attentions` opcional. Aquí tenemos el `loss` porque pasamos `labels`, pero no tenemos `hidden_states` ni `attentions` porque no pasamos `output_hidden_states=True` ni `output_attentions=True`.

> [!TIP]
> Con `output_hidden_states=True`, `outputs.hidden_states[-1]` no siempre es el mismo tensor que `outputs.last_hidden_state`. Muchos codificadores de visión y audio, como ViT, DINOv2, CLIP y Wav2Vec2, devuelven la salida de la última capa *antes* del layernorm final en `hidden_states[-1]`, y la salida normalizada en `last_hidden_state`. Utilice `last_hidden_state` para las características finales del modelo. Para que `hidden_states[-1]` coincida con `last_hidden_state`, establezca `tie_last_hidden_states=True` en la configuración del modelo.

Puedes acceder a cada atributo de la forma habitual, y si ese atributo no ha sido devuelto por el modelo, obtendrás `None`. Por ejemplo, `outputs.loss` es la pérdida calculada por el modelo, y `outputs.attentions` es `None`.

Al considerar nuestro objeto `outputs` como una tupla, solo tiene en cuenta los atributos que no tienen valores `None`. En este caso, por ejemplo, tiene dos elementos, `loss` y luego `logits`, por lo que

```python
outputs[:2]
```

devolverá, por ejemplo, la tupla `(outputs.loss, outputs.logits)`.

Al considerar nuestro objeto `outputs` como un diccionario, solo tiene en cuenta los atributos que no tienen valores `None`. En este caso, por ejemplo, tiene dos claves: `loss` y `logits`.

Aquí documentamos las salidas genéricas de modelo que se utilizan en más de un tipo de modelo. Los tipos de salida específicos se documentan en la página correspondiente de cada modelo.

## ModelOutput[[transformers.utils.ModelOutput]]

#### transformers.utils.ModelOutput[[transformers.utils.ModelOutput]]

```python
transformers.utils.ModelOutput(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L419)

Clase base para todas las salidas de modelos como dataclass. Tiene un `__getitem__` que permite indexar por entero o por rebanada (como una tupla) o por cadenas (como un diccionario), ignorando los atributos `None`. De lo contrario, se comporta como un diccionario de Python regular.

No se puede desempaquetar un `ModelOutput` directamente. Usa el método [to_tuple()](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput.to_tuple) para convertirlo en una tupla antes.

#### to_tuple[[transformers.utils.ModelOutput.to_tuple]]

```python
to_tuple()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L552)

Convierte self en una tupla que contiene todos los atributos/llaves que no son `None`.

## BaseModelOutput[[transformers.modeling_outputs.BaseModelOutput]]

#### transformers.modeling_outputs.BaseModelOutput[[transformers.modeling_outputs.BaseModelOutput]]

```python
transformers.modeling_outputs.BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L24)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de un modelo, con estados ocultos y atenciones potenciales.

## BaseModelOutputWithPooling[[transformers.modeling_outputs.BaseModelOutputWithPooling]]

#### transformers.modeling_outputs.BaseModelOutputWithPooling[[transformers.modeling_outputs.BaseModelOutputWithPooling]]

```python
transformers.modeling_outputs.BaseModelOutputWithPooling(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L69)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo.

pooler_output (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas del modelo que también contiene un agrupamiento de los últimos estados ocultos.

## BaseModelOutputWithCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L159)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_attentions=True` y `config.add_cross_attention=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

Clase base para las salidas de un modelo, con estados ocultos y atenciones potenciales.

## BaseModelOutputWithPoolingAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L192)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo.

pooler_output (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_attentions=True` y `config.add_cross_attention=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

Clase base para las salidas del modelo que también contiene un agrupamiento de los últimos estados ocultos.

## BaseModelOutputWithPast[[transformers.modeling_outputs.BaseModelOutputWithPast]]

#### transformers.modeling_outputs.BaseModelOutputWithPast[[transformers.modeling_outputs.BaseModelOutputWithPast]]

```python
transformers.modeling_outputs.BaseModelOutputWithPast(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L123)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo. Si se utiliza `past_key_values`, solo se devuelve el último estado oculto de las secuencias, de forma `(batch_size, 1, hidden_size)`.

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de un modelo que también pueden contener claves/valores pasados (para acelerar la decodificación secuencial).

## BaseModelOutputWithPastAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions]]

#### transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions[[transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions]]

```python
transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L238)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo. Si se utiliza `past_key_values`, solo se devuelve el último estado oculto de las secuencias, de forma `(batch_size, 1, hidden_size)`.

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_attentions=True` y `config.add_cross_attention=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

Clase base para las salidas de un modelo que también pueden contener claves/valores pasados (para acelerar la decodificación secuencial).

## Seq2SeqModelOutput[[transformers.modeling_outputs.Seq2SeqModelOutput]]

#### transformers.modeling_outputs.Seq2SeqModelOutput[[transformers.modeling_outputs.Seq2SeqModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L454)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de hidden-states en la salida de la última capa del decodificador del modelo. Si se usa `past_key_values`, solo se devuelve el último hidden-state de las secuencias, de forma `(batch_size, 1, hidden_size)`.

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de embedding iniciales opcionales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de embedding iniciales opcionales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas del codificador de un modelo que también contiene: estados ocultos precalculados que pueden acelerar la decodificación secuencial.

## CausalLMOutput[[transformers.modeling_outputs.CausalLMOutput]]

#### transformers.modeling_outputs.CausalLMOutput[[transformers.modeling_outputs.CausalLMOutput]]

```python
transformers.modeling_outputs.CausalLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L583)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de modelado de lenguaje (para la predicción del siguiente token).

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes del SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de un modelo de lenguaje causal (o autorregresivo).

## CausalLMOutputWithCrossAttentions[[transformers.modeling_outputs.CausalLMOutputWithCrossAttentions]]

#### transformers.modeling_outputs.CausalLMOutputWithCrossAttentions[[transformers.modeling_outputs.CausalLMOutputWithCrossAttentions]]

```python
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L647)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de modelado de lenguaje (para la predicción del siguiente token).

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes del SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de las atenciones cruzadas después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de atención) que se pueden utilizar (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

Clase base para las salidas de un modelo de lenguaje causal (o autorregresivo).

## CausalLMOutputWithPast[[transformers.modeling_outputs.CausalLMOutputWithPast]]

#### transformers.modeling_outputs.CausalLMOutputWithPast[[transformers.modeling_outputs.CausalLMOutputWithPast]]

```python
transformers.modeling_outputs.CausalLMOutputWithPast(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L612)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de modelado de lenguaje (para la predicción del siguiente token).

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes del SoftMax).

past_key_values (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden utilizar (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de un modelo de lenguaje causal (o autorregresivo).

## MaskedLMOutput[[transformers.modeling_outputs.MaskedLMOutput]]

#### transformers.modeling_outputs.MaskedLMOutput[[transformers.modeling_outputs.MaskedLMOutput]]

```python
transformers.modeling_outputs.MaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L724)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de modelado de lenguaje enmascarado (MLM).

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes del SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de modelos de lenguaje enmascarados.

## Seq2SeqLMOutput[[transformers.modeling_outputs.Seq2SeqLMOutput]]

#### transformers.modeling_outputs.Seq2SeqLMOutput[[transformers.modeling_outputs.Seq2SeqLMOutput]]

```python
transformers.modeling_outputs.Seq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L753)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de modelado de lenguaje.

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes del SoftMax).

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de los embeddings iniciales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de modelos de lenguaje de secuencia a secuencia.

## NextSentencePredictorOutput[[transformers.modeling_outputs.NextSentencePredictorOutput]]

#### transformers.modeling_outputs.NextSentencePredictorOutput[[transformers.modeling_outputs.NextSentencePredictorOutput]]

```python
transformers.modeling_outputs.NextSentencePredictorOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L884)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `next_sentence_label`) : Pérdida de predicción de la siguiente secuencia (clasificación).

logits (`torch.Tensor` de forma `(batch_size, 2)`) : Puntuaciones de predicción de la cabeza de predicción de la siguiente secuencia (clasificación) (puntuaciones de continuación True/False antes del SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de modelos que predicen si dos oraciones son consecutivas o no.

## SequenceClassifierOutput[[transformers.modeling_outputs.SequenceClassifierOutput]]

#### transformers.modeling_outputs.SequenceClassifierOutput[[transformers.modeling_outputs.SequenceClassifierOutput]]

```python
transformers.modeling_outputs.SequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L914)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación (o de regresión si config.num_labels==1).

logits (`torch.Tensor` de forma `(batch_size, config.num_labels)`) : Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de clasificación de oraciones.

## Seq2SeqSequenceClassifierOutput[[transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput]]

#### transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput[[transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput]]

```python
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L943)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `label`) : Pérdida de clasificación (o de regresión si config.num_labels==1).

logits (`torch.Tensor` de forma `(batch_size, config.num_labels)`) : Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de los embeddings iniciales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de modelos de clasificación de oraciones de secuencia a secuencia.

## MultipleChoiceModelOutput[[transformers.modeling_outputs.MultipleChoiceModelOutput]]

#### transformers.modeling_outputs.MultipleChoiceModelOutput[[transformers.modeling_outputs.MultipleChoiceModelOutput]]

```python
transformers.modeling_outputs.MultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1001)

**Parámetros:**

loss (`torch.Tensor` de forma *(1,)*, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación.

logits (`torch.Tensor` de forma `(batch_size, num_choices)`) : *num_choices* es la segunda dimensión de los tensores de entrada. (ver *input_ids* arriba). Puntuaciones de clasificación (antes de SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de modelos de selección múltiple.

## TokenClassifierOutput[[transformers.modeling_outputs.TokenClassifierOutput]]

#### transformers.modeling_outputs.TokenClassifierOutput[[transformers.modeling_outputs.TokenClassifierOutput]]

```python
transformers.modeling_outputs.TokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1032)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación.

logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) : Puntuaciones de clasificación (antes de SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de clasificación de tokens.

## QuestionAnsweringModelOutput[[transformers.modeling_outputs.QuestionAnsweringModelOutput]]

#### transformers.modeling_outputs.QuestionAnsweringModelOutput[[transformers.modeling_outputs.QuestionAnsweringModelOutput]]

```python
transformers.modeling_outputs.QuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1061)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin.

start_logits (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Puntuaciones de inicio de tramo (antes de SoftMax).

end_logits (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Puntuaciones de fin de tramo (antes de SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de respuesta a preguntas.

## Seq2SeqQuestionAnsweringModelOutput[[transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput]]

#### transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput[[transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1093)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin.

start_logits (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Puntuaciones de inicio de tramo (antes de SoftMax).

end_logits (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Puntuaciones de fin de tramo (antes de SoftMax).

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de los embeddings iniciales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de respuesta a preguntas de secuencia a secuencia.

## Seq2SeqSpectrogramOutput[[transformers.modeling_outputs.Seq2SeqSpectrogramOutput]]

#### transformers.modeling_outputs.Seq2SeqSpectrogramOutput[[transformers.modeling_outputs.Seq2SeqSpectrogramOutput]]

```python
transformers.modeling_outputs.Seq2SeqSpectrogramOutput(loss: typing.Optional[torch.Tensor] = None, spectrogram: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1424)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de generación de espectrograma.

spectrogram (`torch.Tensor` de forma `(batch_size, sequence_length, num_bins)`) : El espectrograma predicho.

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de los embeddings iniciales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de espectrogramas de secuencia a secuencia.

## SemanticSegmenterOutput[[transformers.modeling_outputs.SemanticSegmenterOutput]]

#### transformers.modeling_outputs.SemanticSegmenterOutput[[transformers.modeling_outputs.SemanticSegmenterOutput]]

```python
transformers.modeling_outputs.SemanticSegmenterOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1154)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación (o de regresión si config.num_labels==1).

logits (`torch.Tensor` de forma `(batch_size, config.num_labels, logits_height, logits_width)`) : Puntuaciones de clasificación para cada píxel.    Los logits devueltos no tienen necesariamente el mismo tamaño que los `pixel_values` pasados como entradas. Esto se hace para evitar realizar dos interpolaciones y perder algo de calidad cuando un usuario necesita redimensionar los logits al tamaño de la imagen original como procesamiento posterior. Debe comprobar siempre la forma de sus logits y redimensionarlos según sea necesario.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, patch_size, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, patch_size, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de segmentación semántica.

## ImageClassifierOutput[[transformers.modeling_outputs.ImageClassifierOutput]]

#### transformers.modeling_outputs.ImageClassifierOutput[[transformers.modeling_outputs.ImageClassifierOutput]]

```python
transformers.modeling_outputs.ImageClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1192)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación (o de regresión si config.num_labels==1).

logits (`torch.Tensor` de forma `(batch_size, config.num_labels)`) : Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos (también llamados mapas de características) del modelo en la salida de cada etapa.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, patch_size, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de clasificación de imágenes.

## ImageClassifierOutputWithNoAttention[[transformers.modeling_outputs.ImageClassifierOutputWithNoAttention]]

#### transformers.modeling_outputs.ImageClassifierOutputWithNoAttention[[transformers.modeling_outputs.ImageClassifierOutputWithNoAttention]]

```python
transformers.modeling_outputs.ImageClassifierOutputWithNoAttention(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1220)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación (o de regresión si config.num_labels==1).

logits (`torch.Tensor` de forma `(batch_size, config.num_labels)`) : Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada etapa) de forma `(batch_size, num_channels, height, width)`. Estados ocultos (también llamados mapas de características) del modelo en la salida de cada etapa.

Clase base para las salidas de los modelos de clasificación de imágenes.

## DepthEstimatorOutput[[transformers.modeling_outputs.DepthEstimatorOutput]]

#### transformers.modeling_outputs.DepthEstimatorOutput[[transformers.modeling_outputs.DepthEstimatorOutput]]

```python
transformers.modeling_outputs.DepthEstimatorOutput(loss: typing.Optional[torch.Tensor] = None, predicted_depth: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1241)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación (o de regresión si config.num_labels==1).

predicted_depth (`torch.Tensor` de forma `(batch_size, height, width)`) : Profundidad predicha para cada píxel.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, num_channels, height, width)`. Estados ocultos del modelo en la salida de cada capa más las salidas de embedding iniciales opcionales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, patch_size, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para las salidas de los modelos de estimación de profundidad.

## Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1299)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del modelo.

extract_features (`torch.Tensor` de forma `(batch_size, sequence_length, conv_dim[-1])`) : Secuencia de vectores de características extraídos de la última capa convolucional del modelo.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para la salida de los embeddings + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Clase base para modelos que han sido entrenados con el objetivo de pérdida de Wav2Vec2.

## XVectorOutput[[transformers.modeling_outputs.XVectorOutput]]

#### transformers.modeling_outputs.XVectorOutput[[transformers.modeling_outputs.XVectorOutput]]

```python
transformers.modeling_outputs.XVectorOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, embeddings: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1328)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona `labels`) : Pérdida de clasificación.

logits (`torch.Tensor` de forma `(batch_size, config.xvector_output_dim)`) : Estados ocultos de clasificación antes de AMSoftmax.

embeddings (`torch.Tensor` de forma `(batch_size, config.xvector_output_dim)`) : Embeddings de enunciado utilizados para la recuperación basada en similitud de vectores.

hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para la salida de los embeddings + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas de los embeddings iniciales.

attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Tipo de salida de [Wav2Vec2ForXVector](/docs/transformers/main/es/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector).

## Seq2SeqTSModelOutput[[transformers.modeling_outputs.Seq2SeqTSModelOutput]]

#### transformers.modeling_outputs.Seq2SeqTSModelOutput[[transformers.modeling_outputs.Seq2SeqTSModelOutput]]

```python
transformers.modeling_outputs.Seq2SeqTSModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, loc: typing.Optional[torch.Tensor] = None, scale: typing.Optional[torch.Tensor] = None, static_features: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1482)

**Parámetros:**

last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de hidden-states en la salida de la última capa del decodificador del modelo. Si se usa `past_key_values`, solo se devuelve el último hidden-state de las secuencias, de forma `(batch_size, 1, hidden_size)`.

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de embedding iniciales opcionales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de embedding iniciales opcionales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

loc (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) : Valores de desplazamiento de la ventana de contexto de cada serie temporal, que se utilizan para proporcionar al modelo entradas de la misma magnitud y luego para revertir el desplazamiento a la magnitud original.

scale (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) : Valores de escalado de la ventana de contexto de cada serie temporal, que se utilizan para proporcionar al modelo entradas de la misma magnitud y luego para reescalar de vuelta a la magnitud original.

static_features (`torch.Tensor` de forma `(batch_size, feature size)`, *opcional*) : Características estáticas de cada serie temporal en un lote, que se copian en las covariables durante la inferencia.

Clase base para las salidas del codificador de un modelo de series temporales que también contiene estados ocultos precalculados que pueden acelerar la decodificación secuencial.

## Seq2SeqTSPredictionOutput[[transformers.modeling_outputs.Seq2SeqTSPredictionOutput]]

#### transformers.modeling_outputs.Seq2SeqTSPredictionOutput[[transformers.modeling_outputs.Seq2SeqTSPredictionOutput]]

```python
transformers.modeling_outputs.Seq2SeqTSPredictionOutput(loss: typing.Optional[torch.Tensor] = None, params: tuple[torch.Tensor, ...] | None = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, loc: typing.Optional[torch.Tensor] = None, scale: typing.Optional[torch.Tensor] = None, static_features: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1552)

**Parámetros:**

loss (`torch.Tensor` de forma `(1,)`, *opcional*, devuelto cuando se proporciona un `future_values`) : Pérdida distribucional.

params (`torch.Tensor` de forma `(batch_size, num_samples, num_params)`) : Parámetros de la distribución elegida.

past_key_values (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) : Es una instancia de [EncoderDecoderCache](/docs/transformers/main/es/internal/generation_utils#transformers.EncoderDecoderCache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (consulte la entrada `past_key_values`) para acelerar la decodificación secuencial.

decoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de los embeddings iniciales.

decoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.

encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.

encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador en la salida de cada capa más las salidas de los embeddings iniciales.

encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

loc (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) : Valores de desplazamiento de la ventana de contexto de cada serie temporal, que se utilizan para proporcionar al modelo entradas de la misma magnitud y luego para revertir el desplazamiento a la magnitud original.

scale (`torch.Tensor` de forma `(batch_size,)` o `(batch_size, input_size)`, *opcional*) : Valores de escalado de la ventana de contexto de cada serie temporal, que se utilizan para proporcionar al modelo entradas de la misma magnitud y luego para reescalar de vuelta a la magnitud original.

static_features (`torch.Tensor` de forma `(batch_size, feature size)`, *opcional*) : Características estáticas de cada serie temporal en un lote, que se copian en las covariables durante la inferencia.

Clase base para las salidas del decodificador de un modelo de series temporales que también contiene la pérdida y los parámetros de la distribución elegida.

## SampleTSPredictionOutput[[transformers.modeling_outputs.SampleTSPredictionOutput]]

#### transformers.modeling_outputs.SampleTSPredictionOutput[[transformers.modeling_outputs.SampleTSPredictionOutput]]

```python
transformers.modeling_outputs.SampleTSPredictionOutput(sequences: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1622)

**Parámetros:**

sequences (`torch.Tensor` de forma `(batch_size, num_samples, prediction_length)` o `(batch_size, num_samples, prediction_length, input_size)`) : Valores muestreados de la distribución elegida.

Clase base para las salidas de predicción de modelos de series temporales que contiene los valores muestreados de la distribución elegida.