neuratensor 1.0.0__py3-none-any.whl

lib/neuratensor_core.sha256

@@ -0,0 +1 @@
+a95c77b71fff85e9ebab3d7cb5852628de008e8581564fd2f3b19256225f7908  lib/neuratensor_core.so

neuratensor/__init__.py

@@ -0,0 +1,116 @@
+"""
+NeuraTensor SDK - Public API
+=============================
+
+Production-ready neuromorphic inference SDK with universal hardware support.
+
+Public API for NeuraTensor models. The core CUDA kernels are proprietary
+and distributed as compiled binaries.
+
+Neuramorphic, Inc. - San Francisco, CA
+Version: 1.0.0
+"""
+
+__version__ = "1.0.0"
+__author__ = "Neuramorphic, Inc."
+__license__ = "Apache 2.0"
+
+from .model_loader import ModelLoader
+from .config import SDKConfig, NeuraTensorConfig, ModelSize
+
+
+class NeuraTensor:
+    """
+    NeuraTensor neuromorphic model (Public API).
+    
+    Example:
+        >>> config = NeuraTensorConfig.preset("64m")
+        >>> model = NeuraTensor(config).cuda()
+    """
+    def __init__(self, config: NeuraTensorConfig):
+        import sys
+        import os
+        from pathlib import Path
+        
+        # Enable internal imports (SDK is authorized)
+        os.environ["NEURATENSOR_INTERNAL"] = "1"
+        
+        # Add neuratensor to path
+        sdk_dir = Path(__file__).parent
+        neuratensor_dir = sdk_dir.parent
+        sys.path.insert(0, str(neuratensor_dir))
+        
+        # Import from core (internal only - SDK authorized)
+        from core.model import NeuraTensorModel
+        from config.presets import create_64m_config, create_256m_config, create_1b_config
+        
+        # Map SDK config to internal config
+        preset_map = {
+            "64m": create_64m_config,
+            "256m": create_256m_config,
+            "1b": create_1b_config,
+        }
+        
+        model_size = config.model_size.value if hasattr(config.model_size, 'value') else config.model_size
+        
+        if model_size not in preset_map:
+            raise ValueError(f"Unknown model size: {model_size}")
+        
+        internal_config = preset_map[model_size]()
+        self._model = NeuraTensorModel(internal_config)
+        self.config = config
+        
+        # Update SDK config with internal values
+        self.config.vocab_size = internal_config.vocab_size
+        self.config.hidden_size = internal_config.hidden_size
+    
+    def cuda(self):
+        """Move model to CUDA"""
+        self._model = self._model.cuda()
+        return self
+    
+    def half(self):
+        """Convert model to FP16"""
+        self._model = self._model.half()
+        return self
+    
+    def __call__(self, input_ids):
+        """Forward pass"""
+        return self._model(input_ids)
+    
+    def count_parameters(self):
+        """Count model parameters"""
+        return self._model.count_parameters()
+
+__all__ = [
+    'NeuraTensor',
+    'NeuraTensorConfig',
+    'ModelLoader',
+    'SDKConfig',
+    'ModelSize',
+]
+
+
+# Quick start example
+def quick_start():
+    """
+    Quick start example for NeuraTensor SDK.
+    
+    Usage:
+        >>> from neuratensor.sdk import quick_start
+        >>> quick_start()
+    """
+    print("=" * 70)
+    print("NeuraTensor SDK - Quick Start")
+    print("=" * 70)
+    print()
+    print("from neuratensor.sdk import NeuraTensor")
+    print()
+    print("# Load model")
+    print('model = NeuraTensor.from_pretrained("64m")')
+    print()
+    print("# Run inference")
+    print("output = model(input_ids)")
+    print()
+    print("# Available models: 64m, 256m, 1b")
+    print("=" * 70)

neuratensor/backends.py

@@ -0,0 +1,228 @@
+"""
+Hardware Backend Detection
+==========================
+
+Auto-detection and management of hardware backends.
+"""
+
+import torch
+import platform
+from typing import Optional
+from .config import Backend
+
+
+class HardwareBackend:
+    """Base class for hardware backends"""
+    
+    def __init__(self, name: str):
+        self.name = name
+        self.device_name = None
+        self.compute_capability = None
+        self.available = False
+    
+    def detect(self) -> bool:
+        """Detect if backend is available"""
+        raise NotImplementedError
+    
+    def optimize(self):
+        """Apply backend-specific optimizations"""
+        pass
+    
+    def __repr__(self):
+        return f"{self.name}(available={self.available})"
+
+
+class JetsonOrinBackend(HardwareBackend):
+    """NVIDIA Jetson Orin backend"""
+    
+    def __init__(self):
+        super().__init__("jetson_orin")
+    
+    def detect(self) -> bool:
+        """Detect Jetson Orin"""
+        if not torch.cuda.is_available():
+            return False
+        
+        # Check device name
+        device_name = torch.cuda.get_device_name(0)
+        self.device_name = device_name
+        
+        # Jetson Orin has "Orin" in name and SM 8.7
+        if "Orin" in device_name:
+            props = torch.cuda.get_device_properties(0)
+            self.compute_capability = f"{props.major}.{props.minor}"
+            self.available = self.compute_capability == "8.7"
+            return self.available
+        
+        return False
+    
+    def optimize(self):
+        """Optimize for Jetson Orin"""
+        if torch.cuda.is_available():
+            # Enable TF32 for Ampere
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+            
+            # Enable cudnn benchmarking
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.deterministic = False
+
+
+class JetsonAGXBackend(HardwareBackend):
+    """NVIDIA Jetson AGX Xavier backend"""
+    
+    def __init__(self):
+        super().__init__("jetson_agx")
+    
+    def detect(self) -> bool:
+        """Detect Jetson AGX Xavier"""
+        if not torch.cuda.is_available():
+            return False
+        
+        device_name = torch.cuda.get_device_name(0)
+        self.device_name = device_name
+        
+        if "Xavier" in device_name:
+            props = torch.cuda.get_device_properties(0)
+            self.compute_capability = f"{props.major}.{props.minor}"
+            self.available = True
+            return True
+        
+        return False
+
+
+class NvidiaDesktopBackend(HardwareBackend):
+    """NVIDIA Desktop GPU backend (RTX, GTX, Tesla)"""
+    
+    def __init__(self):
+        super().__init__("nvidia_desktop")
+    
+    def detect(self) -> bool:
+        """Detect desktop NVIDIA GPU"""
+        if not torch.cuda.is_available():
+            return False
+        
+        device_name = torch.cuda.get_device_name(0)
+        self.device_name = device_name
+        
+        # Desktop cards
+        desktop_keywords = ["RTX", "GTX", "Tesla", "Quadro", "TITAN", "A100", "H100"]
+        
+        for keyword in desktop_keywords:
+            if keyword in device_name:
+                props = torch.cuda.get_device_properties(0)
+                self.compute_capability = f"{props.major}.{props.minor}"
+                self.available = True
+                return True
+        
+        return False
+    
+    def optimize(self):
+        """Optimize for desktop GPU"""
+        if torch.cuda.is_available():
+            props = torch.cuda.get_device_properties(0)
+            
+            # Enable TF32 for Ampere and newer (SM >= 8.0)
+            if props.major >= 8:
+                torch.backends.cuda.matmul.allow_tf32 = True
+                torch.backends.cudnn.allow_tf32 = True
+            
+            torch.backends.cudnn.benchmark = True
+
+
+class CUDAGenericBackend(HardwareBackend):
+    """Generic CUDA backend (fallback)"""
+    
+    def __init__(self):
+        super().__init__("cuda_generic")
+    
+    def detect(self) -> bool:
+        """Detect any CUDA device"""
+        if torch.cuda.is_available():
+            self.device_name = torch.cuda.get_device_name(0)
+            props = torch.cuda.get_device_properties(0)
+            self.compute_capability = f"{props.major}.{props.minor}"
+            self.available = True
+            return True
+        return False
+
+
+def detect_backend() -> HardwareBackend:
+    """
+    Auto-detect best available hardware backend.
+    
+    Returns:
+        Detected backend instance
+    
+    Example:
+        >>> backend = detect_backend()
+        >>> print(f"Detected: {backend.name}")
+    """
+    # Try backends in priority order
+    backends = [
+        JetsonOrinBackend(),
+        JetsonAGXBackend(),
+        NvidiaDesktopBackend(),
+        CUDAGenericBackend(),
+    ]
+    
+    for backend in backends:
+        if backend.detect():
+            return backend
+    
+    # No CUDA available
+    generic = HardwareBackend("cpu")
+    generic.available = True
+    return generic
+
+
+def get_backend(backend_type: Backend) -> HardwareBackend:
+    """
+    Get specific backend or auto-detect.
+    
+    Args:
+        backend_type: Backend enum value
+    
+    Returns:
+        Backend instance
+    """
+    if backend_type == Backend.AUTO:
+        return detect_backend()
+    
+    backend_map = {
+        Backend.JETSON_ORIN: JetsonOrinBackend(),
+        Backend.JETSON_AGX: JetsonAGXBackend(),
+        Backend.NVIDIA_DESKTOP: NvidiaDesktopBackend(),
+        Backend.CUDA_GENERIC: CUDAGenericBackend(),
+    }
+    
+    backend = backend_map.get(backend_type)
+    if backend and backend.detect():
+        return backend
+    
+    raise RuntimeError(f"Backend {backend_type} not available")
+
+
+def print_backend_info():
+    """Print information about detected backend"""
+    backend = detect_backend()
+    
+    print("=" * 60)
+    print("NEURATENSOR BACKEND INFORMATION")
+    print("=" * 60)
+    print(f"Backend:             {backend.name}")
+    print(f"Available:           {backend.available}")
+    
+    if backend.device_name:
+        print(f"Device:              {backend.device_name}")
+    
+    if backend.compute_capability:
+        print(f"Compute Capability:  {backend.compute_capability}")
+    
+    if torch.cuda.is_available():
+        print(f"CUDA Version:        {torch.version.cuda}")
+        print(f"PyTorch Version:     {torch.__version__}")
+        props = torch.cuda.get_device_properties(0)
+        print(f"Total Memory:        {props.total_memory / 1024**3:.1f} GB")
+    
+    print("=" * 60)

neuratensor/cli.py

@@ -0,0 +1,247 @@
+"""
+NeuraTensor CLI - Command Line Interface
+=========================================
+
+CLI tool for model management and inference.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__, NeuraTensor
+from .model_loader import ModelLoader
+from .config import NeuraTensorConfig
+
+
+def cmd_info(args):
+    """Display system and model information"""
+    print(f"NeuraTensor SDK v{__version__}")
+    print("-" * 50)
+    
+    # Import here to avoid loading CUDA if not needed
+    import torch
+    
+    print(f"PyTorch: {torch.__version__}")
+    print(f"CUDA Available: {torch.cuda.is_available()}")
+    
+    if torch.cuda.is_available():
+        print(f"CUDA Version: {torch.version.cuda}")
+        print(f"Device Name: {torch.cuda.get_device_name(0)}")
+        print(f"Device Count: {torch.cuda.device_count()}")
+
+
+def cmd_run(args):
+    """Run inference with a model"""
+    print(f"Loading model: {args.model}")
+    
+    # Load model
+    loader = ModelLoader()
+    model = loader.load(args.model, device=args.device)
+    
+    # Create inference engine
+    engine = InferenceEngine(model)
+    
+    # Prepare input
+    import torch
+    if args.input:
+        # Load input from file
+        input_data = torch.load(args.input)
+    else:
+        # Generate random input for testing
+        config = model.config
+        input_data = torch.randint(
+            0, config.vocab_size,
+            (1, args.seq_length),
+            device=args.device
+        )
+    
+    print(f"Running inference...")
+    result = engine.infer(input_data, return_logits=True)
+    
+    print(f"\nResults:")
+    print(f"  Latency: {result['latency_ms']:.2f}ms")
+    print(f"  Output shape: {result['logits'].shape}")
+    
+    if args.output:
+        torch.save(result, args.output)
+        print(f"  Saved to: {args.output}")
+
+
+def cmd_benchmark(args):
+    """Benchmark model performance"""
+    import torch
+    import statistics
+    
+    # Header
+    print("\n" + "=" * 60)
+    print(f"NeuraTensor {args.model.upper()} | Benchmark")
+    print("=" * 60)
+    
+    # Device info
+    if torch.cuda.is_available():
+        device_name = torch.cuda.get_device_name(0)
+        compute_cap = torch.cuda.get_device_capability(0)
+        print(f"Device:    {device_name} (SM {compute_cap[0]}.{compute_cap[1]})")
+        print(f"CUDA:      {torch.version.cuda}")
+    else:
+        print("Device:    CPU")
+    
+    print("-" * 60)
+    
+    # Load model using public API
+    from . import NeuraTensor, NeuraTensorConfig
+    
+    print(f"Loading {args.model} configuration...")
+    config = NeuraTensorConfig.preset(args.model)
+    model = NeuraTensor(config)
+    
+    if args.device == "cuda" and torch.cuda.is_available():
+        model = model.cuda().half()
+        print(f"✓ Model loaded on CUDA")
+    else:
+        print(f"✓ Model loaded on CPU")
+    
+    print(f"✓ Parameters: {model.count_parameters():,}")
+    print("-" * 60)
+    
+    # Prepare input
+    device = "cuda" if args.device == "cuda" and torch.cuda.is_available() else "cpu"
+    input_ids = torch.randint(
+        0,
+        config.vocab_size,
+        (args.batch_size, args.seq_length),
+        device=device
+    )
+    
+    # Warmup
+    print(f"Warming up ({args.warmup} iterations)...")
+    with torch.no_grad():
+        for _ in range(args.warmup):
+            _ = model(input_ids)
+            if device == "cuda":
+                torch.cuda.synchronize()
+    print("✓ Warmup complete")
+    
+    # Benchmark
+    print(f"Benchmarking ({args.iterations} iterations)...")
+    latencies = []
+    
+    with torch.no_grad():
+        for i in range(args.iterations):
+            if device == "cuda":
+                torch.cuda.synchronize()
+                start = torch.cuda.Event(enable_timing=True)
+                end = torch.cuda.Event(enable_timing=True)
+                
+                start.record()
+                output = model(input_ids)
+                end.record()
+                
+                torch.cuda.synchronize()
+                latency_ms = start.elapsed_time(end)
+            else:
+                import time
+                start = time.perf_counter()
+                output = model(input_ids)
+                end = time.perf_counter()
+                latency_ms = (end - start) * 1000
+            
+            latencies.append(latency_ms)
+            
+            if (i + 1) % 10 == 0:
+                print(f"  Progress: {i + 1}/{args.iterations}")
+    
+    # Calculate statistics
+    mean_lat = statistics.mean(latencies)
+    std_lat = statistics.stdev(latencies) if len(latencies) > 1 else 0
+    min_lat = min(latencies)
+    max_lat = max(latencies)
+    p99_lat = sorted(latencies)[int(len(latencies) * 0.99)]
+    throughput = 1000 / mean_lat * args.batch_size
+    
+    # Results
+    print("\n" + "=" * 60)
+    print("BENCHMARK RESULTS")
+    print("=" * 60)
+    print(f"Latency (mean):    {mean_lat:.2f} ms ± {std_lat:.2f} ms")
+    print(f"Latency (p99):     {p99_lat:.2f} ms")
+    print(f"Latency (min):     {min_lat:.2f} ms")
+    print(f"Latency (max):     {max_lat:.2f} ms")
+    print(f"Throughput:        {throughput:.1f} seq/s")
+    print(f"Batch size:        {args.batch_size}")
+    print(f"Sequence length:   {args.seq_length}")
+    print(f"Kernel:            fused_snn_ssm (secure)")
+    print("=" * 60)
+    print("✓ Benchmark complete")
+    print()
+
+
+def cmd_list(args):
+    """List available models"""
+    loader = ModelLoader()
+    models = loader.list_available_models()
+    
+    print("Available Models:")
+    print("-" * 50)
+    for model_name in models:
+        print(f"  - {model_name}")
+
+
+def main():
+    """Main CLI entry point"""
+    parser = argparse.ArgumentParser(
+        prog="neuratensor",
+        description="NeuraTensor SDK - Neuromorphic Tensor Processing"
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}"
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+    
+    # Info command
+    parser_info = subparsers.add_parser("info", help="Display system information")
+    parser_info.set_defaults(func=cmd_info)
+    
+    # Run command
+    parser_run = subparsers.add_parser("run", help="Run inference")
+    parser_run.add_argument("model", help="Model name or path")
+    parser_run.add_argument("--input", help="Input file path")
+    parser_run.add_argument("--output", help="Output file path")
+    parser_run.add_argument("--device", default="cuda", help="Device (cuda/cpu)")
+    parser_run.add_argument("--seq-length", type=int, default=64, help="Sequence length")
+    parser_run.set_defaults(func=cmd_run)
+    
+    # Benchmark command
+    parser_bench = subparsers.add_parser("benchmark", help="Benchmark model")
+    parser_bench.add_argument("model", help="Model name or path")
+    parser_bench.add_argument("--device", default="cuda", help="Device (cuda/cpu)")
+    parser_bench.add_argument("--batch-size", type=int, default=1, help="Batch size")
+    parser_bench.add_argument("--seq-length", type=int, default=64, help="Sequence length")
+    parser_bench.add_argument("--iterations", type=int, default=30, help="Number of iterations")
+    parser_bench.add_argument("--warmup", type=int, default=5, help="Warmup iterations")
+    parser_bench.set_defaults(func=cmd_benchmark)
+    
+    # List command
+    parser_list = subparsers.add_parser("list", help="List available models")
+    parser_list.set_defaults(func=cmd_list)
+    
+    # Parse and execute
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return 1
+    
+    try:
+        return args.func(args) or 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())