Metadata-Version: 2.4
Name: bija-cpu
Version: 0.1.0
Summary: Bija — Artificial Brain Computation Kernel. A PyTorch-like framework for event-causal plastic graph simulation.
Author: BRIAN Project
License: MIT
Project-URL: Homepage, https://github.com/BRIAN-project/bija
Project-URL: Documentation, https://github.com/BRIAN-project/bija
Keywords: neuroscience,brain-simulation,spiking-neural-network,kernel,cuda,gpu
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: numpy>=1.24

# Bija (बीज) — Artificial Brain Computation Kernel

**Bija** (Sanskrit for "seed") is a PyTorch-like computation kernel for
artificial brain simulation. It provides device-agnostic primitives,
a composable module system, and CPU/CUDA backends for event-causal
plastic graph computation.

## Install

```bash
pip install bija-cpu          # CPU only (NumPy)
pip install bija-gpu          # GPU support (Numba CUDA)
pip install bija-tpu          # TPU support (JAX/XLA - coming soon)
```

## Quick Start

```python
import bija
from bija import nn

# 1. Choose device
dev = bija.device("cuda")  # or "cpu"

# 2. Build a brain model (user-level code)
brain = nn.Brain(
    neurons   = nn.AdExNeuron(10_000, branches=2),
    synapses  = [nn.PlasticSynapse(10_000, 10_000, 1_280_000)],
    regions   = nn.RegionMap(10_000, 8),
    stability = nn.HomeostasisController(target_rate=0.05),
    safety    = nn.Watchdog(),
).to(dev)

# 3. Run
for t in range(1000):
    result = brain.step(sensory=[...], body=bija.BodyContext(novelty_delta=0.1))
    print(f"t={t} spikes={result.spike_count}")

# 4. Save / Load
bija.save(brain, "my_brain.bija")
bija.load(brain, "my_brain.bija")
```

## Architecture

```
User Model (10k brain, cortical column, custom architecture)
     |
bija.nn       Module system: Brain, AdExNeuron, PlasticSynapse, RegionMap
     |
bija.ops      Primitives: integrate, spike, trace, plasticity (auto-dispatch)
     |
bija.core     Data structures: Device, StateVector, SparseGraph
     |
Backend       CPU (NumPy) / CUDA (Numba)
```

## Key Principles

- **No global loss.** All plasticity is local (pre/post/neuromodulator).
- **Event-sparse.** Cost per tick ~ O(active_neurons + spikes × fanout).
- **Device-agnostic.** Same model code runs on CPU or GPU.
- **Composable.** Build arbitrary brain architectures from modules.
- **Safe.** External actions gated by an immutable Watchdog.

## Examples

```bash
# Run 10k test model on CPU
python examples/model_10k.py

# Run on GPU
python examples/model_10k.py --cuda
```

## License

MIT
