Getting started

PSE Analyzer opens a GGUF model, measures the eigenvalue spectrum of every weight matrix, compares precisions of the same model, and seals the results in a dossier. It runs on an ordinary CPU. The web view listens on 127.0.0.1 only; nothing leaves your computer.

Download

The files and their SHA-256 checksums are on the PSE Analyzer page and in the releases repository.

Windows

Two files exist. The single .exe is one self-contained file that unpacks itself to a temporary folder on every start, which costs about twelve seconds. The folder .zip starts in half a second; keep the whole folder together. Neither needs Python installed, and neither needs the internet.

Download one of them and check its SHA-256 against SHA256SUMS.txt from the same release:
Terminal window
```
Get-FileHash .\PSE-Analyzer-0.3.1-windows-x64.exe -Algorithm SHA256
```
On the first run Windows shows “Windows protected your PC”: choose More info, then Run anyway.

Open a terminal in the folder that holds the executable and run these three. Below, PSE-A.exe stands for whichever file you have.

PSE-A.exe doctor      # measures this machine: CPU, RAM, BLAS speed
PSE-A.exe selftest    # checks the invariants; all must say OK
PSE-A.exe gui         # opens the web view in your browser

Double-clicking the executable with no arguments does the same as gui.

Ubuntu

The package contains no compiled code. On the first run it builds a Python environment in your home folder and installs numpy and scipy there as wheels, so they come with their own OpenBLAS tuned to your CPU. That first run needs the internet; nothing after it does.

Download the .deb and check its SHA-256:
Terminal window
```
sha256sum pse-a_0.3.1_all.deb
```
Install it. It needs Python 3.10 or newer and the python3-venv package, which apt pulls in:
Terminal window
```
sudo apt install ./pse-a_0.3.1_all.deb
```
Run the same three commands:
Terminal window
```
pse-a doctor
pse-a selftest
pse-a gui
```

The commands

Command	What it does
`doctor [model]`	What this machine can do, measured rather than assumed. With a GGUF file it also prints the model card and the capability traffic light.
`info <model>`	Model card and the inventory of tensor types.
`l1 <model>`	The L1 spectral sweep: the eigenvalue spectrum of every weight matrix, sealed into the dossier.
`qdiff <ref> <test>`	Compares two precisions of the same model. The reference should ideally be f16.
`ppl <folder>`	Perplexity of every rung in a precision ladder. Needs torch.
`lens <model>`	L2 logit lens: what the model believes at each layer. Needs torch.
`sae <model> --layer N`	L3 sparse autoencoder: a dictionary of the features one layer uses. Needs torch.
`jspace <model>`	L4 map of J-space. Needs torch.
`serve`, `gui`	The web view over the dossiers, 127.0.0.1 only.
`selftest [--k2 DIR]`	Invariant checks. With a folder of GGUFs it also verifies dequantisation.
`torch <action>`	Manage the optional torch environment.
`--version`	Prints the version.

Where your data lives

Location	Holds
Windows `%LOCALAPPDATA%\pse-a`, Ubuntu `~/.local/share/pse-a`	Dossiers, sealed runs, the shared library database, harvests.
Windows `%APPDATA%\pse-a`, Ubuntu `~/.config/pse-a`	API keys and the torch setting.

Harvests run to tens of gigabytes and the models themselves are 8 GB and up, so put the data root on a drive with room. Set PSE_A_DATA to that folder; doctor prints the data root and the free space beside it.

torch, and why it sits outside

A frozen executable has no pip, so torch can never be installed into the .exe itself, and at about 300 MB most of the tool does not need it. The weight-anatomy side, doctor, info, l1, qdiff and the web view, is pure numpy and scipy. The four activation missions, lens, sae, jspace and ppl, read the model while it is running and need torch.

The first time you open the web view without torch, a notice explains this and offers two routes. Both are also available from the command line:

pse-a torch setup                      # build an environment alongside, install CPU torch (needs Python 3.10+ and internet, once)
pse-a torch use /path/to/python        # adopt a Python that already has torch

What changed in 0.3.1

Before 0.3.1 a model was identified by its header alone: the GGUF version, the file size, and every tensor’s name, shape, type and offset. Two models of identical geometry and size, such as two checkpoints of one fine-tune at the same quantisation, therefore shared one dossier, and their spectra mixed silently. Since 0.3.1 the key also covers samples of the tensor data: the first 4 KiB of every tensor and two 64 KiB windows in the data section.

Dossiers made before 0.3.1 are carried over automatically. Each is flagged in the inbox until its model file is opened again; at that moment the dossier, its runs, inbox items and harvest folder move to the new key, once, and the mapping is kept in the hash_migrations table. Sealed artefacts are not rewritten: they are content-addressed and immutable, and the old hash inside them resolves through that table.

Licence

Free and open source under GPL-3.0-or-later; the source is at github.com/zeravatechnologies/pse-analyzer. Builds up to 0.3.1 were published under the earlier Zerava software licence; releases built from the public repository carry GPL-3.0 (LICENSE.md and NOTICE inside each download). Questions: contact us.