Pular para o conteúdo

Treine modelos de detecção e segmentação com anotações de imagens

Ajuste um detector com as caixas do seu estudo, mostre as caixas previstas aos anotadores como pré-rótulos, retreine com as correções e adapte a execução a lâminas e células.

Novo na v2.14.0

Este tutorial treina um detector de objetos com as caixas delimitadoras do próprio estudo e mostra as caixas do detector aos próximos anotadores como pré-rótulos a corrigir. O tutorial é para responsáveis por estudos que têm um esquema image_annotation e leram Treine seu primeiro modelo ou estão à vontade com a página Training do administrador. A primeira metade percorre um ciclo completo com torchvision-detect (caixas em imagens, uma execução de treinamento, gravação de volta, correções e uma segunda execução), e todos os passos ali rodaram na CPU de um notebook. A segunda metade adapta o ciclo a YOLO, contornos, refinamento com SAM, classes de imagem inteira, lâminas inteiras, microscopia, mapas, células, páginas de documentos e modelos de visão e linguagem, uma seção para cada.

Instalando os treinadores de visão

torchvision-detect ajusta um detector Faster R-CNN do torchvision. O treinador precisa de torch e torchvision. O Potato deixa os dois fora da instalação padrão porque o torch é um download de vários gigabytes. Instale o extra de visão na máquina que treina:

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

O mesmo extra cobre torchvision-segment, hf-image-classification, sam-finetune, layoutlmv3 e vlm-sft. Um treinador cujos pacotes estão ausentes aparece na página Training como "not installed", com o comando que instala os pacotes.

Uma GPU é opcional para o pequeno projeto abaixo. Em um Mac com Apple silicon, torchvision-detect e torchvision-segment treinam na CPU em vez de no Metal (mps), e o log da execução registra a troca com o aviso "torchvision-detect does not run on Apple's Metal (mps) with this torch; using the CPU". Nas medições da equipe do Potato, um passo de treinamento no Metal com o tamanho de imagem padrão levou mais tempo do que uma época inteira na CPU. Para imagens maiores ou um estudo maior, treine em um servidor com GPU, como descreve o treinamento remoto.

Configurando um projeto de imagens

O projeto precisa de três coisas: as imagens, um arquivo de dados que lista as imagens e uma configuração. Coloque as imagens em uma pasta chamada media dentro da pasta do projeto, porque o Potato serve <task_dir>/media/ no caminho de URL /media/ por padrão. Uma pasta diferente funciona quando a configuração nomeia a pasta com media_directory.

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

Cada linha de data/images.jsonl é um item com um id e o caminho de URL da imagem:

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

A configuração define um esquema image_annotation com a ferramenta bbox e dois rótulos, e ativa o treinamento de modelos com gravação de volta. A configuração passa em python -m potato.validate_cli --strict:

yaml
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

Quatro configurações moldam o ciclo:

  • source_field: "image_url" diz ao widget de imagem e ao treinador qual campo do item contém a imagem.
  • num_annotators_per_item: 1 dá a cada imagem um anotador, de modo que os rótulos iniciais cobrem o maior número possível de imagens diferentes.
  • writeback.include_unlabeled: true faz cada execução prever nas imagens que ninguém rotulou ainda. Sem essa configuração, uma execução prevê apenas nas imagens val e test reservadas, e essas imagens já têm caixas humanas.
  • writeback.min_confidence: 0.5 retém a predição de uma imagem quando a pontuação média das caixas da imagem é menor que 0,5. O limite vale para a imagem inteira, então os anotadores nunca veem metade das caixas de uma imagem.

Inicie o servidor de dentro da pasta do projeto:

bash
potato start config.yaml -p 8000

Rotulando um conjunto inicial

torchvision-detect se recusa a ajustar com menos de 20 imagens anotadas na divisão train, e a divisão padrão põe 70% das imagens rotuladas em train. Rotule pelo menos 30 imagens, e mais se os objetos variarem. Desenhe as caixas à mão em http://localhost:8000. Uma imagem sem caixas fica fora do treinamento, porque um detector não distingue uma imagem sem objetos de uma imagem que ninguém terminou. Desenhe todos os objetos de uma imagem que você enviar.

Para testar o ciclo antes de qualquer pessoa rotular, o simulador de usuários pode desenhar caixas a partir de um arquivo gold. Cada entrada gold dá o id da imagem e as formas do esquema em coordenadas normalizadas:

json
[
  {"id": "img_001", "objects": [
    {"type": "bbox", "label": "circle",
     "coordinates": {"x": 0.158, "y": 0.849, "width": 0.106, "height": 0.146}}
  ]}
]
bash
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

O simulador redesenha cada caixa gold com alguns pixels de variação e, no nível good, também deixa de marcar ou rotula errado alguns objetos, como um anotador cuidadoso às vezes faz. No nosso teste com 80 imagens sintéticas, três anotadores simulados rotularam 60 imagens em cerca de um segundo.

Treinando o torchvision-detect

Abra http://localhost:8000/admin, informe a chave de administrador demo-admin-key e abra http://localhost:8000/admin/training. Escolha objects como esquema e torchvision-detect como treinador, deixe Parameters vazio e clique em Train now. A mesma execução começa a partir de um script com:

bash
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"]}'

A execução parte dos pesos COCO do torchvision e põe uma nova cabeça de caixas no detector para os dois rótulos do esquema. O torch baixa os pesos COCO para o cache do torch na primeira execução. Os padrões são a pequena arquitetura fasterrcnn_mobilenet_v3_large_fpn, 15 épocas, 4 imagens por passo e parada antecipada após 4 épocas sem um mAP melhor em val. Toda forma é treinada como a caixa delimitadora da forma, então um estudo cujos anotadores desenharam polígonos ainda treina um detector de caixas. Com vários anotadores por imagem, a execução treina com a única resposta inteira que model_training.aggregation escolhe para a imagem, porque as caixas de duas pessoas raramente coincidem exatamente.

Na CPU Apple M4 Pro que usamos, 37 imagens de treinamento de 320 por 240 pixels treinaram em cerca de 106 segundos, e a execução parou após 5 épocas. Os arquivos da execução ficam em annotation_output/training/runs/<run_id>/, com o detector ajustado em artifacts/model/detector.pt. As configurações da execução e o dispositivo que a execução usou estão em artifacts/model_card.json.

Lendo a pontuação em itens reservados

Toda execução avalia o detector nas imagens com que o detector nunca treinou. A pontuação principal de um esquema image_annotation é map_50, a precisão média (mAP) do COCO em que uma caixa prevista conta como acerto quando a caixa se sobrepõe à caixa delimitadora de um objeto anotado com IoU de 0,5 ou mais. A página da execução também registra map_50_95, a média sobre limiares de IoU de 0,5 a 0,95. As caixas de dois anotadores para um mesmo objeto raramente se sobrepõem com IoU 0,9, então os limiares mais rígidos medem em parte a consistência com que as pessoas desenham. O Potato por isso prioriza o limiar de 0,5. Medindo a concordância em caixas delimitadoras mostra como verificar essa consistência diretamente.

O detector mantém o checkpoint da época com a melhor pontuação em val, então a pontuação principal vem da divisão test quando a divisão test tem imagens. A tabela Runs mostra a pontuação principal na coluna Held-out score. A página da execução lista n_train, n_boxes, o tamanho e a cobertura de cada divisão e o número de objetos anotados e previstos em val e test. Na nossa execução de teste com as 80 imagens sintéticas de círculos e quadrados coloridos, o detector obteve 0,99 em map_50 de test. Formas sintéticas são muito mais fáceis de encontrar do que objetos reais, então avalie a pontuação nas suas próprias imagens.

Conferindo os pré-rótulos

Depois de uma execução bem-sucedida, o Potato grava as caixas do detector no campo predictions de cada imagem elegível. GET /admin/training/api/status informa o resultado no campo writeback da resposta, com n_written para as imagens que receberam pré-rótulos e uma contagem para cada motivo pelo qual uma imagem foi retida, por exemplo n_skipped_low_confidence abaixo de min_confidence e n_skipped_train_split para imagens com que a execução treinou. Imagens da divisão train nunca recebem pré-rótulos, porque a confiança de um modelo nos próprios dados de treinamento não diz nada sobre imagens novas.

Entre em http://localhost:8000 com um novo nome de usuário. Cada imagem não rotulada que passou nas verificações de gravação de volta abre com as caixas do detector já desenhadas. Cada caixa é armazenada com source: ai e a pontuação do detector como confidence. O anotador move ou redimensiona uma caixa, troca um rótulo, exclui uma detecção falsa e desenha qualquer objeto que o detector perdeu. As caixas se tornam a resposta do anotador quando o anotador as edita ou passa para a imagem seguinte. Um pré-rótulo nunca é salvo enquanto o anotador apenas olha a imagem. A fila de revisão de modelos serve as imagens pré-rotuladas da menos confiável para a mais confiável, e um veredito correct de um revisor põe a imagem na divisão train de todas as execuções seguintes.

Retreinando com as caixas corrigidas

Cada imagem corrigida se torna um rótulo humano para a próxima execução. Inicie outra execução de torchvision-detect na página Training depois que os anotadores tiverem trabalhado em um lote de imagens pré-rotuladas. Uma nova execução substitui a predição da execução anterior em cada imagem, e um pré-rótulo em uma imagem com que a nova execução treina é retirado.

Para retreinar sem clicar, adicione um bloco auto_retrain. Este fragmento estende o bloco model_training acima e inicia uma execução a cada 25 novas anotações, no máximo uma vez a cada 10 minutos:

yaml
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

Pré-rótulos ancoram os anotadores nas caixas do modelo. Ative a gravação de volta para os anotadores quando a pontuação em itens reservados justificar os pré-rótulos, e veja Detectando pré-rótulos aprovados sem revisão para uma forma de verificar se os anotadores aceitam caixas sem olhar.

Detecção mais rápida com o Ultralytics YOLO

ultralytics-detect treina um detector Ultralytics YOLO a partir de um checkpoint pré-treinado no COCO (yolo11n.pt por padrão) com as mesmas caixas. O YOLO treina e prevê mais rápido que torchvision-detect, e os pré-rótulos são as mesmas caixas editáveis. O Ultralytics tem licença AGPL-3.0, e um modelo treinado e distribuído com o Ultralytics carrega os termos da AGPL. A Ultralytics vende uma licença empresarial separada para uso fechado. Os extras do Potato deixam o Ultralytics de fora, então instale o pacote você mesmo:

bash
pip install ultralytics

O Potato pede que você confirme a licença antes de cada execução. A página Training mostra uma confirmação, uma execução pela API precisa de "accept_licence": true no corpo da requisição e um retreinamento automático precisa de auto_retrain.accept_licence: true. Sem a confirmação, a API recusa a execução com HTTP 400, needs_licence_ack: true e a mensagem "ultralytics-detect is licensed AGPL-3.0". A requisição abaixo confirma a licença e inicia a execução:

bash
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 uma execução, o treinador desativa a análise de uso do Ultralytics, o Ultralytics HUB, as integrações com rastreadores de experimentos e as instalações automáticas de pacotes. As mudanças valem na memória do processo da execução, e o seu arquivo de configurações do Ultralytics permanece inalterado. Os checkpoints são baixados em ~/.cache/potato/ultralytics. Os padrões são 50 épocas a 640 pixels, com parada antecipada após 10 épocas.

Contornos em vez de caixas

torchvision-segment treina um Mask R-CNN do torchvision com contornos de polígono, elipse, mão livre e máscara de pincel. Caixas ficam fora do treinamento de segmentação, porque uma caixa não diz quais pixels pertencem ao objeto. Dê aos anotadores uma ferramenta de contorno como polygon ou brush. Como anotar máscaras de segmentação de imagens cobre quando cada ferramenta serve.

Cada máscara prevista é traçada em um polígono com no máximo 64 vértices, então o anotador corrige o pré-rótulo ponto a ponto. Quando uma máscara sai em pedaços, o maior pedaço é mantido. O score_threshold padrão é 0,5 em vez dos 0,25 do detector. Os segundos palpites do Mask R-CNN para um objeto pontuam entre 0,25 e 0,6, e cada palpite seria mais uma forma para o anotador excluir. As pontuações em itens reservados comparam os polígonos previstos com os contornos anotados. Em um Mac, torchvision-segment treina na CPU. Com o torch 2.8, a equipe do Potato mediu um passo de treinamento em uma imagem de 256 pixels em 57 segundos no Metal e 2,3 segundos na CPU. Use um servidor com GPU em estudos reais. ultralytics-segment é a contraparte YOLO (yolo11n-seg.pt), com os mesmos polígonos de 64 vértices e a mesma confirmação de licença AGPL-3.0.

Transformando caixas em contornos com sam-finetune

Caixas são rápidas de desenhar e contornos são lentos. sam-finetune ajusta o decodificador de máscaras do Segment Anything (SAM) para transformar uma caixa no contorno que os seus anotadores desenhariam. O codificador de imagens permanece congelado, e o embedding de cada imagem é calculado uma vez, então uma época custa pouco. O treinamento usa a caixa delimitadora de cada contorno anotado como prompt. A execução move e redimensiona cada caixa de prompt em até box_jitter (5% por padrão), de modo que o decodificador aprende com caixas tão imprecisas quanto as de um detector.

sam-finetune refina caixas e precisa de caixas para começar. A sequência usual em um esquema tem duas execuções:

  1. Execute torchvision-detect ou ultralytics-detect com writeback.include_unlabeled: true, para que as imagens não rotuladas tenham pré-rótulos de caixas.
  2. Execute sam-finetune no mesmo esquema. Cada pré-rótulo de caixa se torna um pré-rótulo de polígono, e os polígonos substituem as caixas.

O esquema precisa de contornos para o SAM aprender, então dê aos anotadores uma ferramenta de contorno ao lado de bbox. Em imagens reservadas, as próprias caixas dos anotadores são os prompts, então val_mask_iou informa o IoU médio do contorno quando a caixa está certa. Essas predições em itens reservados são avaliadas, mas nunca armazenadas nem publicadas, porque as predições partem da resposta de outro anotador. O relatório de gravação de volta conta as predições em itens reservados em n_skipped_heldout_only. O checkpoint padrão é facebook/sam-vit-base (Apache-2.0). O decodificador ajustado serve apenas pré-rótulos. O clique para segmentar da ferramenta de imagem executa pesos ONNX separados no navegador, e uma execução de sam-finetune não substitui esses pesos.

Classificando imagens inteiras

Para uma pergunta sobre a imagem inteira, por exemplo um esquema radio que pergunta que animal uma foto mostra, use um classificador em vez de um detector. hf-image-classification ajusta qualquer modelo que o AutoModelForImageClassification do Hugging Face carregue, como ViT, DeiT, BEiT, ConvNeXt, Swin ou DINOv2. O modelo padrão é google/vit-base-patch16-224-in21k. O treinador espelha as imagens de treinamento aleatoriamente por padrão. Defina flip como false em Parameters quando um espelhamento mudar o rótulo, como em texto na imagem ou esquerda e direita. lora: true treina um adaptador LoRA e a cabeça de classificação em vez de todos os pesos.

Um esquema de escolha conta como um corpus de imagens quando pelo menos 80% dos itens rotulados do esquema têm um caminho de imagem terminado em .jpg, .jpeg, .png, .bmp, .webp, .tif, .tiff ou .gif. Em um corpus assim, sklearn-text sem vetorizador nomeado ajusta um classificador linear sobre embeddings de imagem do CLIP. A linha de base com CLIP não precisa de GPU, apenas de pip install "potato-annotation[embeddings]" pillow.

Caminhos de imagens e imagens remotas

Os treinadores de imagem leem o campo que o source_field do esquema nomeia. Sem source_field, um treinador usa o primeiro campo não vazio do item entre image_url, image, image_path, file_name, url, path e os equivalentes de áudio e vídeo. As imagens precisam ser arquivos locais dentro do projeto:

  • Um caminho relativo é resolvido em relação a task_dir, ou a media_directory quando o arquivo não é encontrado em task_dir.
  • Um caminho de URL como /media/img_001.jpg é resolvido em relação a media_directory. A página de anotação carrega a imagem do mesmo lugar.
  • Um arquivo que um caminho absoluto, ../ ou um link simbólico coloca fora do diretório da tarefa e de media_directory fica de fora, com um aviso.
  • Imagens remotas http(s) nunca são baixadas. Uma execução deixa de fora todo item cuja imagem é remota ou está ausente, o log da execução informa quantos, e esses itens não recebem predição.

Baixe as imagens remotas para media_directory para treinar com elas. A página de formatos de visão e o potato import cobrem como trazer conjuntos de imagens existentes para um projeto.

Lâminas inteiras e outras imagens grandes

Os treinadores de detecção e segmentação redimensionam cada imagem para algumas centenas de pixels, e os objetos de uma lâmina de patologia de 100.000 pixels ou de uma cena de satélite desaparecem nesse tamanho. Para um esquema image_annotation, microscopy ou geo_annotation, o Potato por isso corta imagens grandes em blocos quando os dados de treinamento da execução são construídos. A divisão em blocos é automática para formatos de lâmina (.svs, .ndpi, .mrxs, .scn e outros) e para imagens cujo lado maior tem 4.096 pixels ou mais. Lâminas precisam do openslide:

bash
pip install "potato-annotation[wsi]"

O treinamento usa os blocos que contêm um objeto anotado mais uma amostra de blocos vazios, e cada objeto é recortado no bloco dele. A predição cobre todos os blocos sobre tecido, até max_predict_tiles por imagem. A divisão de cada imagem é decidida antes de a imagem ser cortada, então os blocos de uma mesma lâmina nunca caem em duas divisões. As predições dos blocos são reunidas de volta na imagem inteira, e um objeto que dois blocos sobrepostos encontraram é mantido uma vez. Os pré-rótulos usam as coordenadas da imagem inteira, as mesmas que o visualizador de zoom profundo armazena. As pontuações em itens reservados são calculadas em imagens inteiras. Um backend remoto baixa os blocos em vez da lâmina.

As configurações ficam em model_training.tiling. Este fragmento treina uma lâmina de 40x a 20x com blocos de 1.024 pixels:

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

Mantenha overlap pelo menos tão grande quanto os objetos, já que um objeto maior é encontrado em pedaços, um por bloco. Para uma lâmina que registra a resolução da lâmina, mpp define micrômetros por pixel de bloco e substitui downsample. Duas configurações exigem cuidado em algumas lâminas. Os blocos vazios de treinamento pressupõem que todo objeto de uma imagem anotada foi desenhado, então defina background: 0 quando os anotadores desenharam apenas algumas regiões de uma lâmina. O tecido é detectado pelo limiar de Otsu na miniatura da lâmina, então uma lâmina sem vidro exposto perde a metade mais clara da lâmina, e tissue_threshold: 0 prevê em todos os blocos. A tabela de tiling lista todas as chaves e os padrões.

Microscopia e mapas

As ROIs de um esquema microscopy treinam torchvision-detect, ultralytics-detect, torchvision-segment, ultralytics-segment e cellpose. Cada fatia z e cada instante de tempo com ROIs é renderizado com os canais e o contraste padrão do esquema e se torna uma imagem de treinamento separada. O renderizador é o compositor que o visualizador usa. Uma imagem sem nada desenhado ainda é prevista na fatia z do meio e no primeiro instante de tempo, onde o visualizador abre. As predições voltam como ROIs de microscopia com z e t de cada ROI. As classificações de células se referem a uma imagem de rótulos em vez de uma forma, e os treinadores ignoram as classificações de células.

As feições de um esquema geo_annotation treinam os mesmos treinadores de detecção e segmentação no mapa-base raster do item. Um GeoTIFF é posicionado pela transformação e pelo código EPSG nas tags do próprio arquivo e reprojetado com pyproj quando projetado. Uma imagem simples com uma extensão é posicionada em longitude e latitude. Polígonos, retângulos, linhas e pontos se tornam formas no raster, com os buracos dos polígonos preenchidos. As predições voltam como feições GeoJSON em EPSG:4326 com source: model. O mapa oferece as feições como sugestões, e as sugestões só contam como resposta quando o anotador edita ou aceita uma. Um mapa cujo mapa-base é um servidor de blocos ou um contorno GeoJSON não tem raster para treinar, e a execução deixa esses itens de fora com um aviso.

Células com cellpose

cellpose ajusta o Cellpose com contornos de células ou núcleos em um esquema image_annotation ou microscopy. Instale o Cellpose 3 ou 4 separadamente:

bash
pip install cellpose

O modelo base padrão é cyto3. nuclei e cyto2 também funcionam com o Cellpose 3, e cpsam com o Cellpose 4. Defina diameter como o diâmetro típico das células em pixels quando a estimativa do próprio Cellpose estiver errada. O Cellpose segmenta sem classes, então toda célula prevista recebe o parâmetro label, ou o rótulo mais comum do esquema quando label não está definido. Treine um modelo por rótulo quando as classes tiverem aparência diferente. Cada máscara prevista volta como um polígono, com a probabilidade média da célula como confiança do pré-rótulo. cellpose precisa de apenas 5 imagens anotadas na divisão train, contra 20 dos detectores. O código do Cellpose é BSD-3-Clause, e os pesos vêm dos autores do Cellpose sob os termos dos autores.

Espectrogramas

As caixas de um esquema spectrogram_annotation treinam torchvision-detect e ultralytics-detect com cada gravação renderizada como uma imagem de espectrograma. O tutorial de modelos de áudio cobre a detecção em espectrogramas de ponta a ponta, com as configurações de renderização e os formatos de gravação que os treinadores leem.

Layout de documentos com layoutlmv3

layoutlmv3 ajusta o LayoutLMv3 para encontrar as regiões que os anotadores desenham em imagens de páginas, a partir das palavras da página e das posições das palavras. Uma região é qualquer bloco rotulado, por exemplo um título, uma tabela ou um total. O Potato não executa OCR, então cada item traz as palavras da página com caixas em pixels da imagem da página ou de 0 a 1:

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

Uma importação de PAGE XML no modo regions preenche words a partir dos elementos Word do arquivo. Palavras da camada de texto de um PDF ou de outra ferramenta de OCR funcionam da mesma forma. Cada palavra é rotulada pela região em que o centro da palavra cai, as palavras previstas são reunidas em regiões, e cada região se torna um pré-rótulo de caixa em torno das palavras da região. As pontuações em itens reservados são o mAP de caixas. Uma caixa prevista termina nas palavras da região, então regiões desenhadas muito maiores que as palavras pontuam menos do que as caixas merecem.

Os pesos do LayoutLMv3 têm licença CC BY-NC-SA 4.0 e não servem para uso comercial. Como nos treinadores YOLO, a página Training pede confirmação antes de uma execução, uma execução pela API precisa de accept_licence: true e um retreinamento automático precisa de auto_retrain.accept_licence: true.

Modelos de visão e linguagem com vlm-sft

vlm-sft ajusta um modelo de visão e linguagem com as respostas dos anotadores sobre imagens, com um adaptador LoRA por padrão e Qwen/Qwen2.5-VL-3B-Instruct como modelo padrão. O treinador aprende com quatro esquemas:

EsquemaUm exemplo de treinamento porO que o modelo aprende a produzir
text em itens de imagemitemA resposta do anotador à pergunta do esquema
region_captionregião legendadaA legenda de uma região desenhada como uma caixa vermelha
grounding_evalexpressão respondidaA região como JSON, um ponto ou {"absent": true}
gui_trajectorypasso julgado correct com um cliqueO clique, como {"point": [x, y]}

As coordenadas ficam em uma grade de 0 a 1.000 da imagem, de modo que qualquer checkpoint consegue aprender o formato a partir dos exemplos. Uma execução de texto publica a resposta gerada como um pré-rótulo de texto. Uma execução de grounding publica uma região ou uma ausência para cada expressão, e VLM grounding cobre o esquema grounding_eval. Uma execução de trajetória de GUI sugere um veredito para cada passo a partir de onde o modelo clicaria, e Avaliando agentes de uso de computador cobre os traços de GUI. Uma execução de legendas é avaliada com F1 de tokens e BLEU-4 mas nunca é publicada, porque as regiões legendadas são a resposta de um anotador.

Checkpoints reais precisam de GPU. A equipe do Potato treinou duas épocas de Qwen/Qwen3-VL-2B-Instruct com LoRA em 26 imagens em 46 segundos na GPU Metal de um Mac. {"lora": {"quantize": "4bit"}} em Parameters treina um adaptador QLoRA sobre pesos base de 4 bits. Verifique a licença do modelo que você escolher. O Qwen2.5-VL-3B carrega a licença de pesquisa da Qwen, e o modelo de 7B é Apache-2.0. O tutorial de ajuste fino de LLMs cobre LoRA, QLoRA e a publicação de um modelo no Hugging Face Hub.

Leitura complementar

Referências

  • 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