comfyui-stanno

STANNO — Neural Networks That Train Neural Networks

A modern, open-source Python library implementing the Artificial Neurogenesis Network concept from US Patent 5,852,815 (Thaler, 1998). One network (the trainer) decides how another network (the trainee) should update its weights — no backpropagation needed. Multiple STANNOs can be chained into cascade pipelines, and any trained STANNO can be turned into a data scanner that finds matching rows in large datasets.

Attribution: This is a faithful, open-source implementation of Thaler's patented design with modern extensions (cascading, data scanning, ComfyUI integration). The original patent has expired. All core concepts are credited to the original patent.

⚠️ What STANNO Is (and Isn't)

STANNO is specialized, not a drop-in replacement for PyTorch.

Good for:

• Anomaly detection (reconstruction-based scoring)
• Online/continual learning (one-sample-at-a-time updates)
• Interpretable weight modification (see exactly what changes)
• Multi-stage cascade pipelines (encoder → bottleneck → decoder, end-to-end)
• Semantic data scanning (find rows in a large dataset that match learned distribution)
• ComfyUI creative workflows (style transfer via dream mode)

NOT for:

• General regression (accuracy ~0.4, use PyTorch instead)
• Image generation alone (need Stable Diffusion + nodes)
• High-throughput training (slow NumPy)

For details, see STANNO_IS_NOT.md.

What you can do with this:

Train networks on your data:

from stanno import STANNO
from stanno.config.schema import STANNOConfig
import numpy as np

config = STANNOConfig(layers=[784, 256, 10])
stanno = STANNO(config)
stanno.fit(x_train, y_train, epochs=100)
predictions = stanno.predict(x_test)

Chain into cascade pipelines:

from stanno import STANNO, STANNOConfig, CascadeSTANNO

# Encoder-decoder autoencoder
enc = STANNO(STANNOConfig(layers=[768, 256, 64], learning_rate=0.05))
dec = STANNO(STANNOConfig(layers=[64, 256, 768], learning_rate=0.05))

ae = CascadeSTANNO([enc, dec])
ae.fit(embeddings, embeddings, epochs=200)   # end-to-end gradient cascade

# Extract compressed representations
codes = ae.intermediate_output(embeddings, stage=0)  # (N, 64)

# Freeze the encoder, continue adapting the decoder
ae.freeze(0)
ae.fit(new_domain_embeddings, new_domain_embeddings, epochs=100)

Scan large datasets for matching rows (DSANNO):

from stanno import STANNO, STANNOConfig, DSANNO

# Train on known-good data
detector = STANNO(STANNOConfig(layers=[64, 128, 64], learning_rate=0.05))
detector.fit(normal_data, normal_data, epochs=200)

scanner = DSANNO(detector, mode="reconstruction")

# Auto-calibrate threshold from training distribution
threshold = scanner.calibrate_threshold(normal_data, percentile=95)

# Find matching rows in a large corpus
result = scanner.scan(large_corpus, threshold=threshold)
matching = large_corpus[result.matched_indices()]

# Or retrieve the top-k best matches
indices, scores, _ = scanner.top_k(large_corpus, k=20)

# Stream huge files without loading all at once
for batch_result in scanner.scan_stream(file_batches, threshold=threshold):
    process(batch_result.matched_indices())

Detect when inputs are unusual (anomaly filter):

from stanno.integration.filter import STANNOFilter

# Train on normal data
stanno.fit(normal_data, normal_data, epochs=50)

# Score new input
score, metadata = stanno_filter.score(new_input)
# score ranges [0, 1]: low = normal, high = anomaly

Generate variations via "dream mode":

# Start with a seed input, add noise, generate a sequence
dream_sequence = stanno.dream(
    num_steps=64,
    input_seed=seed_vector,
    noise_sigma=0.1  # controls creativity
)

Use in ComfyUI workflows (9 nodes):

• Load/create STANNO models
• Train on image batches
• Score/filter images
• Inject dream creativity into CLIP conditioning
• Apply dream output as LoRA-style patches
• Route images by style match
• Scan image batches for best matches with auto-calibrated thresholds
• Build multi-stage cascade autoencoders

Why use STANNO?

• Interpretable: You can see exactly what the trainer does to weights. No black-box backprop.
• Flexible: Three trainer types (Fixed, LocalRule, Evolutionary) fit different problems.
• Learnable: The trainer itself can adapt (meta-learning).
• Cascadable: Chain STANNOs into multi-stage pipelines with end-to-end gradient flow across stages.
• Scannable: Turn any trained STANNO into a semantic scanner over large datasets.
• No autodiff: Works with NumPy. No GPU required (but supports PyTorch if you have it).
• ComfyUI ready: Nine custom nodes for image generation workflows.

Install

pip install git+https://github.com/nitroxido/stanno.git

Quick examples

Regression on sin(x)

python -m stanno train --config examples/sin_regression.json
python -m stanno predict --config examples/sin_regression.json --input 0.5
python -m stanno dream --config examples/sin_regression.json

Autoencoder on images

from stanno import STANNO
from stanno.config.schema import STANNOConfig
import numpy as np

# Reshape images to flat vectors (B, H*W*C)
x = images.reshape(images.shape[0], -1).astype('float32')

# Autoencoder: input and output have same size
config = STANNOConfig(layers=[x.shape[1], 256, x.shape[1]])
stanno = STANNO(config)
stanno.fit(x, x, epochs=100, batch_size=32)

# Get reconstruction
x_reconstructed = stanno.predict(x[:10])

Online learning (continual)

from stanno.integration.continual import ContinualSTANNO

cont = ContinualSTANNO(stanno)

for sample, label in data_stream:
    loss = cont.observe(sample, label)
    if cont.steps % 100 == 0:
        test_loss = cont.test_loss(x_test, y_test)
        print(f"Step {cont.steps}: train_loss={loss:.4f}, test_loss={test_loss:.4f}")

Anomaly scoring

from stanno.config.schema import FilterConfig
from stanno.integration.filter import STANNOFilter

# Train on normal embeddings
stanno.fit(normal_embeddings, normal_embeddings, epochs=50)

# Create filter
filt = STANNOFilter(stanno, FilterConfig(anomaly_threshold=0.7))

# Score new embedding
score, info = filt.score(new_embedding)
print(f"Anomaly score: {score:.3f} (0=normal, 1=anomaly)")
if info["blocked"]:
    print("Blocked: input is too unusual")

How it works

The core idea:

• TraineeNet: A neural network with weights you want to train.
• TrainerNet: Another network that looks at the TraineeNet's internal state (activations, errors, weights) and computes how to update those weights.
• No backprop: The update formula is explicit, not learned via autodiff.
• Cascades: Multiple TraineeNet+TrainerNet pairs can be chained so that gradient signals flow backward across stage boundaries, enabling end-to-end training of multi-stage pipelines.
• Scanning: Any trained STANNO can be used as a similarity function to scan and rank rows in large datasets by how closely they match the learned distribution.

The three trainer types:

Technical details

• Backend agnostic: Uses NumPy by default, but can swap in PyTorch.
• Variable architecture: Networks can be any depth (list of layer sizes).
• Configurable feedback: Dream mode can "repeat" outputs, use a learned "linear" projection, or "zero" them.
• Pickle-serializable: Save/load trained models easily.

Benchmark

On sin(x) regression (512 samples, 100 epochs):

Fixed         MSE=0.047
LocalRule     MSE=0.021  (learnable rules = better fit)
Evolutionary  MSE=0.053

For ComfyUI users

The comfyui-stanno custom node package provides nine nodes in the STANNO category:

Install via ComfyUI-Manager or manually.

Patent & Attribution

STANNO is an open-source implementation of US Patent 5,852,815 (Artificial Neurogenesis Network), filed by Stephen L. Thaler. The patent has expired (US utility patents: 20 years from filing). We fully acknowledge and credit all core architectural concepts to the original patent.

This implementation adds:

• Modern Python/NumPy/PyTorch backend
• CascadeSTANNO (multi-stage gradient cascade)
• DSANNO (data scanning and semantic search)
• Three trainer types (Fixed, LocalRule, Evolutionary)
• ComfyUI integration (9 custom nodes)
• CLI tools for common tasks

See Citation below for how to cite the original patent and this implementation.

Citation

If you use STANNO in research, cite the original patent:

@patent{thaler1998artificial,
  title={Artificial neurogenesis network},
  author={Thaler, Stephen L},
  year={1998},
  number={5852815},
  institution={United States Patent}
}

And mention this implementation:

@software{stanno2026,
  title={STANNO: Self-Training Artificial Neural Network Object},
  author={Raides J. Rodríguez},
  year={2026},
  url={https://github.com/nitroxido/stanno}
}

Questions?

• Bug report: Open an issue on GitHub
• Question: Start a discussion
• Feature request: Describe what you want to build

License

MIT

Core Package

This integration requires the stanno core package.

Install with:

pip install git+https://github.com/nitroxido/stanno.git
``` {data-source-line="259"}