sparse_circuit_discovery
v1.3.1
Découverte de circuit dans GPT-2 small , en utilisant un autoencodage clairsemé
Pour installer manuellement, exécutez simplement ces commandes dans le shell:
git clone https://github.com/DavidUdell/sparse_circuit_discovery
cd sparse_circuit_discovery
pip install -e .
Alternativement, j'ai une image Docker sur le registre des conteneurs GitHub. L'image Docker est particulièrement bonne pour se retirer sur un serveur distant.
Votre base d'opérations est sparse_coding/config/central_config.yaml . Les hyperparamètres les plus importants sont regroupés en haut:
# Note: leave out entries for None. Writing in `None` values will get you the
# string "None".
## ------------------------------------------------------------------------- ##
## --------------------------- Key Hyperparameters ------------------------- ##
## ------------------------------------------------------------------------- ##
# ACTS_LAYERS_SLICE should be a Python slice, in str format. Set it to ":" to
# plot data from all model layers.
ACTS_LAYERS_SLICE: "9:12"
INIT_THINNING_FACTOR: 1.0
NUM_SEQUENCES_INTERPED: 1
THRESHOLD_EXP: 5.0
# Only pin single dims per layer. If not set, every ablation effect is plotted.
DIMS_PINNED:
3: [331]
En ordre:
ACTS_LAYERS_SLICE est une tranche de Python formatée sous forme de chaîne. Il définit les couches du GPT-2 small sur lesquelles vous interprétez les activations.INIT_THINNING_FACTOR est la fraction des fonctionnalités au premier calque de votre tranche que vous tracez. Par exemple, une fraction de 1.0 tentera de tracer toutes les fonctionnalités de la couche.NUM_SEQUENCES_INTERPED est le nombre de séquences de jetons utilisées pendant le traçage, dans le but de calculer les effets logit et les effets de fonctionnalité en aval.THRESHOLD_EXP est l'exposant de valeur de seuil pour les différences d'activation tracées. Des différences plus petites dans la magnitude d'activation que 2**THRESHOLD_EXP sont supprimées. Pour tracer tous les effets non nuls, commentez cette ligne.DIMS_PINNED est un dictionnaire des indices de couche suivi des listes de singleton des indices de fonctionnalité. S'il est défini pour la première couche, il remplacera complètement INIT_THINNING_FACTOR . Définissez ces valeurs, enregistrez central_config.yaml , puis exécutez l'interprétabilité avec:
cd sparse_coding
python3 pipe.py
Toutes les données apparaissent dans sparse_coding/data/ .
Le dernier graphique de cognition que vous avez généré est enregistré à la fois comme un .svg pour vous et comme un .dot pour l'ordinateur. Si vous exécutez à nouveau le pipeline d'interprétabilité, les nouvelles données élargiront cet ancien fichier .dot . De cette façon, vous pouvez tracer progressivement les circuits au fur et à mesure.
Il existe également un algorithme basé sur un gradient, une implémentation de Marks et al. (2024). Cet algorithme a l'avantage de tracer des contributions directement à la perte de l'entropie croisée, plutôt que de tracer des contributions aux amplitudes d'activation intermédiaires. Sa mise en œuvre ici s'étend également aux sous-couches de GPT-2, pas seulement au flux résiduel du modèle.
Les hyperparamètres clés ici sont:
ACTS_LAYERS_SLICE fonctionne comme ci-dessus. # Topk thresholds for gradient-based method.
NUM_UP_NODES: 5
NUM_DOWN_NODES: 5
NUM_UP_NODES Corrige le nombre de nœuds sous-couches pour tracer les bords jusqu'à , pour chaque nœud de baisse de sous-maquette. Notez que le nombre de bords est égal deux fois à cette valeur: vous obtiendrez autant de bords supérieurs et de nombreux bords en KNUM_DOWN_NODES corrige le nombre de nœuds sous-couches dont les bords seront ensuite tracés . Enregistrez ces valeurs dans central_config.yaml , puis exécutez l'interprétabilité:
cd sparse_coding
python3 fast.py
Les données apparaissent dans sparse_coding/data/ , comme cela le fait avec l'algorithme naïf.
Ce pipeline d'interprétabilité réduira également les données d'interprétation plus complètes de Neuronpedia et l'a ajouter à chaque nœud, lorsqu'il est disponible.
Ici, vous pouvez également choisir de rendre des graphiques sous forme de fichiers .png . Changez l'extension de GRADS_FILE dans central_config.yaml de .svg à .png pour cela. J'utilise séparément PosterAzor pour imprimer des tuiles, de grands fichiers graphiques .png , lorsqu'une copie physique est souhaitée.
Il existe également un pipeline de validation de circuit indépendant, val.py Ce script ablate simultanément toutes les fonctionnalités qui composent un circuit, pour voir comment le circuit global se comporte sous ablation (plutôt que de simplement regarder des fonctionnalités distinctes sous des ablations indépendantes, la façon dont le fait les graphiques de cognition pipe.py ).
Pour configurer cela, définissez d'abord ACTS_LAYERS_SLICE pour englober les couches pertinentes dans GPT-2 Small, y compris une couche supplémentaire complète après,
ACTS_LAYERS_SLICE: "6:9"
puis épinglez toutes les fonctionnalités qui composent un circuit donné dans VALIDATION_DIMS_PINNED .
# Here you can freely pin multiple dims per layer.
VALIDATION_DIMS_PINNED:
6: [8339, 14104, 18854]
7: [2118]
Maintenant, exécutez la validation avec:
python3 val.py
Définition d'un ensemble de données dans central_config.yaml puis en cours d'exécution:
python3 hist.py
Prévumera cet ensemble de données par activations de neurone-bassin, puis mettra en cache 99,99e centile d'activation du bass de la base autoencoder. Maintenant, Running fast.py utilisera ces seuils mis en cache.
Considérez le graphique de la cognition en haut de cette page. Chaque boîte avec une étiquette comme 4.112 est une fonctionnalité dans un autoencoder clairsemé. 4 est son index de couche, tandis que 112 est son index de colonne dans l'autoencodeur de cette couche. Vous pouvez référencer les données d'interprétation plus complètes pour toute caractéristique donnée sur Neuronpedia.
Les jetons bleus dans les séquences de chaque boîte représentent les activations de fonctions supérieures dans leur contexte, à une longueur spécifiée de chaque côté.
Les jetons bleus et rouges dans des boîtes individuelles en bas sont les logites les plus constituées / les plus pressées par cette dimension. ( Le gris est le cas de bord de l'effet 0,0.)
Les flèches entre les boîtes représentent les effets d'ablation en aval sur d'autres fonctionnalités. Les flèches rouges représentent les flèches de pré-pondération, les flèches bleues (verte dans grad_graph.py ) représentent la pondération et la transparence des flèches représente la magnitude. Par exemple, une flèche rouge pâle est un effet mineur de pondération.
J'ai relâché beaucoup de fonctionnalités de référentiel pour l'instant: seul GPT-2 small et un facteur de projection de 32 sont pris en charge, pour profiter d'un ensemble d'autoencoders clairsemés préexistants.
Si un exactementzoeffectorror est soulevé, vous devez revérifier si votre tranche de couches est compatible avec votre DIM épinglé.
Si vous rencontrez des bogues de variables envisagiques cryptiques, assurez-vous que vous exécutez la boîte à outils CUDA 12.2 ou plus récente.
Comme le suggère la syntaxe de Shell, des chemins de type UNIX (sur macOS ou Linux) sont actuellement nécessaires, et Windows Cheming ne jouera probablement pas bien avec le repo.
fast.py utilise une stratégie d'élagage unique: il faudra AutoEncoder DIMS dans la GPT-2 small finale et en élayant. Vous devez donc commencer par le bas du modèle et tracer progressivement à partir de là.
La version actuelle est 1.3.1
