Find patterns in the flow.
A reading tells you what happened. A sequence reveals how it changed. Spiking neural networks process the timing of incoming events, giving developers a way to model sensor readings and changing signals in Akasha.
Spiking neural networks
Watch timing become a signal.
A threshold crossing becomes an output.
The neuron emits a spike and resets. The output marks when the condition was reached, keeping timing part of the result.
Interactive integrate-and-fire illustration with normalized inputs, leak, and reset.
Give timing a place in your model.
A machine that warms gradually and one that heats suddenly may reach the same temperature. A network that processes the sequence can learn to distinguish those patterns.
- 01EncodeTurn incoming values, such as temperature readings, into signals the network can process.
- 02IntegrateEach neuron combines the new signal with recent activity. The timing and order of events remain part of the calculation.
- 03FireWhen activity crosses a threshold, a neuron sends a short pulse called a spike.
- 04PropagateConnected layers pass those spikes forward. Their learned connection strengths shape the response.
- 05ReadRead which neurons fired at each step, then use those outputs in your application or inspect the network state.
From incoming signal to network response.
Define a network specification in your authorized namespace, compile it, and send a numeric input. The HTTP interface returns the network’s output vector for your application to inspect.
Explore the network illustration
// Run server-side with credentials scoped to this Mind.
const endpoint = process.env.AKASHA_URL;
const capability = process.env.AKASHA_CAPABILITY;
if (!endpoint || !capability) throw new Error("Configure your Mind connection");
async function request(method: string, path: string, body?: unknown) {
const headers: Record<string, string> = {
"Content-Type": "application/json",
"x-akasha-capability": capability!,
};
if (process.env.AKASHA_TOKEN) {
headers.Authorization = "Bearer " + process.env.AKASHA_TOKEN;
}
const response = await fetch(new URL(path, endpoint), {
method, headers,
body: body === undefined ? undefined : JSON.stringify(body),
});
if (!response.ok) throw new Error("Mind request failed: " + response.status);
return response.json();
}
// Use the namespace encoded in your signed capability.
const namespace = process.env.AKASHA_NAMESPACE;
if (!namespace) throw new Error("Configure your authorized namespace");
const network = await request("POST", "/v1/snn/network/build", {
namespace,
spec: {
label: "sensor-example", seed: 42,
ensembles: { input: { n_neurons: 100, dimensions: 1, radius: 1.0 } },
connections: [],
},
});
const identity = {
network_id: network.network_id,
namespace: network.namespace,
version: network.version,
};
await request("POST", "/v1/snn/network/compile", identity);
const { output } = await request("POST", "/v1/snn/network/step", {
...identity, input: [0.5],
});Develop training for your signals.
The Rust library includes a Backpropagation Through Time trainer for developers building a training integration. Supply the network and task-specific data, then evaluate its behavior on sequences it has not seen.
use akasha_snn::train::bptt::{BpttConfig, BpttTrainer};
let trainer = BpttTrainer::new(BpttConfig::default());
// Integrate the trainer with a network and task-specific training data.
// Evaluate learned behavior on held-out sequences.Choose how your network behaves.
Choose a neuron model, set the simulation step, and inspect the outputs. Test network size and input timing together to find a configuration suited to your workload.
- HTTP input
- Numeric vector
- HTTP output
- Output vector
- Engine models
- LIF · Izhikevich · adaptive
- Training integration
- Rust BpttTrainer
- Lifecycle
- build, compile, step
- compile
- compiled_id · version
- step
- { output }
- Scope
- Verified namespace and network version
Build for signals that keep moving.
Explore spiking networks in Akasha and test them with the sequences your application needs to understand.