Figure 1 ML
Construisez la figure en SVG manuscrit en quatre phases verrouillées : Plan → Brouillon → Rendu et critique (≤ 3 tours) → Exportation. Ne commencez pas à écrire du SVG avant que le plan existe. Les coordonnées choisies de manière ad hoc sont la cause principale du débordement des étiquettes et des flèches traversant les boîtes, et le lint ainsi que la révision visuelle ne fonctionnent bien que sur la base d'un plan.
SKILL_DIR ci-dessous désigne le répertoire de base de cette compétence. Les scripts s'exécutent hors ligne ; vérifiez le moteur de rendu une fois par session :
python3 "$SKILL_DIR/scripts/render_svg.py" --list-backends
Le script choisit Chromium (Playwright), rsvg-convert, inkscape, cairosvg ou resvg, selon celui qui est installé. Le lint de géométrie exacte nécessite Chromium. Sans lui, les vérifications sont approximatives, alors insistez davantage sur la révision visuelle.
Fichiers de référence (à lire quand la phase le dit)
| Fichier | Lire quand |
|---|---|
references/design-system.md | Phase 1. Il couvre la taille du canevas par conférence, l'espacement de la mise en page, les rôles de palette, les niveaux de typographie, les métaphores de formes, les styles de connecteurs. Ce sont des valeurs par défaut ; adaptez-les quand le contenu l'exige. |
references/svg-primitives.md | Phase 2. Il contient les <defs> à copier-coller (marqueurs, badges, vignettes), les formules de centrage de texte et de connecteurs, et les modèles de formes ML. |
assets/primitives-gallery.png | Optionnel. Une vue rendue de chaque primitive, utile pour choisir des métaphores. |
assets/example-figure1.svg (+ .png) | Optionnel. Une Figure 1 complète et propre (encodeur gelé → module proposé → décodeur + pertes en pointillés) pour copier la structure. |
scripts/svg_geom.py | Utilisez-le à tout moment lorsque vous avez besoin de coordonnées exactes. Il affiche les chemins des connecteurs, les trapèzes, les piles, les grilles et les étiquettes centrées avec une vérification d'ajustement. |
scripts/tex_math.py | Utilisé par render_svg.py pour les mathématiques $…$. Exécutez --paper main.tex --show pour voir la configuration mathématique et les macros extraites de l'article, --test 'c_{FA}' --pt 6 pour composer un extrait. |
Phase 1 : Plan (plan avant tout SVG)
- Extrayez la structure de ce que l'utilisateur a fourni (texte, LaTeX/Markdown de la section Méthodes, code PyTorch
nn.Module) :- les étapes (2–4 groupes qui deviennent les cartes (a), (b), (c)), et les modules à l'intérieur de chacune ;
- quel(s) module(s) sont la contribution de l'article (reçoit la couleur d'accentuation), lesquels sont gelés/pré-entraînés, lesquels sont entraînables ;
- les tenseurs sur le chemin principal avec les dimensions, par ex.
(B, 3, H, W) → (B, N, D), en utilisant les propres symboles de l'article ; - les flux : données avant (trait plein), pertes/supervision (trait pointillé), gradients/rétroaction, connexions sautées, chemins d'inférence seulement vs entraînement seulement.
Depuis le code :
__init__liste les modules,forward()donne l'ordre et les dimensions,requires_grad_(False)/.eval()/torch.no_grad()marque les parties gelées, et les termes de perte proviennent de l'étape d'entraînement. Si la source ne précise pas ce qui est nouveau ou ce qui est gelé, posez une question courte. Sinon, procédez avec des hypothèses raisonnables et énoncez-les.
- Fixez le canevas : la conférence cible et la largeur, et
viewBoxà partir du tableau dansdesign-system.md§2. La valeur par défaut est de 2 unités par pt imprimé, par ex. NeurIPS800 × ~300. - Écrivez le plan dans
<nom>.blueprint.mdà côté de la figure, et résumez-le à l'utilisateur en quelques lignes. Les fichiers vont là où l'utilisateur conserve les figures de l'article (par défaut :figures/dans son projet) :
figure: figure1_overview # racine du fichier
target: neurips # valeur --target de render_svg.py ; viewBox 800 x 300 (2u = 1pt)
flow: left-to-right # ou top-to-bottom / two-row snake
stages: # les plages x des cartes couvrent la largeur avec des espaces ; les cartes partagent une plage y
- id: a
title: "(a) Encodeur gelé"
box: [12, 12, 186, 240] # x, y, l, h
modules:
- {id: img, kind: thumb-patches, box: [28, 120, 40, 40], label: "x", dims: "3×H×W"}
- {id: enc, kind: trapezoid-encoder, role: frozen, badge: frozen, box: [96, 90, 88, 100], inset: 18, label: "Encodeur|Visuel"}
- id: b
# ...
edges:
- {from: img.right, to: enc.left, style: forward, role: data}
- {from: dec.bottom, to: loss.top, style: loss, label: "ŷ"}
colors: {enc: frozen, uam: proposed, dec: train, loss: loss} # rôles de palette depuis design-system.md §4
legend: [forward, loss, frozen, trainable] # seulement les encodages qui nécessitent une explication
notes: "carte proposée ~45% de la largeur ; ligne de base à y = 140"
Vérifications du plan avant de continuer : chaque module a une boîte ; les boîtes à l'intérieur d'une carte laissent ≥ 14u de marge de carte ; les voisins qu'une flèche relie sont distants de ≥ 28u (≥ 40u si la flèche porte une étiquette) ; les largeurs d'étiquette tiennent dans leurs boîtes (svg_geom.py label … indique la marge) ; et la colonne vertébrale (chemin principal) est une ligne droite dans la mesure du possible.
Phase 2 : Brouillon (un SVG autonome)
Lisez references/svg-primitives.md, puis écrivez <nom>.svg :
- Commencez par le squelette et les
<defs>de base (pile de polices, classes de typographie, une pointe de flèche par rôle de palette, badges vectoriels). Ajoutez les définitions de vignettes optionnelles uniquement lorsqu'elles sont utilisées. - Autonome : pas d'images externes, pas de polices web ni
@import, pas de<foreignObject>, pas de scripts, pas d'emoji. Utilisez les badges vectoriels au lieu de ❄️/🔥, car les emoji deviennent des bitmaps ou des tofu dans les PDF. - Ordre de dessin : fond → cartes → arêtes → modules → étiquettes → badges → légende. Les arêtes se placent sous les modules pour que leurs extrémités se glissent sous les bordures.
- Donnez aux modules des identifiants (
id="enc"), aux connecteursclass="edge"etfill="none", et aux mini visuelsdata-lint="ignore". Les messages de lint nomment alors les éléments que vous pouvez trouver. - Calculez les coordonnées avec les formules ou
svg_geom.py, pas à l'œil. La ligne de base du centre du texte estcy + 0,35 × font-size. Les chemins se terminent 2u avant la bordure cible, car la pointe de flèche standard dépasse de 2u. - Les mathématiques sont en LaTeX : écrivez les symboles entre
$…$dans un<text>(scores $S[i,v,p]$,$\mathcal{L}_{\text{KL}}$) dans la notation de l'article. Le script de rendu les compose dans la police mathématique et les macros de l'article (--paper main.tex) et écrit le résultat dans le SVG. Modifiez uniquement le<text>source ; ne simulez jamais les mathématiques avec du texte italique à empattement ou des indices (svg-primitives.md §2).
Phase 3 : Rendu et critique (boucle, max 3 tours)
Chaque tour :
- Rendu et lint :
Avecpython3 "$SKILL_DIR/scripts/render_svg.py" <nom>.svg --target <conférence> [--paper main.tex] # conférence : neurips (défaut), icml, cvpr, …-col, ou 5.5in--paper(nécessaire une fois ; la configuration est stockée dans le SVG) les mathématiques$…$utilisent la police mathématique et les macros de l'article. Cela écrit<nom>.png,<nom>.debug.png(grille de coordonnées plus boîtes numérotées autour de chaque problèmeE#/W#) et<nom>.preview.png(la figure à la taille d'impression), et affiche les erreurs et avertissements avec les coordonnées. - Regardez les images vous-même. Lisez
<nom>.debug.pngd'abord, puis<nom>.preview.png. Le lint ne peut pas juger la composition, donc le passage visuel est obligatoire. - Parcourez la liste de contrôle et écrivez une critique courte : une ligne par défaut, avec la correction en coordonnées.
- Ajustement du texte : aucune étiquette ne touche ni ne croise la bordure de sa boîte ; les étiquettes de module ont ≥ 8u de marge latérale.
- Flèches : aucune ne traverse un module ou une étiquette ; les pointes de flèche touchent les bordures cibles (pas d'écart, pas de perforation) ; pas de croisements évitables ; la direction du flux est évidente.
- Espacement et alignement : espaces égaux entre les éléments frères, les rangées partagent des lignes centrales, les boîtes de même type partagent des tailles, la marge de la carte est uniforme, et aucun coin n'est encombré pendant qu'un autre est vide.
- Lisibilité à l'impression (
preview.png) : le texte le plus petit est encore lisible ; le script signale un minimum ≥ 6pt à la largeur cible ; les traits sont visibles ; les rôles sont distinguables. - Hiérarchie : le module proposé est la première chose que l'œil voit ; les titres d'étape (a)/(b)/(c) sont faciles à parcourir ; une couleur d'accentuation.
- Sémantique : tous les modules et arêtes du plan sont présents et corrects ; trait plein = avant, pointillé = perte ; les badges et la légende correspondent à ce qui est dessiné ; la notation correspond à l'article.
- Corrigez, puis refaites le rendu. Arrêtez-vous lorsqu'il y a 0 erreur et que chaque élément de la liste de contrôle est réussi, ou qu'un avertissement restant est un choix délibéré que vous pouvez justifier (dites lequel, et pourquoi). Les avertissements de lint sont des indices, pas des verdicts : un avertissement que vous avez inspecté et jugé correct ne nécessite aucune modification.
Après le tour 3, arrêtez d'itérer même si des problèmes mineurs persistent, et listez-les dans le rapport.
Phase 4 : Exportation
python3 "$SKILL_DIR/scripts/render_svg.py" <nom>.svg --target <conférence> --export
Cela produit <nom>.pdf (vectoriel, la taille de la page est égale à la largeur imprimée, donc ses tailles de texte sont les vraies tailles imprimées), un <nom>.png haute résolution (3 px/u, ou --dpi 300), et des vérifications PDF : une seule page, polices intégrées, uniquement des polices Type 1 / TrueType (Type 3 est une erreur), aucun contenu tramé, et le PDF correspondant au PNG. Si le moteur de rendu intègre des polices Type 3 pour le texte sans empattement (Chromium fait cela pour les polices CFF telles que Inter .otf ou TeX Gyre .otf, et les vérificateurs de style NeurIPS/ICML les rejettent), ce texte est automatiquement converti en contours vectoriels (--pdf-text auto|fonts|outline). Les mathématiques $…$ sont ensuite estampillées à partir de la sortie pdflatex, de sorte que le PDF contient les vraies polices mathématiques Type 1 (par ex. CMMI6 avec des exposants CMMI5) ; le rapport liste les polices et leurs tailles imprimées. Il supprime également les images de révision. Ensuite, donnez à l'utilisateur :
- les fichiers (source
.svg,.pdfpour LaTeX,.pngpour les diapositives/aperçu) ; - un extrait LaTeX correspondant à la largeur cible :
\begin{figure*}[t] % utilisez figure + \linewidth pour les conférences à une colonne (NeurIPS/ICLR) ou les figures à largeur de colonne \centering \includegraphics[width=\textwidth]{figures/<nom>.pdf} \caption{...}\label{fig:overview} \end{figure*} - un rapport court : la cible et la plus petite taille de police imprimée (et les tailles de base/exposant mathématiques, le cas échéant), les tours de critique effectués et ce qui a changé, et les avertissements acceptés.
Barre de qualité (ce que "terminé" signifie)
- Lisibles à la largeur d'impression : texte ≥ 6pt, au plus 4 tailles de police, épaisseurs de trait ≥ 0.5pt.
- Zéro erreur de lint. Pas de débordement de texte, de chevauchements, d'éléments hors canevas, de références cassées ou d'emoji.
- Chaque flèche commence et se termine sur une bordure, ne traverse jamais un module ou une étiquette, et suit des chemins arrondis orthogonaux.
- Un point focal clair (la contribution), des couleurs de rôle cohérentes, et une légende uniquement pour les encodages non évidents.
- Fidèle à l'article : les noms de modules, les symboles et les dimensions des tenseurs correspondent au texte ou au code. Rien n'est inventé. Signalez toute hypothèse.
- Les mathématiques sont composées par LaTeX dans la police mathématique et la notation de l'article, avec les tailles d'exposant LaTeX (≥ 5pt imprimés).
- Les livrables sont un seul SVG autonome, un PDF vectoriel (polices Type 1/TrueType ou vectorisées, jamais Type 3), et un PNG, tous rendus localement sans API cloud.