Affinage public Encodon

Utilisez --pretrained_ckpt_path pour la v1 publique. Ne remplacez pas --checkpoint_path : le runner public ne transmet pas cet argument à la tâche d'affinage.

Instructions

Résolvez le label cible, le dataset, le checkpoint et le répertoire de sortie à partir de la requête et des fichiers disponibles. Réutilisez les données et poids existants. Pour l'entraînement, vérifiez les dépendances ML du projet et une GPU NVIDIA compatible avant le lancement. Si une ressource requise n'est pas disponible, complétez la préparation des données disponibles et retournez la commande avec le prérequis manquant clairement identifié. Quand l'entraînement est demandé et les prérequis sont satisfaits, exécutez-le et vérifiez les checkpoints et métriques résultants. Une demande de préparation se termine avec les entrées validées et la commande.

Utilisez le dataset étiqueté de l'utilisateur quand il est fourni. Pour une démonstration de régression de séquence sans dataset, utilisez les données publiques RiboNN d'efficacité de traduction ci-dessous et déclarez ce choix. Ce n'est pas un substitut pour l'essai prévu de l'utilisateur ou pour des variants codants étiquetés. Si les labels de variant manquent, retournez le schéma requis et un template de commande rapidement ; ne cherchez pas les labels ou n'inventez pas d'effets mesurés.

Checkpoint de démonstration par défaut : nvidia/NV-CodonFM-Encodon-80M-v1, révision 399ca9fe17b57941a7bebc6788033919b417413c, fichier NV-CodonFM-Encodon-80M-v1.safetensors avec le config.json associé. Les poids publics font environ 307 MB. Téléchargez-les quand nécessaire pour le travail demandé ; la préparation des entrées peut enregistrer un chemin de checkpoint prévu. Ce sont les poids Encodon originaux ; les checkpoints -TE- utilisent l'implémentation TransformerEngine distincte.

Pour une demande Decodon non supportée ou d'agrégation missense, inspectez la configuration publique du parser/modèle, expliquez la fonctionnalité manquante, et terminez. N'implémentez pas le modèle manquant ou ne cherchez pas dans les repositories privés.

Exemples

Préparez un petit exemple avec données publiques avec l'assistant de la stdlib prepare_ribonn.py, en exécutant depuis la racine du repository. Définissez CODONFM_DATA_PATH au CSV que vous voulez créer :

python skills/codonfm-finetune/scripts/prepare_ribonn.py \
    --output "$CODONFM_DATA_PATH"

Avec un fichier brut existant, ajoutez --input "$RIBONN_DATA_PATH". Le défaut lit au maximum huit lignes acceptées par split ; --max-rows-per-split 0 traite l'entrée complète. Le streaming à distance a un budget de temps et pas de rétries automatiques ; utilisez un fichier local s'il échoue. L'assistant suit le découpage CDS dans le notebook RiboNN :

Lisez le .csv en amont avec un délimiteur en tabulation.
Définissez ref_seq = tx_sequence[utr5_size:utr5_size + cds_size], id = transcript_id, et value = mean_te inchangés. Ne prenez pas un autre logarithme.
Préservez les groupes de fold source : 0–7 deviennent train, 8 devient val, 9 devient test. C'est un holdout de démonstration, pas la cross-validation du notebook.
Excluez les lignes invalides/non-finies et les CDSs dépassant 2046 codons au lieu de tronquer silencieusement les exemples étiquetés. Enregistrez les comptes et la source dans le .metadata.json adjacent. Un petit sous-ensemble n'établit pas la performance prédictive.

L'URL du dataset épinglée est dans l'assistant ; sa source est CenikLab/TE_classic_ML. Le notebook extrait les embeddings Encodon gelés et entraîne un régresseur random-forest avec cross-validation basée sur les folds. Cette skill réutilise sa source de données, l'extraction CDS et la cible pour un exemple d'affinage séparé ; elle ne reproduit pas la procédure ou les résultats d'entraînement du notebook.

Stratégies supportées

lora : affinage par adapter ; choix par défaut pour les datasets plus petits.
head_only_random : geler le backbone et entraîner une nouvelle tête.
head_only_pretrained : entraîner une tête pretrained compatible existante.
full : mettre à jour le modèle complet.

Acceptez uniquement encodon_80m, encodon_600m, ou encodon_1b.

Régression ou classification au niveau de la séquence

Requièrent les colonnes id, ref_seq, value, et split. Les colonnes supplémentaires sont autorisées. Mappez les colonnes de l'utilisateur à ce schéma de loader ; l'assistant RiboNN est uniquement pour les données source RiboNN. L'entraînement a besoin de lignes train et, quand la validation est activée, de lignes val. Un split test est nécessaire uniquement pour l'évaluation ultérieure. Les labels dans les splits inutilisés n'ont pas besoin d'être peuplés. Les cibles de régression doivent être des nombres finis ; les cibles de classification doivent être des indices de classe entiers de zéro à num_classes - 1. Utilisez une tête downstream pour les cibles scalaires.

Vérifiez la préparation de séquence en tenant compte de l'essai de l'utilisateur. Le loader convertit l'ARN en majuscules U en T, et le tokenizer met les bases en majuscules. Les bases ambiguës et les codons incomplets peuvent produire des tokens inconnus ; les séquences trop longues sont tronquées. Examinez ces cas plutôt que de silencieusement supprimer les enregistrements utilisateur. Choisissez les batches et un budget d'entraînement appropriés au dataset ; les petits ensembles d'entraînement peuvent être rééchantillonnés par le loader.

Définissez CODONFM_CHECKPOINT_PATH au fichier checkpoint et CODONFM_RUN_DIR à votre répertoire de sortie choisi. Cet exemple exécute dix étapes pour vérifier le workflow ; choisissez le budget d'entraînement pour le dataset et la tâche actuels :

python -m src.runner finetune \
    --exp_name property_finetune \
    --model_name encodon_80m \
    --pretrained_ckpt_path "$CODONFM_CHECKPOINT_PATH" \
    --data_path "$CODONFM_DATA_PATH" \
    --process_item codon_sequence \
    --dataset_name CodonBertDataset \
    --finetune_strategy lora \
    --lora_alpha 32 \
    --lora_r 16 \
    --lora_dropout 0.1 \
    --loss_type regression \
    --use_downstream_head \
    --lr 2e-5 \
    --max_steps 10 \
    --warmup_iterations 1 \
    --check_val_every_n_epoch 1 \
    --train_batch_size 4 \
    --val_batch_size 4 \
    --num_workers 0 \
    --num_nodes 1 \
    --num_gpus 1 \
    --out_dir "$CODONFM_RUN_DIR" \
    --checkpoints_dir "$CODONFM_RUN_DIR/checkpoints"

Pour la classification, remplacez --loss_type regression par --loss_type classification et passez le correct --num_classes.

Classification de variant codant générique

Utilisez MutationDataset uniquement pour une tête de variant étiquetée ordinaire, pas la perte plus récente d'agrégation de codon synonyme. Requièrent id, la colonne de séquence de référence (ref_seq par défaut), ref_codon, alt_codon, codon_position, et la colonne de label choisie. Sélectionnez les colonnes de séquence/label existantes avec --ref_seq_col et --label_col ; ces overrides s'appliquent à MutationDataset uniquement. En partant de la commande au niveau de la séquence, changez/ajoutez :

--process_item mutation_pred_mlm
--dataset_name MutationDataset
--label_col label
--loss_type classification
--num_classes 2
--use_downstream_head
--extract-seq
--mask_mutation
--train_val_test_ratio 0.8 0.1 0.1

Gardez toujours --mask_mutation pour les entrées de variant à codon masqué. Utilisez --extract-seq pour construire le contexte autour d'un variant dans un CDS complet ; les contextes déjà préparés peuvent l'omettre. Choisissez les rapports de split pour le dataset ; un split de test conservé est optionnel pour l'entraînement. La v1 publique réutilise les fichiers train_idx.npy, val_idx.npy, et test_idx.npy existants sans vérifier qu'ils appartiennent au CSV courant. Vérifiez leur provenance avant de les réutiliser.

Exécution et sorties

Vérifiez les données préparées directement contre le schéma du loader sélectionné ci-dessus en utilisant l'inspection CSV ordinaire. Vérifiez les colonnes requises, les labels finis dans les splits utilisés pour l'entraînement, les indices de classe le cas échéant, la préparation de séquence, et les positions de référence de variant. L'assistant RiboNN vérifie sa sortie lors de la préparation. Ces vérifications ne requièrent pas d'installer les dépendances ML de CodonFM. Pour les demandes de préparation, rapportez ce qui a été vérifié et fournissez la commande d'entraînement. Pour les demandes d'exécution, exécutez-la une fois les données, poids et ressources disponibles.

Le runner existant a un flag --dryrun optionnel qui construit la configuration runtime et saute l'exécution. Il requiert les dépendances ML et ne lit pas le dataset ou ne charge les poids. Ce n'est pas une étape de validation des données ou un prérequis pour préparer les entrées et les commandes.

Définissez la fréquence de validation pour la longueur d'entraînement planifiée : pour un petit exemple, --check_val_every_n_epoch 1 ou un --val_check_interval plus petit évite l'intervalle par défaut de la v1 publique de 1 000 batches dépassant une époque.

Les checkpoints sont écrits sous le --checkpoints_dir explicitement fourni, incluant last.ckpt et les meilleurs checkpoints configurés.
Les métriques CSV sont écrites sous --out_dir/<exp_name>/version_* sauf si W&B est activé.
W&B requiert --enable_wandb, --project_name, et --entity ensemble.
L'affinage ne produit pas de tableaux de prédiction ; exécutez une tâche d'évaluation séparément contre le checkpoint résultant.

Limites

N'utilisez pas MissenseDataset, missense_seq, missense_inference, missense_synom_agg, ou tout flag --missense_*. Ils sont absents publiquement.
N'utilisez pas les noms de modèle Decodon, le prétraitement CLM, les tokens d'organisme, ou les datasets de génération.
Requièrez un taux d'apprentissage explicite. La v1 publique passe lr=None sinon.
Traitez la validité scientifique et clinique comme un problème de validation séparé ; un entraînement réussi ne certifie pas le modèle résultant.