Transformers documentation
LW-DETR
Este modelo se publicó en HF papers el 24-07-2024 y se contribuyó a Hugging Face Transformers el 12-01-2026.
LW-DETR
LW-DETR propone una arquitectura de Detection Transformer (DETR) de bajo peso diseñada para competir con y superar a la serie dominante YOLO en la detección de objetos en tiempo real. Logra un nuevo equilibrio óptimo entre velocidad (latencia) y precisión (mAP) al combinar avances recientes en transformers con decisiones de diseño eficientes.
La arquitectura LW-DETR se caracteriza por su estructura simple y eficiente: un codificador ViT simple, un proyector y un decodificador DETR poco profundo. Mejora la arquitectura DETR para la eficiencia y la velocidad mediante las siguientes modificaciones principales:
- Codificador ViT eficiente: utiliza un ViT simple con atención de ventana/global intercalada y una organización de ventana principal para reducir drásticamente la complejidad y la latencia de la atención.
- Entrada más rica: agrega características de múltiples niveles del codificador y utiliza un Proyectador C2f (YOLOv8) para pasar características de dos escalas ($1/8$ y $1/32$).
- Decodificador más rápido: Emplea un decodificador DETR poco profundo de 3 capas con atención cruzada deformable para una latencia más baja y una convergencia más rápida.
- Consultas optimizadas: utiliza un esquema de consultas mixtas que combina consultas de contenido aprendibles y consultas espaciales generadas.
Puedes encontrar todos los puntos de control de LW DETR disponibles bajo la organización AnnaZhang. El código original se puede encontrar aquí.
Este modelo fue aportado por stevenbucaille.
Haz clic en los modelos LW-DETR en la barra lateral derecha para ver más ejemplos de cómo aplicar LW-DETR a diferentes tareas de detección de objetos.
El siguiente ejemplo demuestra cómo realizar la detección de objetos con la clase Pipeline y la clase AutoModel.
from transformers import pipeline
pipeline = pipeline(
"object-detection",
model="AnnaZhang/lwdetr_small_60e_coco",
device_map=0
)
pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")import requests
import torch
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForObjectDetection
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
model = AutoModelForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco", device_map="auto")
# prepare image for the model
inputs = image_processor(images=image, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3)
for result in results:
for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
score, label = score.item(), label_id.item()
box = [round(i, 2) for i in box.tolist()]
print(f"{model.config.id2label[label]}: {score:.2f} {box}")Recursos
Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con LwDetr.
- Véase también: Guía de la tarea de detección de objetos.
LwDetrConfig
clase transformers.LwDetrConfig
< 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 = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprojector_scale_factors: list[float] | tuple[float, ...] = ()hidden_expansion: float = 0.5c2f_num_blocks: int = 3activation_function: str = 'silu'batch_norm_eps: float = 1e-05dropout: float | int = 0.0decoder_ffn_dim: int = 2048decoder_n_points: int = 4decoder_layers: int = 3decoder_self_attention_heads: int = 8decoder_cross_attention_heads: int = 16decoder_activation_function: str = 'relu'num_queries: int = 300attention_bias: bool = Trueattention_dropout: float | int = 0.0activation_dropout: float | int = 0.0group_detr: int = 13init_std: float = 0.02disable_custom_kernels: bool = Trueclass_cost: int | float = 2bbox_cost: int | float = 5giou_cost: int | float = 2class_loss_coefficient: int | float = 1dice_loss_coefficient: int | float = 1bbox_loss_coefficient: int | float = 5giou_loss_coefficient: int | float = 2eos_coefficient: float = 0.1focal_alpha: float = 0.25auxiliary_loss: bool = Trued_model: int = 256 )
Parámetros
- backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — La configuración del modelo backbone. - projector_scale_factors (
list[float], opcional, valor predeterminado[]) — Factores de escala para la red de pirámide de características. Cada factor de escala determina la resolución de las características en diferentes niveles. Los valores admitidos son 0.5, 1.0 y 2.0. - hidden_expansion (
float, opcional, valor predeterminado 0.5) — Factor de expansión para las dimensiones ocultas en las capas del proyector. - c2f_num_blocks (
int, opcional, valor predeterminado 3) — Número de bloques en la capa C2F. - activation_function (
str, opcional, valor predeterminado"silu") — La función de activación no lineal en el proyector. Los valores admitidos son"silu","relu","gelu". - batch_norm_eps (
float, opcional, valor predeterminado 1e-05) — El valor de epsilon para las capas de normalización por lote. - dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción para todas las capas de dropout. - decoder_ffn_dim (
int, opcional, valor predeterminado 2048) — Dimensión de la capa “intermedia” (a menudo denominada feed-forward) en el decodificador. - decoder_n_points (
int, opcional, valor predeterminado 4) — El número de claves muestreadas en cada nivel de características para cada cabeza de atención en el decodificador. - decoder_layers (
int, opcional, valor predeterminado3) — Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor quenum_layers. - decoder_self_attention_heads (
int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención en la autoatención del decodificador. - decoder_cross_attention_heads (
int, opcional, valor predeterminado 16) — Número de cabezas de atención para cada capa de atención en la atención cruzada del decodificador. - decoder_activation_function (
str, opcional, valor predeterminado"relu") — La función de activación no lineal en el decodificador. Los valores admitidos son"relu","silu","gelu". - num_queries (
int, opcional, valor predeterminado 300) — Número de consultas de objetos, es decir, ranuras de detección. Este es el número máximo de objetos que LwDetrModel puede detectar en una sola imagen. - attention_bias (
bool, opcional, valor predeterminadoTrue) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención. - attention_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las probabilidades de atención. - activation_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada. - group_detr (
int, opcional, valor predeterminado 13) — Número de grupos para el mecanismo de atención Group DETR, que ayuda a reducir la complejidad computacional. - init_std (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - disable_custom_kernels (
bool, opcional, valor predeterminadoTrue) — Desactiva el uso de kernels personalizados de CUDA y CPU. Esta opción es necesaria para la exportación a ONNX, ya que los kernels personalizados no son compatibles con la exportación ONNX de PyTorch. - class_cost (
Union[int, float], opcional, valor predeterminado2) — Peso relativo del error de clasificación en el coste de correspondencia húngara. - bbox_cost (
Union[int, float], opcional, valor predeterminado5) — Peso relativo del error de la caja delimitadora L1 en el costo de correspondencia húngara. - giou_cost (
Union[int, float], opcional, valor predeterminado2) — Peso relativo de la pérdida de IoU generalizada en el costo de correspondencia húngara. - class_loss_coefficient (
float, opcional, valor predeterminado 1) — Peso relativo de la pérdida de clasificación en el coste de correspondencia húngara. - dice_loss_coefficient (
Union[int, float], opcional, valor predeterminado1) — Peso relativo de la pérdida dice en la pérdida de segmentación panóptica. - bbox_loss_coefficient (
Union[int, float], opcional, valor predeterminado5) — Peso relativo de la pérdida de caja delimitadora L1 en la pérdida de segmentación panóptica. - giou_loss_coefficient (
Union[int, float], opcional, valor predeterminado2) — Peso relativo de la pérdida de IoU generalizada en la pérdida de segmentación panóptica. - eos_coefficient (
float, opcional, valor predeterminado0.1) — Peso de clasificación relativo de la clase ‘no-object’ en la pérdida de detección de objetos. - focal_alpha (
float, opcional, valor predeterminado0.25) — Parámetro alfa en la pérdida focal. - auxiliary_loss (
bool, opcional, valor predeterminadoTrue) — Si se deben utilizar las pérdidas de decodificación auxiliares (pérdidas en cada capa del decodificador). - d_model (
int, opcional, valor predeterminado256) — Tamaño de las capas del codificador y de la capa pooler.
Esta es la clase de configuración para almacenar la configuración de un LwDetrModel. Se utiliza para instanciar un modelo Lw Detr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de AnnaZhang/lwdetr_small_60e_coco
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplos:
>>> from transformers import LwDetrConfig, LwDetrModel
>>> # Initializing a LW-DETR AnnaZhang/lwdetr_small_60e_coco style configuration
>>> configuration = LwDetrConfig()
>>> # Initializing a model (with random weights) from the AnnaZhang/lwdetr_small_60e_coco style configuration
>>> model = LwDetrModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLwDetrViTConfig
clase transformers.LwDetrViTConfig
< 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 = Nonehidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12mlp_ratio: int = 4hidden_act: str = 'gelu'dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, int] = 256pretrain_image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3qkv_bias: bool = Truewindow_block_indices: list[int] | tuple[int, ...] = ()use_absolute_position_embeddings: bool = True_out_features: list[str] | None = None_out_indices: list[int] | None = Nonecae_init_values: float = 0.1num_windows: int = 16 )
Parámetros
- hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - num_hidden_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - mlp_ratio (
int, opcional, valor predeterminado4) — Relación entre la dimensión oculta del MLP y la dimensión de la incrustación. - hidden_act (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - dropout_prob (
Union[float, int], opcional, valor predeterminado0.0) — La proporción para todas las capas de dropout. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - layer_norm_eps (
float, opcional, valor predeterminado1e-06) — La epsilon utilizada por las capas de normalización de capa. - image_size (
Union[int, list[int], tuple[int, int]], opcional, valor predeterminado256) — El tamaño (resolución) de cada imagen. - pretrain_image_size (
int, opcional, valor predeterminado 224) — El tamaño (resolución) de cada imagen durante el preentrenamiento. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, valor predeterminado16) — El tamaño (resolución) de cada parche. - num_channels (
int, opcional, valor predeterminado3) — El número de canales de entrada. - qkv_bias (
bool, opcional, valor predeterminadoTrue) — Si se debe añadir un sesgo a las consultas, claves y valores. - window_block_indices (
list[int], opcional, valor predeterminado[]) — Lista de índices de bloques que deben tener atención de ventana en lugar de la autoatención global regular. - use_absolute_position_embeddings (
bool, opcional, valor predeterminadoTrue) — Si se deben añadir embeddings de posición absoluta a los embeddings de parche. - cae_init_values (
float, opcional, valor predeterminado 0.1) — Valor de inicialización para los parámetros de CAE cuandouse_caeestá habilitado. - num_windows (
int, opcional, valor predeterminado 16) — Número de ventanas para la atención basada en ventanas. Debe ser un cuadrado perfecto y el tamaño de la imagen debe ser divisible por la raíz cuadrada de este valor. Esto permite una organización eficiente de los mapas de características con prioridad de ventana.
Esta es la clase de configuración para almacenar la configuración de un LwDetrModel. Se utiliza para instanciar un modelo Lw Detr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de AnnaZhang/lwdetr_small_60e_coco
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> from transformers import LwDetrViTConfig, LwDetrViTModel
>>> # Initializing a LW-DETR ViT configuration
>>> configuration = LwDetrViTConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = LwDetrViTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLwDetrModel
clase transformers.LwDetrModel
< source >( config: LwDetrConfig )
Parámetros
- config (LwDetrConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo LW Detr básico (constituido por un backbone y un decodificador Transformer) que genera estados ocultos sin ningún head específico en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( pixel_values: Tensor = Nonepixel_mask: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LwDetrModelOutput or tuple(torch.Tensor)
Parámetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando DeformableDetrImageProcessor. Consulte DeformableDetrImageProcessor.call() para más detalles (processor_classutiliza DeformableDetrImageProcessor para procesar las imágenes). - pixel_mask (
torch.LongTensorde forma(batch_size, height, width), opcional) — Máscara para evitar realizar atención sobre los valores de píxeles de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los píxeles reales (es decir, no enmascarados),
- 0 para los píxeles que son relleno (es decir, mascarados).
Devuelve
LwDetrModelOutput o tuple(torch.Tensor)
Un LwDetrModelOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LwDetrConfig) y las entradas.
El método forward de LwDetrModel sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
init_reference_points (
torch.Tensorde forma(batch_size, num_queries, 4)) — Puntos de referencia iniciales enviados a través del decodificador Transformer.last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del modelo.intermediate_hidden_states (
torch.Tensorde forma(batch_size, config.decoder_layers, num_queries, hidden_size)) — Estados ocultos intermedios apilados (salida de cada capa del decodificador).intermediate_reference_points (
torch.Tensorde forma(batch_size, config.decoder_layers, num_queries, 4)) — Puntos de referencia intermedios apilados (puntos de referencia de cada capa del decodificador).enc_outputs_class (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels), opcional, devuelto cuandoconfig.with_box_refine=Trueyconfig.two_stage=True) — Puntuaciones de las cajas delimitadoras predichas, donde lasconfig.two_stage_num_proposalscajas delimitadoras con mayor puntuación se seleccionan como propuestas de región en la primera etapa. Salida de la clasificación binaria de cajas delimitadoras (es decir, primer plano y fondo).enc_outputs_coord_logits (
torch.Tensorde forma(batch_size, sequence_length, 4), opcional, se devuelve cuandoconfig.with_box_refine=Trueyconfig.two_stage=True) — Logits de las coordenadas de las cajas delimitadoras predichas en la primera etapa.hidden_states (
tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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 opcionales de la incrustación inicial.
attentions (
tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el 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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una 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.
Ejemplos:
>>> from transformers import AutoImageProcessor, DeformableDetrModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
>>> model = DeformableDetrModel.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]LwDetrForObjectDetection
clase transformers.LwDetrForObjectDetection
< source >( config: LwDetrConfig )
Parámetros
- config (LwDetrConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
Modelo LW DETR (constituido por un backbone y un decodificador Transformer) con cabezas de detección de objetos en la parte superior, para tareas como la detección COCO.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( pixel_values: Tensor = Nonepixel_mask: typing.Optional[torch.LongTensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LwDetrObjectDetectionOutput or tuple(torch.Tensor)
Parámetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando DeformableDetrImageProcessor. Consulte DeformableDetrImageProcessor.call() para más detalles (processor_classutiliza DeformableDetrImageProcessor para procesar las imágenes). - pixel_mask (
torch.LongTensorde forma(batch_size, height, width), opcional) — Máscara para evitar realizar atención sobre los valores de píxeles de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los píxeles reales (es decir, no enmascarados),
- 0 para los píxeles que son relleno (es decir, mascarados).
- labels (
list[Dict]de longitud(batch_size,), opcional) — Etiquetas para calcular la pérdida de bipartite matching. Lista de diccionarios, donde cada diccionario contiene al menos las siguientes 2 claves: ‘class_labels’ y ‘boxes’ (las etiquetas de clase y las cajas delimitadoras de una imagen del lote, respectivamente). Las etiquetas de clase en sí deben ser untorch.LongTensorde longitud(number of bounding boxes in the image,)y las cajas untorch.Tensorde forma(number of bounding boxes in the image, 4).
Devuelve
LwDetrObjectDetectionOutput o tuple(torch.Tensor)
Un LwDetrObjectDetectionOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LwDetrConfig) y las entradas.
El método forward de LwDetrForObjectDetection sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, devuelta cuando se proporcionanlabels) — Pérdida total como combinación lineal de una log-verosimilitud negativa (entropía cruzada) para la predicción de clases y una pérdida de caja delimitadora. Esta última se define como una combinación lineal de la pérdida L1 y la pérdida de IoU generalizada e invariante a la escala.loss_dict (
Dict, opcional) — Un diccionario que contiene las pérdidas individuales. Útil para el registro.logits (
torch.Tensorde forma(batch_size, num_queries, num_classes + 1)) — Logits de clasificación (incluyendo no-objeto) para todas las consultas.pred_boxes (
torch.Tensorde forma(batch_size, num_queries, 4)) — Coordenadas de cajas normalizadas para todas las consultas, representadas como (center_x, center_y, width, height). Estos valores están normalizados en [0, 1], relativos al tamaño de cada imagen individual del lote (ignorando el posible relleno). Puede usar~DeformableDetrProcessor.post_process_object_detectionpara recuperar las cajas delimitadoras no normalizadas.auxiliary_outputs (
list[Dict], opcional) — Opcional, solo se devuelve cuando se activan las pérdidas auxiliares (es decir,config.auxiliary_lossestá establecido enTrue) y se proporcionan etiquetas. Es una lista de diccionarios que contienen las dos claves anteriores (logitsypred_boxes) para cada capa del decodificador.init_reference_points (
torch.Tensorde forma(batch_size, num_queries, 4)) — Puntos de referencia iniciales enviados a través del decodificador Transformer.last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del modelo.intermediate_hidden_states (
torch.Tensorde forma(batch_size, config.decoder_layers, num_queries, hidden_size)) — Estados ocultos intermedios apilados (salida de cada capa del decodificador).intermediate_reference_points (
torch.Tensorde forma(batch_size, config.decoder_layers, num_queries, 4)) — Puntos de referencia intermedios apilados (puntos de referencia de cada capa del decodificador).enc_outputs_class (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels), opcional, devuelto cuandoconfig.with_box_refine=Trueyconfig.two_stage=True) — Puntuaciones de las cajas delimitadoras predichas, donde lasconfig.two_stage_num_proposalscajas delimitadoras con mayor puntuación se seleccionan como propuestas de región en la primera etapa. Salida de la clasificación binaria de cajas delimitadoras (es decir, primer plano y fondo).enc_outputs_coord_logits (
torch.Tensorde forma(batch_size, sequence_length, 4), opcional, se devuelve cuandoconfig.with_box_refine=Trueyconfig.two_stage=True) — Logits de las coordenadas de las cajas delimitadoras predichas en la primera etapa.hidden_states (
tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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 opcionales de la incrustación inicial.
attentions (
tuple[torch.Tensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el 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 pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una 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.
Ejemplos:
>>> from transformers import AutoImageProcessor, LwDetrForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> image_processor = AutoImageProcessor.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
>>> model = LwDetrForObjectDetection.from_pretrained("AnnaZhang/lwdetr_small_60e_coco")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
... 0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
... box = [round(i, 2) for i in box.tolist()]
... print(
... f"Detected {model.config.id2label[label.item()]} with confidence "
... f"{round(score.item(), 3)} at location {box}"
... )
Detected cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78]
Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25]
Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25]LwDetrViTBackbone
clase transformers.LwDetrViTBackbone
< source >( config: LwDetrViTConfig )
Parámetros
- config (LwDetrViTConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El backbone de Lw Detr.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BackboneOutput or tuple(torch.Tensor)
Parámetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando DeformableDetrImageProcessor. Consulte DeformableDetrImageProcessor.call() para más detalles (processor_classutiliza DeformableDetrImageProcessor para procesar las imágenes).
Devuelve
BackboneOutput o tuple(torch.Tensor)
Un BackboneOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LwDetrConfig) y las entradas.
El método forward de LwDetrViTBackbone sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
feature_maps (
tuple(torch.Tensor)de forma(batch_size, num_channels, height, width)) — Mapas de características de las etapas.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size)o(batch_size, num_channels, height, width), según el backbone.Estados ocultos del modelo en la salida de cada etapa más las salidas de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length). Solo aplicable si el backbone usa atención.Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> from transformers import LwDetrViTConfig, LwDetrViTBackbone
>>> import torch
>>> config = LwDetrViTConfig()
>>> model = LwDetrViTBackbone(config)
>>> pixel_values = torch.randn(1, 3, 224, 224)
>>> with torch.no_grad():
... outputs = model(pixel_values)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 768, 14, 14]