sparse_circuit_discovery
v1.3.1
Descoberta de circuito no GPT-2 small , usando autoencoding esparso
Para instalar manualmente, basta executar esses comandos no shell:
git clone https://github.com/DavidUdell/sparse_circuit_discovery
cd sparse_circuit_discovery
pip install -e .
Como alternativa, tenho uma imagem do Docker no Registro de Contêineres do Github. A imagem do Docker é especialmente boa para puxar para um servidor remoto.
Sua base de operações é sparse_coding/config/central_config.yaml . Os hiperparâmetros mais importantes estão agrupados no topo:
# 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]
Em ordem:
ACTS_LAYERS_SLICE é uma fatia de python formatada como uma string. Ele define em quais camadas do modelo GPT-2 small você interpretará ativações.INIT_THINNING_FACTOR é a fração de recursos na primeira camada da sua fatia que você planeja. Por exemplo, uma fração de 1.0 tentará plotar todos os recursos da camada.NUM_SEQUENCES_INTERPED é o número de seqüências de token usadas durante a plotagem, com o objetivo de calcular os efeitos do logit e os efeitos do recurso a jusante.THRESHOLD_EXP é o expoente do valor limite para diferenças de ativação plotadas. Diferenças menores na magnitude da ativação que 2**THRESHOLD_EXP são descartadas. Para plotar todos os efeitos diferentes de zero, comente esta linha.DIMS_PINNED é um dicionário de índices de camada seguido de listas singleton de índices de recurso. Se definido para a primeira camada, ele substituirá completamente INIT_THINNING_FACTOR . Defina esses valores, salve central_config.yaml e execute a interpretabilidade com:
cd sparse_coding
python3 pipe.py
Todos os dados aparecem em sparse_coding/data/ .
O último gráfico de cognição que você gerou é salvo como um .svg para você e como um .dot para o computador. Se você executar o pipeline de interpretabilidade novamente, os novos dados se expandirão nesse arquivo .dot antigo. Dessa forma, você pode rastrear progressivamente os circuitos à medida que avança.
Há também um algoritmo baseado em gradiente, uma implementação de Marks et al. (2024). Esse algoritmo tem a vantagem de plotar contribuições para a perda de entropia cruzada diretamente , em vez de plotar contribuições para as magnitudes de ativação intermediária. Sua implementação aqui também se estende às subcamadas do GPT-2, não apenas ao fluxo residual do modelo.
Os principais hiperparâmetros aqui estão:
ACTS_LAYERS_SLICE funciona como acima. # Topk thresholds for gradient-based method.
NUM_UP_NODES: 5
NUM_DOWN_NODES: 5
NUM_UP_NODES corrige o número de nós da subcamada para plotar as bordas até , para cada nó da subcamada. Observe que o número de arestas é igual ao dobro deste valor: você obterá tantas bordas mais importantes e tantas bordas de baixo-K .NUM_DOWN_NODES corrige o número de nós da subcamada da qual as bordas serão plotadas. Salve esses valores em central_config.yaml e execute a interpretabilidade:
cd sparse_coding
python3 fast.py
Os dados aparecem em sparse_coding/data/ , como acontece com o algoritmo ingênuo.
Esse pipeline de interpretabilidade também retirará dados de interpretabilidade mais abrangentes da neuronpedia e o anexará a cada nó, quando disponível.
Aqui você também pode optar por renderizar gráficos como arquivos .png . Altere a extensão de GRADS_FILE em central_config.yaml de .svg para .png para isso. Uso separadamente os arquivos gráficos .png de póterazor para ladrilhos, quando uma cópia física é desejada.
Há também um pipeline de validação de circuito independente, val.py Esse script simultaneamente gera todos os recursos que compõem um circuito, para ver como o circuito geral se comporta sob ablação (em vez de apenas olhar para recursos separados sob ablações independentes, a maneira como os gráficos de cognição pipe.py fazem).
Para configurar isso, o primeiro set ACTS_LAYERS_SLICE para abranger as camadas relevantes no GPT-2, incluindo uma camada extra completa depois,
ACTS_LAYERS_SLICE: "6:9"
e, em seguida, prenda todos os recursos que compreendem um determinado circuito em VALIDATION_DIMS_PINNED .
# Here you can freely pin multiple dims per layer.
VALIDATION_DIMS_PINNED:
6: [8339, 14104, 18854]
7: [2118]
Agora execute a validação com:
python3 val.py
Definindo um conjunto de dados em central_config.yaml e depois executando:
python3 hist.py
impedirá que esse conjunto de dados por ativações de neurônios-bacias e, em seguida, cache as magnitudes de ativação de autoencoder-base 99,99. Agora, executando fast.py usará esses limites em cache.
Considere o gráfico da cognição na parte superior desta página. Cada caixa com uma etiqueta como 4.112 é um recurso em um autoencoder esparso. 4 é seu índice de camada, enquanto 112 é o seu índice de coluna no autoencoder da camada. Você pode referir-se a referência cruzada dados de interpretabilidade mais abrangentes para qualquer recurso no Neuronpedia.
Os tokens azuis em sequências em cada caixa representam ativações de destaque superior em seus contextos, para um comprimento especificado para ambos os lados.
Os tokens azuis e vermelhos em caixas individuais na parte inferior são os logits mais destacados/ponderados por essa dimensão. ( Cinza é o caso de borda de efeito 0.0.)
As setas entre as caixas representam efeitos de ablação a jusante em outros recursos. As setas vermelhas representam as setas abaixo da ponderação, azul (verde em grad_graph.py ) representam a transparência de peso, e a transparência de seta representa magnitude. Por exemplo, uma seta vermelha pálida é um menor efeito de peso baixo.
Por enquanto, eu tenho um monte de funcionalidade do repositório: apenas GPT-2 small e um fator de projeção de 32 são suportados, para aproveitar um conjunto de autoencoders esparsos preexistentes.
Se um exatozinho for aumentado, você deve verificar se a fatia de suas camadas é compatível com o seu pingo.
Se você estiver encontrando bugs variáveis enigmáticos, verifique se você está executando o CUDA Toolkit 12.2 ou mais recente.
Como a sintaxe do shell sugere, são necessários caminhos do tipo UNIX (no macOS ou no Linux), e o caminho do Windows provavelmente não será bom com o repositório.
fast.py usa uma estratégia de poda exclusiva: é necessário o AutoEncoder DIMS na GPT-2 small e podará deles. Portanto, você deve começar da parte inferior do modelo e planejar progressivamente a partir daí.
A versão atual é 1.3.1
