gitwtfhub

wtf is jspace_collisions?

alanoursland/jspace_collisions — explained in plain English

Analysis updated 2026-05-18

0PythonAudience · researcherComplexity · 4/5Setup · moderate

TL;DR

A research project that tests whether the J-space interpretability technique for language models reliably distinguishes different internal states or hides collisions.

Mindmap

mindmap
  root((jspace_collisions))
    What it does
      Tests J-lens readouts
      Finds hidden collisions
      Runs experiment families
    Tech stack
      Python
      NumPy
      PyTorch
    Use cases
      Probe collision cases
      Activation patching
      Lightweight metrics
    Audience
      Interpretability researchers
      ML safety researchers

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Why would anyone build with this?

REASON 1

Test whether two different internal model states produce misleadingly similar J-lens readouts

REASON 2

Generate minimal-pair prompts designed to probe for collisions in the J-lens technique

REASON 3

Run activation patching experiments to check how readouts relate to real model behavior

REASON 4

Run lightweight metric and prompt generation code without needing a GPU

What's in the stack?

PythonNumPyPyTorchTransformers

How it stacks up

alanoursland/jspace_collisions0xallam/my-recipe0xhassaan/nn-from-scratch
Stars00
LanguagePythonPythonPython
Last pushed2022-11-22
MaintenanceDormant
Setup difficultymoderatemoderatemoderate
Complexity4/52/54/5
Audienceresearchergeneraldeveloper

Figures from each repo's GitHub metadata at analysis time.

How do you spin it up?

Difficulty · moderate Time to first run · 30min

Core metrics run with just NumPy, model-based experiments need PyTorch, transformers, and typically a GPU.

Wtf does this do

This is a research project that investigates a specific technique for interpreting what is happening inside a language model, called J-space or the Jacobian lens. The core question the project is testing is whether this technique gives a trustworthy, complete picture of a model's internal state, or whether it only works well in some situations while hiding cases where two very different internal states end up looking the same when read through this lens. If two internal states produce nearly identical readouts but actually behave differently, that would be a meaningful blind spot for anyone relying on this method to understand or check model behavior. The project is organized around a set of five hypotheses and twelve planned experiment families, each living in its own folder, that test different angles of this question, such as generating pairs of prompts designed to trigger the same readout while producing different real behavior, and using activation patching to directly test how internal states relate to outputs. A shared Python library holds the metrics, prompt generators, and interfaces to the underlying lens technique. Setup uses Python 3.11 or newer with the uv package manager. The core metrics and prompt generation code only needs NumPy and can run on any machine, while the parts of the project that work directly with a language model need PyTorch and transformers, plus a GPU for anything beyond very small models. The README links to external Anthropic research describing the Jacobian lens technique and a reference implementation that this project plans to integrate but has not yet included. The README is upfront that the project is still in an early scaffolding phase, with a separate planning document tracking what has been built so far and what remains to be done.

Yoink these prompts

Prompt 1
Help me set up this project with uv and run the core NumPy-only tests
Prompt 2
Explain what a collision in J-space readouts means and why it matters for safety
Prompt 3
Walk me through the experiment families listed in docs/research_program.md
Prompt 4
What is needed to install the [models] extra and run GPU-dependent experiments

Frequently asked questions

wtf is jspace_collisions?

A research project that tests whether the J-space interpretability technique for language models reliably distinguishes different internal states or hides collisions.

What language is jspace_collisions written in?

Mainly Python. The stack also includes Python, NumPy, PyTorch.

How hard is jspace_collisions to set up?

Setup difficulty is rated moderate, with roughly 30min to a first successful run.

Who is jspace_collisions for?

Mainly researcher.

View the repo → Decode another repo

This repo across BitVibe Labs

Don't trust strangers blindly. Verify against the repo.