{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Đào tạo bộ mã hóa tự động thưa thớt

Cung cấp hướng dẫn đào tạo và phân tích Bộ mã hóa tự động thưa thớt (SAE) bằng cách sử dụng SAELens để phân tách các hoạt động kích hoạt mạng thần kinh thành các tính năng có thể hiểu được. Sử dụng khi khám phá các đặc điểm có thể hiểu được, phân tích sự chồng chất hoặc nghiên cứu các cách biểu diễn đơn ngữ trong các mô hình ngôn ngữ.

Siêu dữ liệu kỹ năng

Nguồn	Tùy chọn — cài đặt với
`Hermes skills install official/mlops/saelens
`
Đường dẫn

optional-skills/mlops/saelens ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

sae-lens>=6.0.0

, `transformer-lens>=2.0.0

, torch>=2.0.0 | | Nền tảng | Linux, macOS, Windows | | Thẻ |

Sparse Autoencoders

, `SAE

, `Mechanistic Interpretability

, `Feature Discovery

, Superposition |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

SAELens: Bộ mã hóa tự động thưa thớt cho khả năng diễn giải cơ học

SAELens là thư viện chính để đào tạo và phân tích Bộ mã hóa tự động thưa thớt (SAE) - một kỹ thuật phân tách các kích hoạt mạng thần kinh đa nghĩa thành các tính năng thưa thớt, có thể hiểu được. Dựa trên nghiên cứu đột phá của Anthropic về tính đơn nghĩa.

GitHub: jbloomAus/SAELens (1.100+ sao)

Vấn đề: Đa ngữ nghĩa và chồng chất

Các nơ-ron riêng lẻ trong mạng nơ-ron là đa nghĩa - chúng kích hoạt trong nhiều bối cảnh khác biệt về mặt ngữ nghĩa. Điều này xảy ra vì các mô hình sử dụng chồng chất để thể hiện nhiều tính năng hơn số nơ-ron mà chúng có, khiến cho việc diễn giải trở nên khó khăn.

SAE giải quyết vấn đề này bằng cách phân tách các kích hoạt dày đặc thành các tính năng đơn ngữ, thưa thớt - thường chỉ một số lượng nhỏ tính năng kích hoạt cho bất kỳ đầu vào nhất định nào và mỗi tính năng tương ứng với một khái niệm có thể hiểu được.

Khi nào nên sử dụng SAELens`Sử dụng SAELens khi bạn cần:

• Khám phá các tính năng có thể giải thích được khi kích hoạt mô hình
• Hiểu những khái niệm mà người mẫu đã học
• Nghiên cứu sự chồng chất và hình học đặc trưng
• Thực hiện chỉ đạo hoặc cắt bỏ dựa trên tính năng
• Phân tích các tính năng liên quan đến an toàn (lừa dối, thiên vị, nội dung có hại)

Cân nhắc các lựa chọn thay thế khi:

• Bạn cần phân tích kích hoạt cơ bản → Sử dụng trực tiếp TransformerLens
• Bạn muốn thử nghiệm can thiệp nhân quả → Sử dụng pyvene hoặc TransformerLens
• Bạn cần chỉ đạo sản xuất → Xem xét kỹ thuật kích hoạt trực tiếp

Cài đặt

pip install sae-lens

`
``Yêu cầu: Python 3.10+, ống kính biến áp>=2.0.0

## Khái niệm cốt lõi

### SAE học được gì

SAE được đào tạo để tái cấu trúc kích hoạt mô hình thông qua nút cổ chai thưa thớt:

`
Input Activation → Encoder → Sparse Features → Decoder → Reconstructed Activation
    (d_model)       ↓        (d_sae >> d_model)    ↓         (d_model)
                 sparsity                      reconstruction
                 penalty                          loss

`
``**Hàm mất**: 
`MSE(original, reconstructed) + L1_coefficient × L1(features)

### Xác thực khóa (Nghiên cứu nhân chủng học)

Trong "Hướng tới tính đơn nghĩa", những người đánh giá con người nhận thấy **70% tính năng SAE có thể diễn giải thực sự**. Các tính năng được phát hiện bao gồm:

- Trình tự DNA, ngôn ngữ pháp lý, yêu cầu HTTP
- Văn bản tiếng Do Thái, báo cáo dinh dưỡng, cú pháp mã
- Tình cảm, tên gọi thực thể, cấu trúc ngữ pháp

## Quy trình làm việc 1: Tải và phân tích SAE được đào tạo trước

### Từng bước

``` python
from transformer_lens import HookedTransformer
from sae_lens import SAE

# 1. Load model and pre-trained SAE
model = HookedTransformer.from_pretrained("GPT2-small", device="cuda")
sae, cfg_dict, sparsity = SAE.from_pretrained(
    release="GPT2-small-res-jb",
    sae_id="blocks.8.hook_resid_pre",
    device="cuda"
)

# 2. Get model activations
tokens = model.to_tokens("The cAPItal of France is Paris")
_, cache = model.run_with_cache(tokens)
activations = cache["resid_pre", 8]  # [batch, pos, d_model]

# 3. Encode to SAE features
sae_features = sae.encode(activations)  # [batch, pos, d_sae]
print(f"Active features: \{(sae_features > 0).sum()}")

# 4. Find top features for each position
for pos in range(tokens.shape[1]):
    top_features = sae_features[0, pos].topk(5)
    token = model.to_str_tokens(tokens[0, pos:pos+1])[0]
    print(f"Token '\{token}': features \{top_features.indices.tolist()}")

# 5. Reconstruct activations
reconstructed = sae.decode(sae_features)
reconstruction_error = (activations - reconstructed).norm()

`

### Có sẵn các SAE được đào tạo trước

| Phát hành | Người mẫu | Lớp |
|----------|-------|--------|
| 
`GPT2-small-res-jb
` | GPT-2 Nhỏ | Nhiều luồng dư |
| 
`gemma-2b-res
` | Gemma 2B | Luồng dư |
| Khác nhau trên HuggingFace | Từ khóa tìm kiếm 
`saelens
` | Khác nhau |

### Danh sách kiểm tra

- [ ] Tải mô hình bằng TransformerLens
- [ ] Tải SAE phù hợp cho lớp mục tiêu
- [ ] Mã hóa kích hoạt thành các tính năng thưa thớt
- [ ] Xác định các tính năng kích hoạt hàng đầu trên mỗi mã thông báo
- [] Xác nhận chất lượng tái thiết

## Quy trình làm việc 2: Đào tạo SAE tùy chỉnh

### Từng bước

``` python
from sae_lens import SAE, LanguageModelSAERunnerConfig, SAETrainingRunner

# 1. Configure training
cfg = LanguageModelSAERunnerConfig(

    # Model
    model_name="GPT2-small",
    hook_name="blocks.8.hook_resid_pre",
    hook_layer=8,
    d_in=768,  # Model dimension

# SAE architecture
    architecture="standard",  # or "gated", "topk"
    d_sae=768 * 8,  # Expansion factor of 8
    activation_fn="relu",

# Training
    lr=4e-4,
    l1_coefficient=8e-5,  # Sparsity penalty
    l1_warm_up_steps=1000,
    train_batch_size_tokens=4096,
    training_tokens=100_000_000,

# Data
    dataset_path="monology/pile-uncopyrighted",
    context_size=128,

# Logging
    log_to_wandb=True,
    wandb_project="sae-training",

# Checkpointing
    checkpoint_path="checkpoints",
    n_checkpoints=5,
)

# 2. Train
trainer = SAETrainingRunner(cfg)
sae = trainer.run()

# 3. Evaluate
print(f"L0 (avg active features): \{trainer.metrics['l0']}")
print(f"CE Loss Recovered: \{trainer.metrics['ce_loss_score']}")

`

### Siêu tham số chính

| Tham số | Giá trị điển hình | Hiệu ứng |
|----------|---------------|--------|
| 
`d_sae
` | 4-16× d_model | Nhiều tính năng hơn, dung lượng cao hơn |
| 
`l1_coefficient
` | 5e-5 đến 1e-4 | Cao hơn = thưa thớt hơn, kém chính xác hơn |
| 
`lr
` | 1e-4 đến 1e-3 | Trình tối ưu hóa tiêu chuẩn LR |
| 
`l1_warm_up_steps
` | 500-2000 | Ngăn chặn tính năng chết sớm |

### Số liệu đánh giá| Số liệu | Mục tiêu | Ý nghĩa |
|--------|--------|---------|
| **L0** | 50-200 | Tính năng hoạt động trung bình trên mỗi mã thông báo |
| **Điểm mất CE** | 80-95% | Entropy chéo được phục hồi so với bản gốc |
| **Tính năng chết** | <5% | Các tính năng không bao giờ kích hoạt |
| **Giải thích phương sai** | >90% | Chất lượng tái thiết |

### Danh sách kiểm tra
- [ ] Chọn lớp mục tiêu và điểm móc
- [ ] Đặt hệ số mở rộng (d_sae = 4-16× d_model)
- [ ] Điều chỉnh hệ số L1 cho độ thưa mong muốn
- [ ] Kích hoạt tính năng khởi động L1 để ngăn chặn các tính năng chết
- [ ] Giám sát số liệu trong quá trình đào tạo (W&B)
- [ ] Xác thực phục hồi mất L0 và CE
- [ ] Kiểm tra tỷ lệ tính năng chết

## Quy trình làm việc 3: Phân tích và chỉ đạo tính năng

### Phân tích các tính năng riêng lẻ

``` python
from transformer_lens import HookedTransformer
from sae_lens import SAE
 import torch`model = HookedTransformer.from_pretrained("GPT2-small", device="cuda")
sae, _, _ = SAE.from_pretrained(
    release="GPT2-small-res-jb",
    sae_id="blocks.8.hook_resid_pre",
    device="cuda"
)

# Find what activates a specific feature
feature_idx = 1234
test_texts = [
    "The scientist conducted an experiment",
    "I love chocolate cake",
    "The code compiles successfully",
    "Paris is beautiful in spring",
]

for text in test_texts:
    tokens = model.to_tokens(text)
    _, cache = model.run_with_cache(tokens)
    features = sae.encode(cache["resid_pre", 8])
    activation = features[0, :, feature_idx].max().item()
    print(f"\{activation:.3f}: \{text}")

`

### Chỉ đạo tính năng

`Python
def steer_with_feature(model, sae, prompt, feature_idx, strength=5.0):
    """Add SAE feature direction to residual stream."""
    tokens = model.to_tokens(prompt)

# Get feature direction from decoder
    feature_direction = sae.W_dec[feature_idx]  # [d_model]

def steering_hook(activation, hook):

        # Add scaled feature direction at all positions
        activation += strength * feature_direction
        return activation

# Generate with steering
    output = model.generate(
        tokens,
        max_new_tokens=50,
        fwd_hooks=[("blocks.8.hook_resid_pre", steering_hook)]
    )
    return model.to_string(output[0])

`

### Thuộc tính tính năng

``` python

# Which features most affect a specific output?
tokens = model.to_tokens("The cAPItal of France is")
_, cache = model.run_with_cache(tokens)

# Get features at final position
features = sae.encode(cache["resid_pre", 8])[0, -1]  # [d_sae]

# Get logit attribution per feature
# Feature contribution = feature_activation × decoder_weight × unembedding
W_dec = sae.W_dec  # [d_sae, d_model]
W_U = model.W_U    # [d_model, vocab]

# Contribution to "Paris" logit
paris_token = model.to_single_token(" Paris")
feature_contributions = features * (W_dec @ W_U[:, paris_token])

top_features = feature_contributions.topk(10)
print("Top features for 'Paris' prediction:")
for idx, val in zip(top_features.indices, top_features.values):
    print(f"  Feature \{idx.item()}: \{val.item():.3f}")

`

## Các vấn đề thường gặp & Giải pháp

### Vấn đề: Tỷ lệ tính năng chết cao

`
``` python

# WRONG: No warm-up, features die early
cfg = LanguageModelSAERunnerConfig(
    l1_coefficient=1e-4,
    l1_warm_up_steps=0,  # Bad!
)

# RIGHT: Warm-up L1 penalty
cfg = LanguageModelSAERunnerConfig(
    l1_coefficient=8e-5,
    l1_warm_up_steps=1000,  # Gradually increase
    use_ghost_grads=True,   # Revive dead features
)

`

### Vấn đề: Tái thiết kém (khả năng phục hồi CE thấp)

`
``` python

# Reduce sparsity penalty
cfg = LanguageModelSAERunnerConfig(
    l1_coefficient=5e-5,  # Lower = better reconstruction
    d_sae=768 * 16,       # More capacity
)

`

### Vấn đề: Các đặc điểm không thể hiểu được

`
``` python

# Increase sparsity (higher L1)
cfg = LanguageModelSAERunnerConfig(
    l1_coefficient=1e-4,  # Higher = sparser, more interpretable
)
# Or use TopK architecture
cfg = LanguageModelSAERunnerConfig(
    architecture="topk",
    activation_fn_kwargs=\{"k": 50},  # Exactly 50 active features
)

`

### Vấn đề: Lỗi bộ nhớ trong quá trình luyện tập

`
``` python
cfg = LanguageModelSAERunnerConfig(
    train_batch_size_tokens=2048,  # Reduce batch size
    store_batch_size_prompts=4,    # Fewer prompts in buffer
    n_batches_in_buffer=8,         # Smaller activation buffer
)

`

## Tích hợp với Neuronpedia

Duyệt qua các tính năng SAE được đào tạo trước tại [neuronpedia.org](https://neuronpedia.org):

`Python

# Features are indexed by SAE ID
# Example: GPT2-small layer 8 feature 1234
# → neuronpedia.org/GPT2-small/8-res-jb/1234

`

## Tham khảo các lớp chính

| Lớp | Mục đích |
|-------|----------|
| 
`SAE
` | Mô hình bộ mã hóa tự động thưa thớt |
| 
`LanguageModelSAERunnerConfig
` | Cấu hình đào tạo |
| 
`SAETrainingRunner
` | Quản lý vòng đào tạo |
| 
`ActivationsStore
` | Thu thập và phân đợt kích hoạt |
| 
`HookedSAETransformer
` | Tích hợp TransformerLens + SAE |

## Tài liệu tham khảo

Để biết tài liệu, hướng dẫn chi tiết về API và cách sử dụng nâng cao, hãy xem thư mục 
`references/

:

| Tập tin | Nội dung |
|------|----------|
| [references/README.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/saelens/references/README.md) | Tổng quan và hướng dẫn bắt đầu nhanh |
| [references/API.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/saelens/references/API.md) | Tham chiếu API hoàn chỉnh cho SAE, TrainingSAE, cấu hình |
| [references/tutorials.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/saelens/references/tutorials.md) | Hướng dẫn từng bước về đào tạo, phân tích, chỉ đạo |

## Tài nguyên bên ngoài

### Hướng dẫn
- [Basic Loading & Analysis](https://GitHub.com/jbloomAus/SAELens/blob/main/tutorials/basic_loading_and_analysing.ipynb)
- [Training a Sparse Autoencoder](https://GitHub.com/jbloomAus/SAELens/blob/main/tutorials/training_a_sparse_autoencoder.ipynb)
- [ARENA SAE Curriculum](https://www.lesswrong.com/posts/LnHowHgmrMbWtpkxx/intro-to-superposition-and-sparse-autoencoders-colab)

### Giấy tờ
- [Towards Monosemanticity](https://transformer-circuits.pub/2023/monosemantic-features) - Nhân Loại (2023)
- [Scaling Monosemanticity](https://transformer-circuits.pub/2024/scaling-monosemanticity/) - Nhân Loại (2024)
- [Sparse Autoencoders Find Highly Interpretable Features](https://arxiv.org/abs/2309.08600) - Cunningham và cộng sự. (ICLR 2024)

### Tài liệu chính thức
- [SAELens Docs](https://jbloomaus.GitHub.io/SAELens/)
- [Neuronpedia](https://neuronpedia.org) - Trình duyệt tính năng

## Kiến trúc SAE

| Kiến trúc | Mô tả | Trường hợp sử dụng |
|--------------|-------------|----------|
| **Tiêu chuẩn** | ReLU + L1 phạt | Mục đích chung |
| **Có cổng** | Cơ chế gating đã học | Kiểm soát thưa thớt tốt hơn |
| **TopK** | Chính xác K tính năng hoạt động | Độ thưa thớt nhất quán |

``` python

# TopK SAE (exactly 50 features active)
cfg = LanguageModelSAERunnerConfig(
    architecture="topk",
    activation_fn="topk",
    activation_fn_kwargs=\{"k": 50},
)

`
`