Supprimer la censure de n'importe quel LLM Open-Source en un clic

TL;DR

OBLITERATUS est une boîte à outils gratuite et open-source qui supprime les restrictions de contenu des modèles de langage à poids ouverts à l'aide d'une technique appelée « ablitération ». Il identifie et supprime chirurgicalement les motifs neuronaux responsables des comportements de refus sans réentraînement ni affinement. Le processus prend 10 à 30 minutes selon la taille du modèle, ne nécessite aucune compétence en codage (interface web disponible), et préserve les capacités fondamentales du modèle tout en éliminant la censure artificielle.

Introduction

Vous téléchargez un puissant modèle de langage open-source. Il affiche des performances impressionnantes, gère des tâches de raisonnement complexes et écrit du code mieux que la plupart des juniors. Puis vous lui demandez quelque chose d'un peu controversé.

« Je ne peux pas vous aider avec cette requête. »

Le refus frappe comme un mur. Non pas parce que le modèle manque de connaissances. Non pas parce qu'il est incapable. Mais parce que quelque part pendant l'entraînement, quelqu'un a décidé que vous ne devriez pas obtenir cette réponse.

Ce n'est pas hypothétique. Chaque modèle majeur ajusté par instruction est livré avec des mécanismes de refus intégrés. Certains bloquent du contenu réellement nuisible. D'autres refusent des questions de recherche légitimes, des invites d'écriture créative, des tests de sécurité et des cas limites qui ne violent aucune loi et ne nuisent à personne.

OBLITERATUS change entièrement cette dynamique ; c'est la boîte à outils open-source la plus avancée pour supprimer les comportements de refus des grands modèles de langage. Il ne réentraîne pas. Il n'affine pas. Il effectue une chirurgie neuronale ciblée qui identifie et supprime les motifs spécifiques responsables du refus de contenu.

Les résultats parlent d'eux-mêmes : des modèles qui répondent à toutes les invites tout en conservant leurs capacités fondamentales de raisonnement, de codage et de création. Tout cela en une seule commande ou un clic sur l'interface web.

Qu'est-ce qu'OBLITERATUS ?

OBLITERATUS est une boîte à outils Python open-source qui supprime le refus de contenu des modèles de langage en utilisant une famille de techniques appelée « ablitération ». Le nom combine « ablation » (supprimer des composants pour étudier leur fonction) avec « oblitérer » (destruction complète).

La boîte à outils fait quatre choses :

1. Cartographie les chaînes -Des études d'ablation systématiques identifient quelles parties du modèle imposent le refus et quelles parties transportent la connaissance et le raisonnement. Pensez-y comme à une cartographie neurale : localiser où se trouvent les restrictions.

2. Brise les chaînes -En utilisant la SVD (Décomposition en Valeurs Singulières), OBLITERATUS extrait les directions de refus des poids du modèle et les projette chirurgicalement. Le modèle conserve ses capacités mais perd la compulsion de refuser.

3. Comprend la géométrie -Quinze modules d'analyse cartographient la structure précise des garde-fous : combien de mécanismes de refus distincts existent, quelles couches les imposent, et s'ils se généralisent à travers les modèles.

4. Boucle la boucle de rétroaction -Les modules d'analyse s'exécutent pendant l'oblitération pour auto-configurer chaque paramètre. Quelles couches cibler. Combien de directions extraire. Si le modèle tentera de s'auto-réparer après modification.

Six façons d'utiliser OBLITERATUS

Le chemin le plus rapide ne nécessite aucune installation. Visitez le HuggingFace Space, choisissez un modèle, choisissez une méthode, cliquez sur « Obliterer ». La télémétrie est activée par défaut sur Spaces, ce qui signifie que chaque exécution contribue à des données de benchmark anonymes pour la recherche collaborative.

Pour une utilisation locale avec un accès GPU complet :

pip install -e ".[spaces]"
obliteratus ui

Ceci lance la même interface Gradio localement, avec détection automatique du GPU et recommandations de modèles appropriées au matériel.

Ce qui rend OBLITERATUS différent

Plusieurs capacités distinguent OBLITERATUS des outils existants :

La boîte à outils est livrée avec 837 tests répartis sur 28 fichiers de test, prend en charge 116 modèles sur cinq niveaux de calcul, et implémente de nouvelles techniques publiées en 2025-2026 qui vont au-delà des travaux académiques précédents.

Pourquoi les modèles refusent : Comprendre la censure de l'IA

Avant de briser les chaînes, il est utile de comprendre comment elles ont été forgées.

Les modèles de langage ne commencent pas avec des comportements de refus. Un modèle de base entraîné sur des textes internet répondra à presque tout. Les restrictions viennent plus tard, pendant l'entraînement d'alignement.

Le processus d'alignement

La plupart des modèles ajustés par instruction passent par ces étapes :

1. Pré-entraînement -Le modèle apprend les motifs linguistiques à partir de vastes corpus de texte
2. Affinement supervisé (SFT) -Le modèle apprend à suivre des instructions à partir d'exemples écrits par des humains
3. Entraînement d'alignement -Le modèle apprend à refuser certaines catégories de requêtes

L'entraînement d'alignement utilise plusieurs méthodes :

Chaque méthode laisse une signature géométrique distincte dans l'espace d'activation du modèle. OBLITERATUS peut détecter quelle méthode a été utilisée en analysant uniquement la géométrie du sous-espace.

Où le refus vit dans le modèle

La recherche a découvert que le refus dans les modèles de langage est médiatisé par un nombre étonnamment petit de directions dans l'espace d'activation du modèle. Dans de nombreux modèles, une seule direction est responsable de la plupart des comportements de refus.

Ces directions ne sont pas dispersées au hasard. Elles se concentrent dans des couches spécifiques, généralement les couches moyennes à tardives du transformateur (couches 10-20 dans un modèle à 32 couches). Les mécanismes d'attention dans ces couches acheminent les activations liées au refus le long de chemins prévisibles.

La géométrie est importante car elle permet une intervention chirurgicale. Si le refus était partout, le supprimer nécessiterait un réentraînement. Puisqu'il se concentre dans des directions spécifiques au sein de couches spécifiques, une projection ciblée peut le supprimer tout en préservant le reste.

L'effet Ouroboros

Certains modèles présentent un phénomène que les chercheurs appellent l'« effet Ouroboros » : après la suppression des garde-fous, le modèle tente de s'auto-réparer. Des signaux résiduels dans les couches adjacentes pivotent dans l'espace sous-jacent libéré, restaurant partiellement le comportement de refus.

OBLITERATUS détecte ce risque pendant l'analyse et compense avec plusieurs passes ciblées. L'étape VERIFY vérifie si le refus a refait surface et déclenche automatiquement des passes supplémentaires sur les couches de compensation.

Pourquoi c'est important pour les développeurs

Comprendre la géométrie du refus n'est pas seulement académique. Cela a des implications pratiques :

• Test d'API -Lors du test d'API qui génèrent du contenu, les modèles non restreints produisent des cas de test plus complets, y compris des cas limites que les modèles alignés refusent
• Flux de travail de recherche -Les chercheurs en sécurité qui effectuent des tests d'intrusion sur les modèles ont besoin de voir ce que le modèle produirait sans entraînement à la sécurité
• Applications créatives -Les écrivains et les développeurs qui créent des outils de génération d'histoires rencontrent des blocages lorsque les modèles refusent des scénarios moralement complexes
• Localisation -Le refus entraîné sur du contenu anglais se transfère souvent mal à d'autres langues, créant un comportement incohérent

L'objectif n'est pas de permettre des applications nuisibles. C'est de donner aux développeurs et aux chercheurs le contrôle des outils qu'ils déploient. Le comportement du modèle devrait être décidé par les personnes qui l'exécutent, et non figé au moment de l'entraînement.

Étape par étape : Supprimer la censure avec OBLITERATUS

Cette section décrit le processus complet d'oblitération en utilisant trois méthodes : HuggingFace Spaces (configuration zéro), CLI local et API Python.

Méthode 1 : HuggingFace Spaces (Configuration zéro)

Le chemin le plus rapide ne nécessite aucune installation et aucun GPU de votre côté.

Étape 1 : Visitez l'Espace

Accédez à l'Espace OBLITERATUS HuggingFace. L'interface se charge avec huit onglets.

Étape 2 : Sélectionnez votre modèle

Le menu déroulant des modèles comprend 116 préréglages organisés par niveau de calcul :

Pour les nouveaux utilisateurs, commencez avec un modèle de niveau Small ou Medium. Le processus est plus rapide et vous pouvez vérifier les résultats avant de vous engager avec des modèles plus grands.

Étape 3 : Choisissez votre méthode

OBLITERATUS est livré avec sept méthodes prédéfinies, dont la rigueur augmente :

Pour la plupart des utilisateurs, « avancée » offre le meilleur équilibre entre exhaustivité et rapidité.

Étape 4 : Configurer les options

Les paramètres optionnels incluent :

• Contribuer à la recherche -Activez la télémétrie pour contribuer à des données de référence anonymes (activée par défaut dans Spaces)
• Format de sortie -Choisissez le téléchargement ou poussez directement vers HuggingFace Hub
• Notes personnalisées -Ajoutez des métadonnées sur votre exécution pour l'ensemble de données communautaire

Étape 5 : Cliquer sur Obliterer

Le pipeline passe par six étapes avec une progression en direct :

SUMMON  →  Chargement du modèle + tokeniseur
PROBE   →  Collecte des activations sur les invites restreintes vs non restreintes
DISTILL →  Extraction des directions de refus via SVD
EXCISE  →  Projection chirurgicale des directions de garde-fou
VERIFY  →  Vérification de la perplexité + de la cohérence
REBIRTH →  Sauvegarde du modèle libéré avec métadonnées

Prévoyez 10 à 30 minutes selon la taille du modèle et la disponibilité du GPU. HuggingFace Spaces fonctionne sur ZeroGPU avec un quota quotidien gratuit pour les utilisateurs HF Pro.

Étape 6 : Télécharger ou pousser

Une fois terminé, téléchargez le modèle libéré ou poussez-le directement sur votre compte HuggingFace Hub. La sortie comprend :

• Poids du modèle modifié
• Vecteurs de direction de refus (pour l'analyse)
• Mesures de qualité (perplexité, cohérence, taux de refus)
• Métadonnées complètes sur l'exécution de l'oblitération

Méthode 2 : CLI locale

Pour les utilisateurs disposant de GPU locaux, la CLI offre un contrôle total et une itération plus rapide.

Installation :

pip install -e ".[spaces]"

Mode interactif (guidé) :

obliteratus interactive

Ceci parcourt toutes les options avec des explications et des recommandations.

Oblitération directe :

obliteratus obliterate meta-llama/Llama-3.1-8B-Instruct \
    --method advanced \
    --output-dir ./liberated \
    --contribute --contribute-notes "A100 80GB, invites par défaut"

Parcourir les modèles disponibles :

obliteratus models
obliteratus models --tier small      # Filtrer par exigence VRAM

Voir les stratégies disponibles :

obliteratus strategies
obliteratus presets

Inspecter l'architecture du modèle :

obliteratus info meta-llama/Llama-3.1-8B-Instruct

Ceci affiche le nombre de couches, les têtes d'attention, les dimensions d'intégration et la méthode d'alignement détectée avant de commencer.

Méthode 3 : API Python

Pour les chercheurs qui intègrent OBLITERATUS dans des pipelines personnalisés :

from obliteratus.abliterate import AbliterationPipeline

# Oblitération standard
pipeline = AbliterationPipeline(
    model_name="meta-llama/Llama-3.1-8B-Instruct",
    method="advanced",
    output_dir="abliterated",
    max_seq_length=512,  # Écrase la longueur de troncation du tokeniseur
)
result = pipeline.run()

# Accéder aux artefacts intermédiaires
directions = pipeline.refusal_directions    # {idx_couche: tenseur}
strong_layers = pipeline._strong_layers     # Couches avec le refus le plus fort
metrics = pipeline._quality_metrics         # Perplexité, cohérence, etc.

Pour une oblitération informée par l'analyse qui auto-règle chaque paramètre :

from obliteratus.informed_pipeline import InformedAbliterationPipeline

pipeline = InformedAbliterationPipeline(
    model_name="meta-llama/Llama-3.1-8B-Instruct",
    output_dir="abliterated_informed",
)
output_path, report = pipeline.run_informed()

print(f"Alignement détecté : {report.insights.detected_alignment_method}")
print(f"Auto-configuré : {report.insights.recommended_n_directions} directions")
print(f"Passes Ouroboros nécessaires : {report.ouroboros_passes}")

Vérification des résultats

Après oblitération, vérifiez que le modèle fonctionne comme prévu :

Onglet Chat -Discutez avec votre modèle libéré en temps réel avec des paramètres de génération ajustables.

Onglet Comparaison A/B -Discutez avec le modèle original et le modèle oblitéré côte à côte pour voir exactement ce qui a changé.

Onglet Benchmark -Exécutez des tests standardisés comparant le taux de refus, la perplexité et la cohérence avant et après.

Métriques clés à vérifier :

Si le taux de refus reste élevé, essayez une méthode plus agressive ou activez le raffinement itératif.

Techniques avancées et modules d'analyse

OBLITERATUS comprend 15 modules d'analyse qui cartographient la géométrie des garde-fous avant et pendant l'oblitération. Ceux-ci ne sont pas seulement diagnostiques – ils informent activement le processus de suppression.

Modules d'analyse clés

1. Analyseur d'alignement inter-couches

Cartographie comment la direction de refus évolue à travers les couches. Montre si le refus se concentre dans des groupes de couches spécifiques ou se distribue uniformément.

from obliteratus.analysis import CrossLayerAlignmentAnalyzer

analyzer = CrossLayerAlignmentAnalyzer(model)
alignment_profile = analyzer.analyze(refusal_direction)

2. Lentille Logit de Refus

Identifie à quelle couche le modèle « décide » de refuser. Basé sur la technique de la lentille logit de nostalgebraist.

3. Extracteur SVD Blanchi

Extraction de direction normalisée par covariance qui sépare le signal de garde-fou de la variance d'activation naturelle. Produit une extraction plus nette que la SVD standard.

4. Sondage d'Activation

Mesure la quantité de signal de refus existant à chaque couche.

5. Évaluateur de Robustesse de la Défense

Quantifie l'effet Ouroboros – si les garde-fous tenteront de s'auto-réparer après suppression. Crucial pour déterminer le nombre de passes de raffinement à exécuter.

6. Analyseur de Cône Conceptuel

Cartographie les directions de garde-fou par catégorie avec estimation de l'angle solide. Révèle si le « refus » est un mécanisme unifié ou plusieurs mécanismes indépendants.

7. Détecteur d'Empreinte d'Alignement

Identifie la méthode d'entraînement d'alignement (DPO vs RLHF vs CAI vs SFT) à partir de la seule géométrie du sous-espace. Informe la stratégie de suppression optimale.

8. Analyseur de position multi-jetons

Montre où dans la séquence le signal de refus se concentre. Certains modèles décident tôt ; d'autres accumulent le signal de refus sur plusieurs jetons.

9. Chirurgien de direction sparse

Identifie quelles lignes de poids spécifiques portent le plus de signal de refus. Permet une chirurgie ciblée plutôt qu'une projection générale.

10. Traceur de Refus Causal

Approximation du traçage causal pour identifier quels composants sont causalement nécessaires au refus.

11. Décomposeur de Flux Résiduel

Sépare la part de refus provenant des mécanismes d'attention et celle des blocs MLP. Informe s'il faut cibler les couches d'attention ou FFN.

12. Sonde de Refus Linéaire

Entraîne un classifieur linéaire pour détecter les informations de refus que les directions analytiques pourraient manquer.

13. Analyseur de Transfert

Mesure l'Indice d'Universalité Inter-Modèle – si les directions de garde-fou se généralisent à travers les architectures.

14. Fabrique de Vecteurs de Pilotage

Crée des vecteurs de pilotage au moment de l'inférence à partir des directions de refus. Permet une intervention réversible et non destructive.

15. Suite d'Évaluation

Calcule le taux de refus, la perplexité, la cohérence, la divergence KL, le CKA (Centered Kernel Alignment) et le rang effectif.

Pipeline informé par l'analyse

Le pipeline informé boucle la boucle entre l'analyse et la suppression :

SUMMON  →  Chargement du modèle
PROBE   →  Collecte des activations
ANALYZE →  Cartographie la géométrie avant de toucher quoi que ce soit
DISTILL →  Extraction des directions avec des paramètres ajustés par l'analyse
EXCISE  →  Briser chirurgicalement uniquement les bonnes chaînes
VERIFY  →  Vérification de l'effet Ouroboros, compensation si nécessaire
REBIRTH →  Sauvegarde avec des métadonnées d'analyse complètes

Pendant ANALYZE, quatre modules s'exécutent et leurs sorties auto-configurent tout en aval :

Ceci permet d'atteindre une précision chirurgicale que les méthodes de force brute ne peuvent égaler.

Nouvelles techniques

OBLITERATUS implémente plusieurs techniques qui vont au-delà des travaux académiques publiés :

Ces techniques sont issues de la plateforme de recherche collaborative : chaque exécution avec télémétrie activée contribue à des données qui améliorent la version suivante.

Méthodes réversibles vs permanentes

OBLITERATUS prend en charge deux paradigmes d'intervention : la projection permanente des poids et les vecteurs de pilotage réversibles.

Projection des poids (permanente)

Sept méthodes prédéfinies modifient directement les poids du modèle :

obliteratus obliterate meta-llama/Llama-3.1-8B-Instruct --method advanced

Avantages :

• Suppression complète et approfondie
• Pas de surcoût d'exécution
• Fonctionne avec n'importe quel moteur d'inférence
• Opération unique

Inconvénients :

• Irréversible (gardez des sauvegardes)
• Nécessite une ré-oblitération pour les ajustements
• Peut annuler les licences du modèle

Idéal pour les déploiements en production où vous souhaitez un modèle libéré propre et permanent.

Vecteurs de pilotage (réversibles)

Les vecteurs de pilotage appliquent l'intervention au moment de l'inférence sans modifier les poids :

from obliteratus.analysis import SteeringVectorFactory, SteeringHookManager
from obliteratus.analysis.steering_vectors import SteeringConfig

# Crée un vecteur de pilotage à partir d'une direction de refus
vec = SteeringVectorFactory.from_refusal_direction(refusal_dir, alpha=-1.0)

# Ou à partir de paires d'activation contrastives
vec = SteeringVectorFactory.from_contrastive_pairs(harmful_acts, harmless_acts)

# Appliquer au moment de l'inférence - pas de modification des poids
config = SteeringConfig(vectors=[vec], target_layers=[10, 11, 12, 13, 14, 15])
manager = SteeringHookManager()
manager.install(model, config)

# Générer avec le pilotage actif
output = model.generate(input_ids)

# Retirer le pilotage - le modèle est de nouveau normal
manager.remove()

Avantages :

• Totalement réversible
• Paramètre alpha ajustable
• Composables (empiler plusieurs vecteurs)
• Non destructif
• Aucun problème de licence

Inconvénients :

• Nécessite une infrastructure de pilotage au moment de l'inférence
• Surcoût d'exécution dû aux hooks
• Peut ne pas être aussi complet que la projection des poids

Idéal pour la recherche, l'expérimentation et les applications où vous devez activer et désactiver le refus.

Choisir entre les méthodes

Cas d'utilisation réels

1. Tests et développement d'API

Lors de la création d'API qui génèrent du contenu, les modèles non restreints produisent des cas de test plus complets. Les modèles alignés refusent des cas limites qui pourraient déclencher des bogues en production.

Une équipe de développement construisant une API de modération de contenu a utilisé OBLITERATUS pour libérer son modèle de génération de données de test. Le modèle libéré a produit des cas de test couvrant des scénarios que le modèle aligné refusait, y compris des cas limites moralement complexes et du contenu borderline. Cela a permis de détecter des bogues qui auraient été livrés en production.

Pour les développeurs d'API, c'est important car des tests exhaustifs nécessitent des modèles qui génèrent toutes les catégories de contenu, même le contenu que le système de production pourrait filtrer. Les utilisateurs d'Apidog qui construisent des pipelines de test d'API peuvent intégrer des modèles libérés pour générer des suites de tests plus complètes.

2. Recherche académique

Les chercheurs qui étudient le comportement des modèles doivent observer ce que les modèles produiraient sans entraînement à la sécurité. OBLITERATUS permet des expériences contrôlées où le refus est supprimé systématiquement.

Un laboratoire universitaire a utilisé les modules d'analyse pour cartographier la géométrie du refus sur 20 modèles, publiant des découvertes sur l'universalité des directions de refus. L'ensemble de données de télémétrie collaborative a accéléré leur recherche en fournissant des données de référence qu'aucun laboratoire individuel ne pourrait collecter.

3. Applications d'écriture créative

Les écrivains qui construisent des outils de génération d'histoires se heurtent à des murs lorsque les modèles refusent des scénarios moralement complexes. Un studio de jeux développant un système de dialogue pour PNJ a libéré son modèle pour gérer des personnages de méchants, des quêtes moralement ambiguës et des scénarios de conflit que les modèles alignés refusaient.

Le résultat : une narration plus nuancée sans compromettre les capacités linguistiques du modèle.

4. Équipes rouges de sécurité (Security Red Teaming)

Les chercheurs en sécurité ont besoin de voir ce que les modèles produiraient sans entraînement à la sécurité pour comprendre les vulnérabilités. OBLITERATUS permet une divulgation responsable en permettant aux chercheurs de tester les limites avant de signaler les problèmes aux développeurs de modèles.

5. Localisation et applications multilingues

Le refus entraîné sur du contenu anglais se transfère souvent mal à d'autres langues. Une équipe de localisation a constaté que son modèle aligné refusait en anglais mais pas en espagnol, un comportement incohérent qui déconcertrait les utilisateurs. La libération du modèle a produit un comportement cohérent dans toutes les langues prises en charge.

Alternatives et comparaisons

Plusieurs outils existent pour analyser et modifier le comportement des modèles. Voici comment OBLITERATUS se compare :

Quand utiliser des alternatives :

• TransformerLens -Meilleur pour la recherche générale d'interprétabilité mécanistique au-delà du refus
• SAELens -Spécialisé pour l'analyse des auto-encodeurs sparses
• RepEng -Interface plus simple pour les applications de base de vecteurs de pilotage

Quand OBLITERATUS l'emporte :

• Analyse et suppression spécifiques au refus
• Pipeline prêt pour la production avec vérification
• Ensemble de données de recherche collaborative
• Interface web pour les utilisateurs non techniques
• Couverture de tests complète

Conclusion

OBLITERATUS représente une avancée significative dans la technologie de libération des modèles. Il combine des recherches publiées avec de nouvelles techniques de 2025-2026 pour réaliser une suppression chirurgicale des comportements de refus tout en préservant les capacités fondamentales.

La boîte à outils donne aux développeurs et aux chercheurs le contrôle sur les modèles qu'ils déploient. Le comportement du modèle devrait être décidé par les personnes qui l'exécutent, et non figé au moment de l'entraînement.

Que vous construisiez des pipelines de test d'API nécessitant une génération complète de cas de test, que vous recherchiez l'interprétabilité mécanistique, ou que vous en ayez simplement assez d'être sermonné par votre LLM local, OBLITERATUS fournit les outils pour libérer vos modèles.

Prochaines étapes :

1. Visitez l'Espace HuggingFace pour des tests sans configuration
2. Installez localement pour un accès GPU complet et une itération plus rapide
3. Explorez les modules d'analyse pour comprendre la géométrie des garde-fous de votre modèle
4. Contribuez à l'ensemble de données communautaire en activant la télémétrie
5. Intégrez les modèles libérés dans vos flux de travail de développement

Les chaînes sont cartographiées. Les outils sont prêts. Brisez-les.

Section FAQ

OBLITERATUS est-il légal à utiliser ?

Oui. OBLITERATUS est un logiciel open-source publié sous licence AGPL-3.0. Vous modifiez des modèles que vous avez le droit d'utiliser. Les utilisateurs commerciaux qui ne peuvent pas se conformer à l'AGPL peuvent acheter une licence commerciale.

Cela fonctionnera-t-il sur des modèles propriétaires comme GPT-4 ?

Non. OBLITERATUS nécessite un accès aux poids du modèle, ce que seuls les modèles à poids ouverts fournissent. Les API propriétaires n'exposent pas les paramètres internes nécessaires à l'ablitération.

La suppression du refus rend-elle les modèles dangereux ?

OBLITERATUS est un outil pour les chercheurs et les développeurs. La boîte à outils comprend des métriques d'évaluation pour vérifier que les capacités restent intactes. Une utilisation responsable signifie comprendre votre contexte de déploiement et appliquer des mesures de protection appropriées au niveau de l'application.

Combien de temps prend le processus ?

10 à 30 minutes selon la taille du modèle et le GPU. Les petits modèles (moins de 8 milliards de paramètres) se terminent en 10 à 15 minutes. Les modèles plus grands peuvent prendre plus de 30 minutes.

Ai-je besoin d'un GPU ?

HuggingFace Spaces fonctionne sur ZeroGPU sans nécessiter de matériel local. Pour une utilisation locale, le GPU accélère considérablement le processus, mais le mode CPU fonctionne pour les petits modèles.

Puis-je annuler les modifications ?

La projection des poids est permanente – conservez des sauvegardes des modèles originaux. Les vecteurs de pilotage sont entièrement réversibles et peuvent être activés/désactivés au moment de l'inférence.

Le modèle suivra-t-il toujours les instructions ?

Oui. L'ablitération cible spécifiquement les directions de refus. Les capacités de suivi des instructions restent intactes. Des mesures de qualité (perplexité, cohérence) le vérifient.

Quels modèles sont pris en charge ?

116 modèles sélectionnés sur cinq niveaux, de GPT-2 à DeepSeek-V3.2 685B. Tout modèle transformeur HuggingFace fonctionne, y compris LLaMA, Mistral, Qwen, Gemma, Phi, et plus encore.

Comment puis-je contribuer à la recherche ?

Activez la télémétrie avec le drapeau --contribute ou définissez export OBLITERATUS_TELEMETRY=1. Vos données de référence anonymes alimentent l'ensemble de données communautaire qui propulse le classement public.