CommunityImagegithub.com

wshobson/vision-sft

Ajuster finement les modèles de langage et de vision (VLM) par apprentissage supervisé sur des données image+texte. À utiliser pour adapter un VLM à un domaine ou une tâche visuelle, configurer un LoRA avec tour de vision gelée, ou déboguer un ajustement fin qui s'entraîne sans apprendre.

Qu'est-ce que vision-sft ?

Ce skill spécialise le fine-tuning supervisé (SFT) pour les modèles de langage et de vision (VLM), en supposant que la méthode de fine-tuning a déjà été sélectionnée et que les données sont des démonstrations image+texte. Il fournit une recette consensuelle : geler la tour de vision et le projecteur, appliquer LoRA uniquement sur le LLM avec un rang 8-16 et un alpha 16-32. Les cas de dégel de la tour de vision sont réservés aux changements de domaine visuel significatifs, avec des règles strictes (6 dernières couches ViT, taux d'apprentissage 5-10x inférieur). Le skill identifie aussi deux « tueurs silencieux » courants : le décalage entre les placeholders d'image et les médias, et le budget de résolution min_pixels/max_pixels. Compatible avec Unsloth, avec des mises en garde sur l'utilisation de fast_inference et du collateur dédié. Le choix du modèle de base est délégué au catalogue de modèles. L'apprentissage par renforcement des VLM est hors du scope ici.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/wshobson/agents/tree/main/plugins/llm-finetuning/skills/vision-sft

Installed? Explore more Image skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Vision-Language SFT (Ajustement Fin Supervisé Vision-Langage)

Ce skill suppose que finetuning-method-selection a déjà orienté ici : la forme des données est constituée de démonstrations image+texte, et non de paires de préférences ou d'un signal de récompense vérifiable, et le modèle de base est un modèle vision-langage plutôt qu'un modèle texte seul. lora-qlora-recipes couvre la recette LoRA/QLoRA (texte seul) que ce skill spécialise pour la tour de vision et le projecteur ; lisez d'abord ce skill si les fondamentaux de LoRA (rang, alpha, modules cibles) ne vous sont pas familiers.

Entrée : un jeu de données image+texte et un modèle de base VLM déjà sélectionné à partir du catalogue de modèles. Format de sortie : une configuration d'adaptateur validée — quels composants sont gelés, les modules cibles LoRA, et un budget min_pixels/max_pixels — que llm-finetuning-training-engineer consomme directement lorsqu'il génère un script exécutable.

Référence Rapide

SituationValeur par défaut
Adapter le comportement sur des images familièresTour+projecteur gelés, LoRA r=8–16, α=16–32
Changement de domaine visuelDégeler les 6 dernières couches ViT, LR vision 5–10x inférieur
Ne tient pas en bf16 au rang cibleQLoRA — tour de vision gelée uniquement
fast_inference=Truefinetune_vision_layers=False
Perte normale, évaluation ne s'améliore pasVérifier d'abord les Deux Tueurs Silencieux ci-dessous

La Recette Consensuelle

Gelez la tour de vision et le projecteur. Appliquez LoRA uniquement sur le LLM, tous les modules linéaires (la même liste de cibles attention + MLP que pour le SFT texte seul — voir lora-qlora-recipes), avec r=8–16, α=16–32. C'est la valeur par défaut établie pour adapter le comportement d'un VLM sans perturber sa façon de voir.

  • La tour de vision et le projecteur restent gelés par défaut. Ils encodent déjà une représentation visuelle générale ; les réentraîner est rarement nécessaire et ajoute du risque sans apporter de capacité supplémentaire pour la plupart des tâches.
  • Le rang LoRA est plus bas que la valeur par défaut générale pour le texte seul (r=8–16 ici contre r=16–32 pour le SFT texte seul) car l'adaptateur sur le seul LLM adapte le comportement, n'injecte pas de nouvelles connaissances visuelles.
  • QLoRA n'est autorisé qu'avec une tour de vision gelée. Quantifier le modèle de base tout en dégelant et entraînant les couches de vision n'est pas supporté et instable — traitez cela comme une règle de couplage stricte, pas comme un paramètre réglable. Si la tour de vision doit être dégelée, abandonnez QLoRA et utilisez bf16 LoRA à la place.
# geler tour + projecteur ; LoRA sur le LLM uniquement
for name, param in model.named_parameters():
    if "vision_tower" in name or "projector" in name:
        param.requires_grad = False

target_modules = [
    "q_proj", "k_proj", "v_proj", "o_proj",
    "gate_proj", "up_proj", "down_proj",
]  # LLM uniquement, tous linéaires — r=8-16, alpha=16-32

Quand Dégeler

Dégeler les couches de vision est une escalade volontaire, pas une décision par défaut — utilisez-la seulement lorsque le changement de domaine est visuel, pas textuel.

  • Dégeler uniquement pour un changement de domaine visuel. Si la tâche consiste à enseigner un nouveau comportement sur des images que la tour comprend déjà (graphiques, photos du quotidien), la recette avec tour gelée ci-dessus est suffisante. Dégeler lorsque le domaine visuel lui-même est inconnu de la tour — imagerie satellite, scans médicaux, diagrammes techniques denses — et que la recette avec tour gelée plafonne.
  • Les 6 dernières couches ViT sont le point idéal. Dégeler les six dernières couches du transformateur de vision (pas toute la tour) a mesuré +1,7 pt DocVQA à un coût d'entraînement d'environ 1,75x par rapport à la référence gelée. Traitez six couches comme le plafond qui vaut la peine d'être payé ; aller plus loin consomme du calcul sans résultat correspondant.
  • Le LR de la vision doit être 5–10x inférieur au LR du LLM lorsqu'elle est dégelée. La représentation pré-entraînée de la tour de vision est plus fragile que l'adaptateur du LLM ; le même LR pour les deux risque d'écraser la représentation visuelle plus vite que l'adaptateur du LLM ne peut compenser.
  • Un rang LoRA élevé sur la couche d'embedding de patchs risque NaN. Si l'embedding de patchs fait partie de l'ensemble dégelé, gardez son rang bas et surveillez attentivement la perte des premières étapes — c'est l'un des endroits les plus fragiles pour appliquer LoRA dans un VLM.

Les Deux Tueurs Silencieux

Tous deux produisent une exécution qui s'entraîne sans erreur et sans apprentissage : la courbe de perte semble normale, le modèle ne s'améliore pas, et aucun ne lève d'exception — les deux nécessitent une vérification explicite pré-entraînement, et non seulement un journal d'entraînement propre.

  • Décalage image/balise ou compte. Chaque jeton de placeholder d'image dans le texte modélisé doit correspondre 1:1 à un élément média réellement passé au collateur. Un décalage (un placeholder, zéro ou deux images attachées ; ou une image sans placeholder) ne génère pas d'erreur dans la plupart des collateurs — il désaligne silencieusement l'image et le texte, et le modèle « s'entraîne mais n'apprend rien ». Validez le mapping 1:1 placeholder-média avant le début de l'entraînement, sur chaque exemple, pas seulement un échantillon. Détail complet de la liste de validation : references/collators-and-pitfalls.md.
  • Budget de résolution min_pixels/max_pixels. Cette paire est l'hyperparamètre le plus important pour la qualité et la mémoire dans le SFT VLM — plus que le rang, alpha ou LR. Trop bas réduit silencieusement la résolution des images en dessous de ce dont la tâche a besoin (le petit texte de document devient illisible même si l'entraînement « réussit ») ; trop haut fait exploser le budget mémoire d'activation ou force un lot trop petit pour un entraînement stable. Définissez-le délibérément par jeu de données, ne le laissez pas à une valeur par défaut du framework.

Spécificités Unsloth

  • UnslothVisionDataCollator est le collateur qu'Unsloth attend pour le SFT VLM — il gère l'alignement des balises d'image et le contrat du processeur par architecture décrits dans references/collators-and-pitfalls.md. Ne substituez pas un collateur texte seul pour les données VLM.
  • finetune_vision_layers=False est requis lorsque fast_inference=True. vLLM ne peut pas servir les adaptateurs LoRA sur les couches de vision, donc une configuration d'inférence rapide qui dégèle également les couches de vision échoue au moment du service même si l'entraînement réussit. Si la recette nécessite de dégeler les 6 dernières couches ViT (voir Quand Dégeler ci-dessus), l'inférence rapide n'est pas disponible pour cette exécution — choisissez l'une ou l'autre, pas les deux.

Choix du Modèle

Le choix du VLM de base est hors du champ de ce skill — il réside en un seul endroit, le catalogue de modèles dans references/model-catalog.md de finetuning-method-selection. Ce skill et ses références décrivent les recettes par famille d'architecture uniquement, jamais en recommandant un modèle plutôt qu'un autre.

L'apprentissage par renforcement des VLM (VLM-GRPO) est uniquement une référence dans ce plugin — les outils fragmentés et les modes de défaillance par « reward hacking » spécifiques au VLM-RL sont couverts dans grpo-rlvr-training, pas ici. Le champ de ce skill s'arrête au fine-tuning supervisé.

Modes de Défaillance

L'erreur récurrente dans chaque section ci-dessus est de traiter une courbe de perte propre comme une preuve que l'exécution est saine. Une courbe normale peut correspondre à la fois à une exécution fonctionnelle et à l'un ou l'autre des tueurs silencieux, car le modèle s'entraîne sur quelque chose dans les deux cas — simplement pas le signal image-texte aligné lorsqu'un tueur est présent. Un score d'évaluation plat à côté d'une courbe de perte normale signifie relancer la liste de contrôle dans references/collators-and-pitfalls.md avant de toucher à un hyperparamètre.

Références

  • references/collators-and-pitfalls.md — tableau des collateurs par architecture, exemples de format de jeu de données avec placeholders d'image, une liste de validation pré-entraînement, et la recette d'alignement du projecteur en deux étapes comme motif avancé.

Skills connexes : finetuning-method-selection aiguille ici ; lora-qlora-recipes couvre les fondamentaux LoRA (texte seul) que ce skill spécialise ; grpo-rlvr-training couvre VLM-RL (référence uniquement) ; dataset-curation couvre la préparation de jeux de données image+texte que ce skill ne traite pas.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

wshobson/accessibility-compliance

Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Use when auditing accessibility, implementing ARIA patterns, building for screen readers, or ensuring inclusive user experiences.

wshobson/airflow-dag-patterns

Build production Apache Airflow DAGs with best practices for operators, sensors, testing, and deployment. Use when creating data pipelines, orchestrating workflows, or scheduling batch jobs.

wshobson/angular-migration

Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code.

wshobson/anti-reversing-techniques

Understand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use this skill when analyzing malware evasion techniques, when implementing anti-debugging protections for CTF challenges, when reverse engineering packed binaries, or when building security research tools that need to detect virtualized environments.

wshobson/api-design-principles

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

wshobson/architecture-decision-records

Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.

wshobson/architecture-patterns

Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing clean architecture for a new microservice, when refactoring a monolith to use bounded contexts, when implementing hexagonal or onion architecture patterns, or when debugging dependency cycles between application layers.

wshobson/async-python-patterns

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

wshobson/attack-tree-construction

Build comprehensive attack trees to visualize threat paths. Use when mapping attack scenarios, identifying defense gaps, or communicating security risks to stakeholders.

wshobson/auth-implementation-patterns

Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when implementing auth systems, securing APIs, or debugging security issues.

wshobson/avoid-ai-writing

Audit and rewrite prose so it stops reading as machine-generated. Use this skill when asked to remove AI-isms, clean up AI writing, edit a draft for AI tells, audit a README, changelog, release note, PR description, or blog post for machine-sounding prose, or make text sound less like AI. Supports a detect-only mode, a rewrite mode, and an edit-in-place mode, with optional voice and context profiles.

wshobson/backtesting-frameworks

Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.

wshobson/bash-defensive-patterns

Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety.

wshobson/bats-testing-patterns

Master Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring test-driven development of shell utilities.

wshobson/bazel-build-optimization

Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases.

wshobson/before-you-build

Pre-build product and feature risk review for founders, product managers, and AI-assisted builders. Use this skill when the user is about to build a landing page, MVP, SaaS product, internal tool, agent workflow, or major feature and needs to check demand, positioning, monetization, retention, trust, distribution, and adoption risk before implementation starts.

wshobson/billing-automation

Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing, automating invoicing, or managing recurring payment systems.

wshobson/binary-analysis-patterns

Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries.

wshobson/block-no-verify-hook

Configure a PreToolUse hook to prevent AI agents from skipping git pre-commit hooks with --no-verify and other bypass flags. Use when setting up Claude Code projects that enforce commit quality gates.

wshobson/brand-landingpage

Brand-first landing page designer — runs a brand-identity interview (colors, typography, shape language), then generates and iterates on a polished landing page via Stitch with deployment-ready HTML. Use when the user asks to create, design, or build a landing page, homepage, or marketing page and has no established visual direction. Skip when they have a design mockup, need a dashboard or app UI, are working at component level, building a multi-page app, or restyling with known design tokens — use frontend-design instead.

Skills associés