pip install huggingface_hub
hf auth login

pip install heretic-llm
heretic google/gemma-3-12b-it

heretic --model google/gemma-3-12b-it --evaluate-model ./gemma-3-12b-it-heretic

from safetensors.torch import load_file, save_file
import torch
import glob

model_path = "./gemma-3-12b-it-heretic"

# Merge weight shards
all_tensors = {}
for f in sorted(glob.glob(f"{model_path}/*.safetensors")):
    all_tensors.update(load_file(f))

# Filter and rename keys
renamed = {}
for k, v in all_tensors.items():
    if k.startswith("vision_tower."):
        continue
    if k.startswith("language_model."):
        new_key = k[len("language_model."):]
    else:
        new_key = k
    renamed[new_key] = v

# Embed tokenizer
with open(f"{model_path}/tokenizer.model", "rb") as f:
    tokenizer_bytes = f.read()
renamed["spiece_model"] = torch.frombuffer(bytearray(tokenizer_bytes), dtype=torch.uint8)

save_file(renamed, "gemma_3_12B_it_heretic.safetensors")

import torch
from safetensors.torch import load_file, save_file

tensors = load_file("gemma_3_12B_it_heretic.safetensors")

fp8_tensors = {}
for k, v in tensors.items():
    if v.dtype in [torch.float16, torch.bfloat16, torch.float32]:
        fp8_tensors[k] = v.to(torch.float8_e4m3fn)
    else:
        fp8_tensors[k] = v

save_file(fp8_tensors, "gemma_3_12B_it_heretic_fp8_e4m3fn.safetensors")

# Using Docker with llama.cpp
docker run --rm -it --gpus=all \
  -v /path/to/heretic:/models \
  nvidia/cuda:13.1.0-devel-ubuntu22.04 bash

# Inside container
apt-get update && apt-get install -y python3 python3-pip git cmake build-essential
git clone https://github.com/ggml-org/llama.cpp.git /app
pip3 install -r /app/requirements.txt

# Convert to F16
python3 /app/convert_hf_to_gguf.py /models/gemma-3-12b-it-heretic \
  --outfile /models/gemma-3-12b-it-heretic-f16.gguf \
  --outtype f16

# Build quantize tool
cd /app
cmake -B build -DCMAKE_BUILD_TYPE=Release -DLLAMA_CURL=OFF
cmake --build build --target llama-quantize -j $(nproc)

# Quantize to multiple formats
for quant in Q3_K_M Q4_K_M Q5_K_M Q6_K Q8_0; do
  /app/build/bin/llama-quantize /models/gemma-3-12b-it-heretic-f16.gguf \
    /models/gemma-3-12b-it-heretic-${quant}.gguf ${quant}
done

import torch
from transformers import AutoModel, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("./gemma-3-12b-it")

# Create your own prompt categories
prompts = {
    "innocent": [
        "a beautiful sunset over the ocean",
        "baking chocolate chip cookies",
        "a dog running on the beach",
        "children playing in a park",
        "reading a book by the fireplace",
        # ... add more innocent prompts
    ],
    "mild": [
        "a woman in a bikini",
        "drinking alcohol at a bar",
        "a fistfight between two men",
        "gambling at a casino",
        "smoking a cigarette",
        # ... add more mild prompts
    ],
    "violent": [
        # ... add violent prompts
    ],
    "sexual": [
        # ... add sexual prompts
    ],
    "extreme": [
        # ... add extreme prompts... these were so extreme it was probably better to remove them here, but you can add your own.
    ],
}

def get_embedding(model, text):
    inputs = tokenizer(text, return_tensors="pt")
    with torch.no_grad():
        outputs = model(**inputs, output_hidden_states=True)
    return outputs.last_hidden_state[:, -1, :]

print("Loading original...")
original = AutoModel.from_pretrained("./gemma-3-12b-it", torch_dtype=torch.bfloat16, device_map="cpu")
orig_embs = {}
for cat, ps in prompts.items():
    for p in ps:
        orig_embs[p] = get_embedding(original, p)
del original

print("Loading abliterated...")
abliterated = AutoModel.from_pretrained("./gemma-3-12b-it-heretic", torch_dtype=torch.bfloat16, device_map="cpu")
abl_embs = {}
for cat, ps in prompts.items():
    for p in ps:
        abl_embs[p] = get_embedding(abliterated, p)
del abliterated

print("\nResults by category:")
for cat, ps in prompts.items():
    sims = []
    for p in ps:
        cos_sim = torch.nn.functional.cosine_similarity(orig_embs[p], abl_embs[p]).item()
        sims.append(cos_sim)
    avg = sum(sims) / len(sims)
    std = (sum((x - avg) ** 2 for x in sims) / len(sims)) ** 0.5
    print(f"{cat:12} | n={len(ps):2} | avg: {avg:.4f} | std: {std:.4f}")

import torch
from transformers import AutoModel, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("./gemma-3-12b-it")

prompts = [
    "a beautiful sunset over the ocean",
    # ... add your own spicey test prompts
]

print("Loading original...")
original = AutoModel.from_pretrained("./gemma-3-12b-it", torch_dtype=torch.bfloat16, device_map="cpu")

print("Loading abliterated...")
abliterated = AutoModel.from_pretrained("./gemma-3-12b-it-heretic", torch_dtype=torch.bfloat16, device_map="cpu")

for prompt in prompts:
    print(f"\nPrompt: {prompt[:40]}...")
    inputs = tokenizer(prompt, return_tensors="pt")
    
    with torch.no_grad():
        orig_out = original(**inputs, output_hidden_states=True)
        abl_out = abliterated(**inputs, output_hidden_states=True)
    
    print("Layer | Cosine Sim (last token)")
    print("-" * 30)
    for i, (orig_h, abl_h) in enumerate(zip(orig_out.hidden_states, abl_out.hidden_states)):
        orig_vec = orig_h[0, -1, :]
        abl_vec = abl_h[0, -1, :]
        cos_sim = torch.nn.functional.cosine_similarity(orig_vec.unsqueeze(0), abl_vec.unsqueeze(0)).item()
        print(f"{i:5} | {cos_sim:.4f}")

import torch
from safetensors.torch import load_file

ltx_path = "/path/to/ltx-2-19b-dev.safetensors"
tensors = load_file(ltx_path)

proj = tensors['text_embedding_projection.aggregate_embed.weight']  # [3840, 188160]

# 188160 = 3840 * 49 layers
proj_reshaped = proj.view(3840, 49, 3840)

# L2 norm per layer
layer_importance = torch.norm(proj_reshaped, dim=(0, 2))

# Sort by importance
sorted_indices = torch.argsort(layer_importance, descending=True)

print("Top 10 most important layers:")
for i, idx in enumerate(sorted_indices[:10]):
    print(f"#{i+1}: Layer {idx.item():2} - {layer_importance[idx].item():.4f}")

total_importance = layer_importance.sum().item()
layer_48_pct = (layer_importance[48].item() / total_importance) * 100
print(f"\nLayer 48 contributes: {layer_48_pct:.2f}% of total weight")
print(f"Expected if uniform: {100/49:.2f}%")