TALON — Tactical AI at Low-power On-device Nodes

TALON is the unified development kit for neuromorphic computing with Type 1 Compute hardware. It provides analysis, profiling, conversion, and deployment tools for spiking neural networks — everything from model export to FPGA bitstream generation.

Read more in our documentation

Installation

pip install t1c-talon

CLI Commands

Both talon and t1c invoke the same CLI (aliases):

# Information
talon info            # Ecosystem version info  (also: t1c info)
talon primitives      # List available TALON IR primitives

# Analysis & Profiling
talon analyze FILE    # Graph structure and statistics
talon profile FILE    # Hardware profiling and resource estimation
talon compare A B     # Compare two graphs (diff)

# Quality & Validation
talon lint FILE       # Lint graph for issues and best practices
talon validate FILE   # Validate graph structure (basic checks)

# Provenance & Reproducibility
talon hash FILE       # Generate deterministic fingerprint
talon stamp FILE -o   # Add provenance metadata

# Inspection & Debugging
talon inspect FILE    # Inspect nodes and edges
talon node FILE NODE  # Detailed node information
talon trace FILE A B  # Trace paths from node A to B

# Conversion & Optimization
talon convert FILE    # Convert to SpikingAffine, quantize, prune

# Visualization
talon visualize FILE  # Interactive browser visualization
talon export-html FILE # Export standalone HTML

# Deployment Pipeline (Graph → Backend → Hardware)
talon quantize FILE   # Mixed-precision fixed-point quantization
talon partition FILE  # Graph partitioning for hardware cores
talon compile FILE    # Compile to hardware descriptor (JSON/binary)
talon simulate FILE   # CPU simulation for correctness validation
talon energy FILE     # Energy estimation (MAC-based, 45nm process)
talon pipeline FILE   # Full pipeline: load → lint → analyze → partition → compile → simulate
talon run FILE        # Quick simulation (graph.run convenience)
talon profile-hw FILE # From-scratch CPU profiler (latency/energy)

Analysis

$ talon analyze model.t1c -v

TALON IR Graph Summary
==================================================
Nodes: 7  |  Edges: 6  |  Depth: 6  |  Width: 1
Parameters: 235.1K  |  Memory: 918.5 KB  |  FLOPs: 469.5K

Layer Types:
  Affine: 2
  LIF: 2
  Input: 1
  Output: 1
  Flatten: 1

Input: (784,)
Output: (10,)

SNN: 2 LIF neuron layer(s)

==================================================
Layer Breakdown:
  fc1: Affine - 100.5K params, 392.0 KB
  fc2: Affine - 1,290 params, 5.0 KB

Hardware Profiling

$ talon profile model.t1c

TALON Hardware Profile
==================================================

Memory Estimates:
  Weight memory:     918.5 KB
  Activation memory: 3.1 KB (peak)
  State memory:      512 B (LIF membrane)
  Total:             922.1 KB
  8-bit quantized:   232.7 KB (estimate)

Compute Estimates:
  MAC operations: 234.8K
  Spike operations: 384

Architecture:
  Conv layers:    0
  FC layers:      2
  LIF layers:     2
  Pooling layers: 0

💡 Recommendations:
  • Consider using SpikingAffine for FC layers to enable hardware-optimized quantization
  • 8-bit quantization could reduce memory by ~75%

Conversion

# Convert Affine to SpikingAffine for hardware deployment
$ talon convert model.t1c --spiking --weight-bits 8 -o model_hw.t1c
✓ Converted to SpikingAffine (bits=8, mode=binary)
✓ Saved to: model_hw.t1c

# Quantize weights
$ talon convert model.t1c --quantize 8 -o model_q8.t1c
✓ Quantized weights to 8 bits
✓ Saved to: model_q8.t1c

Python API

from talon import sdk as talon  # TALON Python API

# === Analysis ===
stats = talon.analyze_graph("model.t1c")
print(f"Params: {stats.total_params:,}, Memory: {stats.total_bytes:,} bytes")
print(f"LIF layers: {stats.lif_count}, Depth: {stats.depth}")

# === Comparison ===
diff = talon.compare_graphs("model_v1.t1c", "model_v2.t1c")
if diff.identical:
    print("Models are identical")
else:
    print(f"Modified: {diff.nodes_modified}")
    print(f"Max weight diff: {diff.max_weight_diff:.2e}")

# === Profiling ===
profile = talon.profile_graph("model.t1c")
print(f"Total memory: {profile.total_memory:,} bytes")
print(f"8-bit estimate: {profile.estimated_quantized_memory:,} bytes")
for rec in profile.recommendations:
    print(f"  • {rec}")

# === Conversion ===
graph = talon.read("model.t1c")
spiking_graph = talon.convert_to_spiking(graph, weight_bits=8)
talon.write("model_hw.t1c", spiking_graph)

# === Round-trip verification ===
talon.assert_graphs_equal(original_graph, reloaded_graph)

# === Export/Import (from t1ctorch) ===
graph = talon.to_ir(model, sample_input)
executor = talon.ir_to_torch(graph, return_state=True)
output, state = executor(input_tensor, state)

# === Linting ===
result = talon.lint_graph(graph)
if not result.is_valid:
    for error in result.errors:
        print(f"Error: {error.message}")
for warning in result.warnings:
    print(f"Warning: {warning.message}")

# === Fingerprinting ===
hash_struct = talon.fingerprint_graph(graph, include_weights=False)
hash_full = talon.fingerprint_graph(graph, include_weights=True)
print(f"Structure hash: {hash_struct}")
print(f"Full hash: {hash_full}")

# === Stamping ===
stamped = talon.stamp_graph(
    graph,
    notes="PokerDVS model, 92% accuracy",
    git_commit="a1b2c3d",
    quantization_config={"weight_bits": 8}
)
talon.write("stamped_model.t1c", stamped)

# === Node Inspection ===
node_info = talon.inspect_node(graph, "fc1")
print(f"Node type: {node_info['type']}")
print(f"Parameters: {node_info['parameters']}")
print(f"Inputs from: {node_info['inputs']}")

# === Path Tracing ===
paths = talon.trace_path(graph, "input", "output")
for path in paths:
    print(" → ".join(path))

# === Pattern Matching ===
conv_lif_pairs = talon.find_pattern(graph, "Conv2d->LIF")
for conv_node, lif_node in conv_lif_pairs:
    print(f"Found: {conv_node} -> {lif_node}")

# === Visualization (from talon.viz) ===
talon.visualize(graph, title="My SNN")

Key Features

Analysis & Profiling

Quality & Validation

Provenance & Reproducibility

Inspection & Debugging

Conversion & Optimization

TALON Core Packages

TALON IR Primitives

Core Layers

ANN Primitives (Hybrid Architectures)

Deployment & Hardware Mapping

Event I/O & Neural Encoding

FPGA Backend (HLS4ML)

License

MIT License - see LICENSE for details.

Acknowledgements

TALON IR, the IR layer underlying TALON, is inspired by the Neuromorphic Intermediate Representation (NIR) project.