Entrena modelos de detección y segmentación con anotaciones de imágenes

Novedad de la v2.14.0

Este tutorial entrena un detector de objetos con las cajas delimitadoras de tu propio estudio y muestra las cajas del detector a los siguientes anotadores como preetiquetas que corregir. El tutorial está pensado para responsables de estudios con un esquema image_annotation que han leído Entrena tu primer modelo o se manejan con la página Training del administrador. La primera mitad recorre un ciclo completo con torchvision-detect (cajas sobre imágenes, una ejecución de entrenamiento, escritura de vuelta, correcciones y una segunda ejecución), y todos los pasos se ejecutaron en la CPU de un portátil. La segunda mitad adapta el ciclo a YOLO, contornos, refinamiento con SAM, clases de imagen completa, portaobjetos completos, microscopía, mapas, células, páginas de documentos y modelos de visión y lenguaje, con una sección para cada uno.

Instalar los entrenadores de visión

torchvision-detect ajusta un detector Faster R-CNN de torchvision. El entrenador necesita torch y torchvision. Potato deja ambos fuera de la instalación predeterminada porque torch es una descarga de varios gigabytes. Instala el extra de visión en la máquina que entrena:

pip install "potato-annotation[train-vision]"

El mismo extra cubre torchvision-segment, hf-image-classification, sam-finetune, layoutlmv3 y vlm-sft. Un entrenador cuyos paquetes faltan aparece en la página Training como «not installed», con el comando que instala los paquetes.

Una GPU es opcional para el proyecto pequeño de abajo. En un Mac con Apple silicon, torchvision-detect y torchvision-segment entrenan en la CPU y no en Metal (mps), y el registro de la ejecución anota el cambio con la advertencia «torchvision-detect does not run on Apple's Metal (mps) with this torch; using the CPU». En las mediciones del equipo de Potato, un paso de entrenamiento en Metal con el tamaño de imagen predeterminado tardó más que una época completa en la CPU. Para imágenes mayores o un estudio más grande, entrena en un servidor con GPU como describe el entrenamiento remoto.

Preparar un proyecto de imágenes

El proyecto necesita tres cosas: las imágenes, un archivo de datos que las liste y una configuración. Coloca las imágenes en una carpeta llamada media dentro de la carpeta del proyecto, porque Potato sirve <task_dir>/media/ en la ruta de URL /media/ de forma predeterminada. Otra carpeta funciona cuando la configuración la nombra con media_directory.

shapes/
  config.yaml
  data/images.jsonl
  media/img_001.png
  media/img_002.png
  ...

Cada línea de data/images.jsonl es un ítem con un identificador y la ruta de URL de la imagen:

{"id": "img_001", "image_url": "/media/img_001.png"}

La configuración define un esquema image_annotation con la herramienta bbox y dos etiquetas, y activa el entrenamiento de modelos con escritura de vuelta. La configuración pasa python -m potato.validate_cli --strict:

annotation_task_name: "Shape detection (model training)"
task_dir: "."
data_files:
  - "data/images.jsonl"
item_properties:
  id_key: "id"
  text_key: "image_url"
output_annotation_dir: "annotation_output"
 
require_password: false
admin_api_key: "demo-admin-key"
num_annotators_per_item: 1
 
annotation_schemes:
  - annotation_type: "image_annotation"
    name: "objects"
    description: "Draw a box around every circle and every square."
    source_field: "image_url"
    tools: ["bbox"]
    labels:
      - name: "circle"
        color: "#e6194b"
      - name: "square"
        color: "#4363d8"
 
model_training:
  enabled: true
  writeback:
    schemas: ["objects"]
    include_unlabeled: true
    min_confidence: 0.5

Cuatro ajustes dan forma al ciclo:

• source_field: "image_url" indica al widget de imagen y al entrenador qué campo del ítem contiene la imagen.
• num_annotators_per_item: 1 asigna cada imagen a un anotador, de modo que las etiquetas iniciales cubran el mayor número posible de imágenes distintas.
• writeback.include_unlabeled: true hace que cada ejecución prediga sobre las imágenes que nadie ha etiquetado todavía. Sin este ajuste, una ejecución predice solo sobre las imágenes reservadas de val y test, y esas imágenes ya tienen cajas humanas.
• writeback.min_confidence: 0.5 retiene la predicción de una imagen cuando la puntuación media de sus cajas es inferior a 0,5. El umbral se aplica a la imagen entera, así que los anotadores nunca ven la mitad de las cajas de una imagen.

Inicia el servidor desde dentro de la carpeta del proyecto:

potato start config.yaml -p 8000

Etiquetar un conjunto inicial

torchvision-detect se niega a ajustar con menos de 20 imágenes anotadas en la partición train, y la partición predeterminada reparte el 70 % de las imágenes etiquetadas en train. Etiqueta al menos 30 imágenes, y más si los objetos varían. Dibuja las cajas a mano en http://localhost:8000. Una imagen sin cajas queda fuera del entrenamiento, porque un detector no distingue una imagen sin objetos de una imagen que nadie terminó. Dibuja todos los objetos de cada imagen que envíes.

Para probar el ciclo antes de que ninguna persona etiquete, el simulador de usuarios puede dibujar cajas a partir de un archivo de referencia. Cada entrada del archivo da el identificador de la imagen y las formas del esquema en coordenadas normalizadas:

[
  {"id": "img_001", "objects": [
    {"type": "bbox", "label": "circle",
     "coordinates": {"x": 0.158, "y": 0.849, "width": 0.106, "height": 0.146}}
  ]}
]

python -m potato.simulator --server http://localhost:8000 --users 3 \
  --strategy gold_standard --competence good=1.0 --max-annotations 20 \
  --gold-file data/gold.json --sequential --fast-mode --no-export

El simulador vuelve a dibujar cada caja de referencia con unos píxeles de variación, y en el nivel good también omite o etiqueta mal algunos objetos, como a veces hace un anotador cuidadoso. En nuestra prueba con 80 imágenes sintéticas, tres anotadores simulados etiquetaron 60 imágenes en cerca de un segundo.

Entrenar torchvision-detect

Abre http://localhost:8000/admin, introduce la clave de administrador demo-admin-key y abre http://localhost:8000/admin/training. Elige objects como esquema y torchvision-detect como entrenador, deja Parameters vacío y pulsa Train now. La misma ejecución se inicia desde un script con:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "torchvision-detect", "schemas": ["objects"]}'

La ejecución parte de los pesos COCO de torchvision y pone al detector una cabeza de cajas nueva para las dos etiquetas del esquema. Torch descarga los pesos COCO en la caché de torch durante la primera ejecución. Los valores predeterminados son la arquitectura pequeña fasterrcnn_mobilenet_v3_large_fpn, 15 épocas, 4 imágenes por paso y parada anticipada tras 4 épocas sin un mAP mejor en val. Toda forma se entrena como su caja delimitadora, así que un estudio cuyos anotadores dibujaron polígonos sigue entrenando un detector de cajas. Con varios anotadores por imagen, la ejecución entrena con la única respuesta completa que model_training.aggregation elige para la imagen, porque las cajas de dos personas rara vez coinciden con exactitud.

En la CPU Apple M4 Pro que usamos, 37 imágenes de entrenamiento de 320 por 240 píxeles se entrenaron en unos 106 segundos, y la ejecución se detuvo tras 5 épocas. Los archivos de la ejecución quedan en annotation_output/training/runs/<run_id>/, con el detector ajustado en artifacts/model/detector.pt. Los ajustes de la ejecución y el dispositivo que usó están en artifacts/model_card.json.

Leer la puntuación sobre ítems reservados

Cada ejecución puntúa el detector sobre imágenes con las que nunca entrenó. La métrica principal de un esquema image_annotation es map_50, la precisión media promedio de COCO en la que una caja predicha cuenta como acierto cuando se solapa con la caja delimitadora de un objeto anotado con un IoU de 0,5 o más. La página de la ejecución registra también map_50_95, el promedio sobre umbrales de IoU de 0,5 a 0,95. Las cajas de dos anotadores para un mismo objeto rara vez se solapan con un IoU de 0,9, así que los umbrales más estrictos miden en parte la coherencia con que dibujan las personas. Por eso Potato destaca el umbral de 0,5. Medir el acuerdo en cajas delimitadoras muestra cómo comprobar esa coherencia directamente.

El detector conserva el punto de control de la época con la mejor puntuación en val, de modo que la métrica principal procede de la partición test cuando esta tiene imágenes. La tabla de ejecuciones muestra la métrica principal en la columna Held-out score. La página de la ejecución lista n_train, n_boxes, el tamaño y la cobertura de cada partición, y el número de objetos anotados y predichos en val y test. En nuestra ejecución de prueba con las 80 imágenes sintéticas de círculos y cuadrados de colores, el detector obtuvo 0,99 en map_50 sobre test. Las formas sintéticas son mucho más fáciles de encontrar que los objetos reales, así que juzga la puntuación con tus propias imágenes.

Comprobar las preetiquetas

Tras una ejecución correcta, Potato escribe las cajas del detector en el campo predictions de cada imagen elegible. GET /admin/training/api/status informa del resultado en el campo writeback de la respuesta, con n_written para las imágenes que recibieron preetiquetas y un contador para cada motivo por el que se retuvo una imagen, por ejemplo n_skipped_low_confidence por debajo de min_confidence y n_skipped_train_split para las imágenes con las que entrenó la ejecución. Las imágenes de la partición train nunca reciben preetiquetas, porque la confianza de un modelo sobre sus propios datos de entrenamiento no dice nada de las imágenes nuevas.

Inicia sesión en http://localhost:8000 con un nombre de usuario nuevo. Cada imagen sin etiquetar que pasó las comprobaciones de escritura de vuelta se abre con las cajas del detector ya dibujadas. Cada caja se guarda con source: ai y la puntuación del detector como confidence. El anotador mueve o redimensiona una caja, cambia una etiqueta, elimina una falsa detección y dibuja los objetos que el detector omitió. Las cajas pasan a ser la respuesta del anotador cuando las edita o cuando avanza a la siguiente imagen. Una preetiqueta no se guarda nunca mientras el anotador solo mira la imagen. La cola de revisión del modelo sirve las imágenes preetiquetadas empezando por las de menor confianza, y un veredicto correct de un revisor coloca la imagen en la partición train de todas las ejecuciones posteriores.

Reentrenar con las cajas corregidas

Cada imagen corregida se convierte en una etiqueta humana para la siguiente ejecución. Inicia otra ejecución de torchvision-detect desde la página Training cuando los anotadores hayan trabajado un lote de imágenes preetiquetadas. Una ejecución nueva reemplaza la predicción de la ejecución anterior en cada imagen, y se retira la preetiqueta de una imagen con la que entrena la nueva ejecución.

Para reentrenar sin pulsar nada, añade un bloque auto_retrain. Este fragmento amplía el bloque model_training de arriba e inicia una ejecución cada 25 anotaciones nuevas, como máximo una vez cada 10 minutos:

model_training:
  enabled: true
  auto_retrain:
    enabled: true
    trainer: torchvision-detect
    schemas: [objects]
    update_frequency: 25
    min_interval_s: 600
  writeback:
    schemas: [objects]
    include_unlabeled: true
    min_confidence: 0.5

Las preetiquetas anclan a los anotadores a las cajas del modelo. Activa la escritura de vuelta para los anotadores cuando la puntuación sobre ítems reservados respalde las preetiquetas, y consulta Detectar preetiquetas aprobadas sin revisar para comprobar si los anotadores aceptan cajas sin mirarlas.

Detección más rápida con Ultralytics YOLO

ultralytics-detect entrena un detector Ultralytics YOLO a partir de un punto de control preentrenado con COCO (yolo11n.pt de forma predeterminada) con las mismas cajas. YOLO entrena y predice más rápido que torchvision-detect, y las preetiquetas son las mismas cajas editables. Ultralytics tiene licencia AGPL-3.0, y un modelo entrenado y distribuido con Ultralytics lleva los términos de la AGPL. Ultralytics vende una licencia empresarial aparte para uso cerrado. Los extras de Potato dejan fuera Ultralytics, así que instala el paquete por tu cuenta:

pip install ultralytics

Potato pide confirmar la licencia antes de cada ejecución. La página Training muestra una confirmación, una ejecución por API necesita "accept_licence": true en el cuerpo de la solicitud, y un reentrenamiento automático necesita auto_retrain.accept_licence: true. Sin la confirmación, la API rechaza la ejecución con HTTP 400, needs_licence_ack: true y el mensaje «ultralytics-detect is licensed AGPL-3.0». La solicitud siguiente confirma la licencia e inicia la ejecución:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "ultralytics-detect", "schemas": ["objects"], "accept_licence": true}'

Durante una ejecución, el entrenador desactiva la analítica de uso de Ultralytics, Ultralytics HUB, las integraciones con rastreadores de experimentos y las instalaciones automáticas de paquetes. Los cambios se aplican en memoria al proceso de la ejecución, y tu archivo de ajustes de Ultralytics no cambia. Los puntos de control se descargan en ~/.cache/potato/ultralytics. Los valores predeterminados son 50 épocas a 640 píxeles con parada anticipada tras 10 épocas.

Contornos en lugar de cajas

torchvision-segment entrena un Mask R-CNN de torchvision con contornos de polígono, elipse, trazo libre y máscara de pincel. Las cajas quedan fuera del entrenamiento de segmentación, porque una caja no dice qué píxeles pertenecen al objeto. Da a los anotadores una herramienta de contorno como polygon o brush. Cómo anotar máscaras de segmentación de imágenes explica cuándo conviene cada herramienta.

Cada máscara predicha se traza como un polígono de 64 vértices como máximo, de modo que el anotador corrige la preetiqueta punto por punto. Cuando una máscara sale en trozos, se conserva el más grande. El score_threshold predeterminado es 0,5 y no el 0,25 del detector. Las segundas conjeturas de Mask R-CNN para un mismo objeto puntúan entre 0,25 y 0,6, y cada conjetura sería una forma más que el anotador tendría que eliminar. Las puntuaciones sobre ítems reservados comparan los polígonos predichos con los contornos anotados. En un Mac, torchvision-segment entrena en la CPU. Con torch 2.8, el equipo de Potato midió un paso de entrenamiento sobre una imagen de 256 píxeles en 57 segundos en Metal y 2,3 segundos en la CPU. Usa un servidor con GPU para estudios reales. ultralytics-segment es la contrapartida YOLO (yolo11n-seg.pt), con los mismos polígonos de 64 vértices y la misma confirmación de la licencia AGPL-3.0.

Convertir cajas en contornos con sam-finetune

Las cajas son rápidas de dibujar y los contornos son lentos. sam-finetune ajusta el decodificador de máscaras de Segment Anything (SAM) para convertir una caja en el contorno que dibujarían tus anotadores. El codificador de imagen permanece congelado, y la incrustación de cada imagen se calcula una sola vez, de modo que una época cuesta poco. El entrenamiento usa como indicación la caja delimitadora de cada contorno anotado. La ejecución mueve y redimensiona cada caja de indicación hasta box_jitter (5 % de forma predeterminada), de modo que el decodificador aprende de cajas tan imprecisas como las de un detector.

sam-finetune refina cajas y necesita cajas de las que partir. La secuencia habitual sobre un esquema tiene dos ejecuciones:

1. Ejecuta torchvision-detect o ultralytics-detect con writeback.include_unlabeled: true, de modo que las imágenes sin etiquetar lleven preetiquetas de cajas.
2. Ejecuta sam-finetune sobre el mismo esquema. Cada preetiqueta de caja se convierte en una preetiqueta de polígono, y los polígonos sustituyen a las cajas.

El esquema necesita contornos de los que SAM pueda aprender, así que da a los anotadores una herramienta de contorno junto a bbox. En las imágenes reservadas, las cajas de los propios anotadores son las indicaciones, de modo que val_mask_iou informa del IoU medio del contorno cuando la caja es correcta. Esas predicciones sobre ítems reservados se puntúan pero nunca se guardan ni se publican, porque se hacen a partir de la respuesta de otro anotador. El informe de escritura de vuelta cuenta las predicciones sobre ítems reservados en n_skipped_heldout_only. El punto de control predeterminado es facebook/sam-vit-base (Apache-2.0). El decodificador ajustado sirve solo para preetiquetas. El clic para segmentar de la herramienta de imagen ejecuta en el navegador pesos ONNX distintos, y una ejecución de sam-finetune no sustituye esos pesos.

Clasificar imágenes completas

Para una pregunta sobre la imagen entera, por ejemplo un esquema radio que pregunta qué animal muestra una foto, usa un clasificador en lugar de un detector. hf-image-classification ajusta cualquier modelo que cargue AutoModelForImageClassification de Hugging Face, como ViT, DeiT, BEiT, ConvNeXt, Swin o DINOv2. El modelo predeterminado es google/vit-base-patch16-224-in21k. De forma predeterminada, el entrenador voltea las imágenes de entrenamiento al azar. Pon flip en false en Parameters cuando un volteo cambie la etiqueta, como con texto en la imagen o con izquierda y derecha. lora: true entrena un adaptador LoRA y la cabeza de clasificación en lugar de todos los pesos.

Un esquema de elección cuenta como corpus de imágenes cuando al menos el 80 % de sus ítems etiquetados llevan una ruta de imagen que termina en .jpg, .jpeg, .png, .bmp, .webp, .tif, .tiff o .gif. En un corpus así, sklearn-text sin un vectorizador nombrado ajusta un clasificador lineal sobre incrustaciones de imagen de CLIP. La línea base con CLIP no necesita GPU, solo pip install "potato-annotation[embeddings]" pillow.

Rutas de imagen e imágenes remotas

Los entrenadores de imagen leen el campo que nombra el source_field del esquema. Sin source_field, un entrenador toma el primer campo no vacío del ítem entre image_url, image, image_path, file_name, url, path y los equivalentes de audio y vídeo. Las imágenes deben ser archivos locales dentro del proyecto:

• Una ruta relativa se resuelve respecto de task_dir, o respecto de media_directory cuando el archivo no se encuentra bajo task_dir.
• Una ruta de URL como /media/img_001.jpg se resuelve respecto de media_directory. La página de anotación carga la imagen desde el mismo lugar.
• Un archivo que una ruta absoluta, ../ o un enlace simbólico sitúa fuera del directorio de la tarea y de media_directory se deja fuera con una advertencia.
• Las imágenes remotas http(s) no se descargan nunca. Una ejecución deja fuera todo ítem cuya imagen es remota o falta, el registro de la ejecución indica cuántos, y esos ítems no reciben predicción.

Descarga las imágenes remotas en media_directory para entrenar con ellas. La página de formatos de visión y potato import explican cómo traer a un proyecto conjuntos de imágenes existentes.

Portaobjetos completos y otras imágenes grandes

Los entrenadores de detección y segmentación reducen cada imagen a unos cientos de píxeles, y los objetos de un portaobjetos de patología de 100 000 píxeles o de una escena de satélite desaparecen a ese tamaño. Para un esquema image_annotation, microscopy o geo_annotation, Potato corta por eso las imágenes grandes en teselas cuando se construyen los datos de entrenamiento de la ejecución. El teselado es automático para los formatos de portaobjetos (.svs, .ndpi, .mrxs, .scn y otros) y para las imágenes cuyo lado mayor mide 4096 píxeles o más. Los portaobjetos necesitan openslide:

pip install "potato-annotation[wsi]"

El entrenamiento usa las teselas que contienen un objeto anotado más una muestra de teselas vacías, y cada objeto se recorta a su tesela. La predicción cubre todas las teselas sobre tejido, hasta max_predict_tiles por imagen. La partición de cada imagen se decide antes de cortarla, de modo que las teselas de un mismo portaobjetos nunca caen en dos particiones. Las predicciones de las teselas se fusionan de nuevo sobre la imagen completa, y un objeto que encontraron dos teselas solapadas se conserva una sola vez. Las preetiquetas usan las coordenadas de la imagen completa, las mismas que guarda el visor de zoom profundo. Las puntuaciones sobre ítems reservados se calculan sobre imágenes completas. Un backend remoto descarga las teselas y no el portaobjetos.

Los ajustes viven bajo model_training.tiling. Este fragmento entrena un portaobjetos a 40x como si fuera a 20x con teselas de 1024 píxeles:

model_training:
  enabled: true
  tiling:
    tile_size: 1024
    overlap: 128
    downsample: 2

Mantén overlap al menos tan grande como los objetos, porque un objeto mayor se encuentra en trozos, uno por tesela. Para un portaobjetos que registra su resolución, mpp fija las micras por píxel de tesela y anula downsample. Dos ajustes requieren cuidado en algunos portaobjetos. Las teselas vacías de entrenamiento suponen que se dibujó todo objeto de una imagen anotada, así que pon background: 0 cuando los anotadores dibujaron solo algunas regiones de un portaobjetos. El tejido se detecta con el umbral de Otsu sobre la miniatura del portaobjetos, de modo que un portaobjetos sin vidrio desnudo pierde su mitad más pálida, y tissue_threshold: 0 predice sobre todas las teselas. La tabla de tiling lista cada clave y su valor predeterminado.

Microscopía y mapas

Las ROI de un esquema microscopy entrenan torchvision-detect, ultralytics-detect, torchvision-segment, ultralytics-segment y cellpose. Cada corte z y cada instante con ROI se renderiza con los canales y el contraste predeterminados del esquema y se convierte en una imagen de entrenamiento aparte. El renderizador es el compositor que usa el visor. Una imagen en la que todavía no se ha dibujado nada se predice en el corte z central y en el primer instante, donde se abre el visor. Las predicciones vuelven como ROI de microscopía con la z y la t de cada ROI. Las clasificaciones de células se refieren a una imagen de etiquetas y no a una forma, y los entrenadores omiten las clasificaciones de células.

Los elementos de un esquema geo_annotation entrenan los mismos entrenadores de detección y segmentación sobre el mapa base ráster del ítem. Un GeoTIFF se coloca con la transformación y el código EPSG de las etiquetas del propio archivo y se reproyecta con pyproj cuando está proyectado. Una imagen simple con una extensión se coloca en longitud y latitud. Los polígonos, rectángulos, líneas y puntos se convierten en formas sobre el ráster, con los huecos de los polígonos rellenados. Las predicciones vuelven como elementos GeoJSON en EPSG:4326 con source: model. El mapa ofrece los elementos como sugerencias, y las sugerencias cuentan como respuesta solo cuando el anotador edita o acepta una. Un mapa cuyo mapa base es un servidor de teselas o un contorno GeoJSON no tiene ráster con el que entrenar, y la ejecución deja esos ítems fuera con una advertencia.

Células con cellpose

cellpose ajusta Cellpose con contornos de células o núcleos en un esquema image_annotation o microscopy. Instala Cellpose 3 o 4 por separado:

pip install cellpose

El modelo base predeterminado es cyto3. nuclei y cyto2 también funcionan con Cellpose 3, y cpsam con Cellpose 4. Pon diameter en el diámetro típico de las células en píxeles cuando la estimación propia de Cellpose falle. Cellpose segmenta sin clases, así que cada célula predicha recibe el parámetro label, o la etiqueta más frecuente del esquema cuando label no está definido. Entrena un modelo por etiqueta cuando las clases se vean distintas. Cada máscara predicha vuelve como un polígono con la probabilidad media de la célula como confianza de la preetiqueta. cellpose necesita solo 5 imágenes anotadas en la partición train, frente a las 20 de los detectores. El código de Cellpose es BSD-3-Clause, y los pesos proceden de los autores de Cellpose bajo los términos de los autores.

Espectrogramas

Las cajas de un esquema spectrogram_annotation entrenan torchvision-detect y ultralytics-detect con cada grabación renderizada como imagen de espectrograma. El tutorial de modelos de audio cubre la detección en espectrogramas de principio a fin, con los ajustes de renderizado y los formatos de grabación que leen los entrenadores.

Diseño de documentos con layoutlmv3

layoutlmv3 ajusta LayoutLMv3 para encontrar las regiones que dibujan los anotadores sobre imágenes de página a partir de las palabras de la página y de sus posiciones. Una región es cualquier bloque etiquetado, por ejemplo un título, una tabla o un total. Potato no ejecuta OCR, así que cada ítem lleva las palabras de la página con cajas en píxeles de la imagen de la página o de 0 a 1:

{"id": "page_001", "image": "pages/page_001.png",
 "words": [{"text": "INVOICE", "bbox": [40, 52, 180, 82]},
           {"text": "Total", "bbox": [300, 700, 380, 730]}]}

Una importación de PAGE XML en modo regions rellena words a partir de los elementos Word del archivo. Las palabras de la capa de texto de un PDF o de otra herramienta de OCR funcionan igual. Cada palabra se etiqueta con la región en la que cae su centro, las palabras predichas se fusionan de nuevo en regiones, y cada región se convierte en una preetiqueta de caja alrededor de sus palabras. Las puntuaciones sobre ítems reservados son el mAP de cajas. Una caja predicha termina en las palabras de la región, así que las regiones dibujadas mucho mayores que las palabras puntúan menos de lo que merecen las cajas.

Los pesos de LayoutLMv3 tienen licencia CC BY-NC-SA 4.0 y no son para uso comercial. Como con los entrenadores YOLO, la página Training pide confirmación antes de una ejecución, una ejecución por API necesita accept_licence: true y un reentrenamiento automático necesita auto_retrain.accept_licence: true.

Modelos de visión y lenguaje con vlm-sft

vlm-sft ajusta un modelo de visión y lenguaje con las respuestas de los anotadores sobre imágenes, con un adaptador LoRA de forma predeterminada y Qwen/Qwen2.5-VL-3B-Instruct como modelo predeterminado. El entrenador aprende de cuatro esquemas:

Las coordenadas están en una cuadrícula de 0 a 1000 de la imagen, de modo que cualquier punto de control puede aprender el formato a partir de los ejemplos. Una ejecución de texto publica la respuesta generada como preetiqueta de texto. Una ejecución de grounding publica una región o una ausencia para cada expresión, y Grounding con VLM cubre el esquema grounding_eval. Una ejecución de trayectoria de GUI sugiere un veredicto para cada paso a partir de dónde haría clic el modelo, y Evaluar agentes de uso del ordenador cubre las trazas de GUI. Una ejecución de pies de imagen se puntúa con F1 por tokens y BLEU-4 pero nunca se publica, porque las regiones con pie son una respuesta del anotador.

Los puntos de control reales necesitan una GPU. El equipo de Potato entrenó dos épocas de Qwen/Qwen3-VL-2B-Instruct con LoRA sobre 26 imágenes en 46 segundos en la GPU Metal de un Mac. {"lora": {"quantize": "4bit"}} en Parameters entrena un adaptador QLoRA sobre pesos base de 4 bits. Comprueba la licencia del modelo que elijas. Qwen2.5-VL-3B lleva la licencia de investigación de Qwen, y el modelo de 7B es Apache-2.0. El tutorial de ajuste fino de LLM cubre LoRA, QLoRA y la publicación de un modelo en Hugging Face Hub.

Más información

• Descripción general del entrenamiento de modelos, para el ciclo y la página Training
• Entrenadores, para todos los entrenadores agrupados por tarea
• Configuración, para todas las claves, las puntuaciones sobre ítems reservados, la escritura de vuelta y las rutas
• Etiquetado con el modelo en el ciclo, para la revisión, la adquisición y el reentrenamiento automático
• Entrenamiento remoto, para servidores con GPU por ssh, SLURM y el agente que sondea
• Anotación de imágenes, para las herramientas y opciones del esquema
• Zoo de modelos y licencias, para los modelos de visión que se ejecutan en el navegador y en el servidor
• Referencia del repositorio original para ítems de imagen, portaobjetos completos, torchvision-detect, sam-finetune y vlm-sft, con todas las tablas de parámetros

Referencias

• Ren, S., He, K., Girshick, R., and Sun, J. (2017). Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 39, 1137–1149. doi:10.1109/TPAMI.2016.2577031
• He, K., Gkioxari, G., Dollár, P., and Girshick, R. (2017). Mask R-CNN. 2017 IEEE International Conference on Computer Vision (ICCV), 2980–2988. doi:10.1109/ICCV.2017.322
• Kirillov, A., Mintun, E., Ravi, N., Mao, H., Rolland, C., Gustafson, L., Xiao, T., Whitehead, S., Berg, A. C., Lo, W.-Y., Dollár, P., and Girshick, R. (2023). Segment Anything. 2023 IEEE/CVF International Conference on Computer Vision (ICCV), 3992–4003. doi:10.1109/ICCV51070.2023.00371
• Stringer, C., Wang, T., Michaelos, M., and Pachitariu, M. (2021). Cellpose: a generalist algorithm for cellular segmentation. Nature Methods, 18, 100–106. doi:10.1038/s41592-020-01018-x
• Huang, Y., Lv, T., Cui, L., Lu, Y., and Wei, F. (2022). LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking. Proceedings of the 30th ACM International Conference on Multimedia, 4083–4091. doi:10.1145/3503161.3548112