神经形态计算芯片在边缘AI推理中的突破性应用

neuromorphic_edge_ai_simulator/
├── README.md
├── requirements.txt
├── config.yaml
├── run_simulation.py
├── src/
│   ├── __init__.py
│   ├── data_generator.py
│   ├── neuron_models.py
│   ├── snn_layers.py
│   ├── event_simulator.py
│   ├── inference_engine.py
│   └── utils.py
├── tests/
│   ├── __init__.py
│   ├── test_neuron.py
│   └── test_inference.py
└── results/ (生成)
    ├── events_visualization.png
    └── membrane_potential_trace.png

numpy>=1.21.0
pyyaml>=6.0
matplotlib>=3.5.0
pytest>=7.0.0  # 用于运行测试

simulation:
  input_shape: [32, 32]          # 模拟DVS传感器的空间分辨率 (高度， 宽度)
  num_classes: 3                 # 手势类别数
  simulation_time_ms: 1000       # 模拟总时间（毫秒）
  time_step_ms: 1.0              # 模拟的最小时间步长（毫秒）

snn_model:
  tau_mem: 20.0                  # LIF神经元膜电位时间常数 (ms)
  v_thresh: 1.0                  # 发放阈值
  v_reset: 0.0                   # 重置电位
  refractory_period_ms: 5.0      # 不应期 (ms)

inference:
  # 这是一个简化的"预训练"权重和偏置矩阵，连接输入事件到10个隐藏神经元，再到3个输出神经元。
  # 在实际应用中，这些参数需要通过STDP等算法训练得到。
  weights_input_hidden: "random" # 可以是 "random" 或路径，此处为演示生成随机权重
  weights_hidden_output: "random"
  bias_hidden: 0.01
  bias_output: 0.01

data_generation:
  gesture_type: "swipe_right"    # 生成的手势类型： "swipe_left", "swipe_right", "circle"
  event_rate_hz: 500             # 平均事件生成频率 (Hz)
  noise_level: 0.1               # 事件噪声比例

visualization:
  plot_events: true
  plot_membrane: true
  dpi: 150

# 空文件，用于将src目录标记为Python包

import numpy as np
from typing import List, Tuple
import random

class DVSDataGenerator:
    """
    模拟动态视觉传感器（DVS）事件流生成器。
    生成简单手势（滑动、画圈）的事件序列。
    """
    def __init__(self, config: dict):
        self.height = config['input_shape'][0]
        self.width = config['input_shape'][1]
        self.gesture_type = config['gesture_type']
        self.event_rate = config['event_rate_hz'] # 事件/秒
        self.simulation_time_ms = config['simulation_time_ms']
        self.time_step_ms = config['time_step_ms']
        self.noise_level = config['noise_level']
        self.total_time_steps = int(self.simulation_time_ms / self.time_step_ms)

    def generate_events(self) -> List[Tuple[int, int, int, float]]:
        """
        生成事件列表。每个事件为 (x, y, polarity, timestamp_ms)。
        polarity: 1 表示亮度增加， -1 表示亮度减少。
        返回： 事件列表，按时间戳排序。
        """
        events = []
        num_gesture_events = int(self.event_rate * (self.simulation_time_ms / 1000.0))

        # 1. 生成手势主体事件
        if self.gesture_type == "swipe_right":
            events += self._generate_swipe_right(num_gesture_events)
        elif self.gesture_type == "swipe_left":
            events += self._generate_swipe_left(num_gesture_events)
        elif self.gesture_type == "circle":
            events += self._generate_circle(num_gesture_events)
        else:
            raise ValueError(f"未知手势类型: {self.gesture_type}")

        # 2. 添加随机噪声事件
        num_noise_events = int(num_gesture_events * self.noise_level)
        for _ in range(num_noise_events):
            x = random.randint(0, self.width - 1)
            y = random.randint(0, self.height - 1)
            pol = random.choice([-1, 1])
            t = random.uniform(0, self.simulation_time_ms)
            events.append((x, y, pol, t))

        # 3. 按时间戳排序
        events.sort(key=lambda e: e[3])
        return events

    def _generate_swipe_right(self, num_events: int) -> List[Tuple[int, int, int, float]]:
        """生成从左向右滑动的事件。"""
        events = []
        center_y = self.height // 2
        swipe_width = self.width // 2
        start_x = self.width // 4
        for i in range(num_events):
            progress = i / num_events
            x = int(start_x + progress * swipe_width)
            # 添加一些垂直方向的微小变化模拟自然手势
            y_variation = int((random.random() - 0.5) * 5)
            y = max(0, min(self.height - 1, center_y + y_variation))
            # 时间均匀分布在整个仿真期间
            t = progress * self.simulation_time_ms
            # 简单假设滑动产生正极性事件
            events.append((x, y, 1, t))
        return events

    def _generate_swipe_left(self, num_events: int) -> List[Tuple[int, int, int, float]]:
        """生成从右向左滑动的事件。"""
        events = []
        center_y = self.height // 2
        swipe_width = self.width // 2
        start_x = self.width * 3 // 4
        for i in range(num_events):
            progress = i / num_events
            x = int(start_x - progress * swipe_width)
            y_variation = int((random.random() - 0.5) * 5)
            y = max(0, min(self.height - 1, center_y + y_variation))
            t = progress * self.simulation_time_ms
            events.append((x, y, 1, t))
        return events

    def _generate_circle(self, num_events: int) -> List[Tuple[int, int, int, float]]:
        """生成画圈手势的事件。"""
        events = []
        center_x, center_y = self.width // 2, self.height // 2
        radius = min(self.width, self.height) // 4
        for i in range(num_events):
            angle = 2 * np.pi * (i / num_events)
            x = int(center_x + radius * np.cos(angle))
            y = int(center_y + radius * np.sin(angle))
            # 确保坐标在范围内
            x = max(0, min(self.width - 1, x))
            y = max(0, min(self.height - 1, y))
            t = (i / num_events) * self.simulation_time_ms
            events.append((x, y, 1, t))
        return events

import numpy as np

class LIFNeuron:
    """
    漏电积分发放 (Leaky Integrate-and-Fire) 神经元模型。
    这是一个简化版本，用于离散时间步模拟。
    """
    def __init__(self, tau_mem: float, v_thresh: float, v_reset: float, refractory_period_ms: float, dt_ms: float):
        """
        参数:
            tau_mem: 膜时间常数 (ms)
            v_thresh: 发放阈值
            v_reset: 重置电位
            refractory_period_ms: 不应期时长 (ms)
            dt_ms: 模拟时间步长 (ms)
        """
        self.tau_mem = tau_mem
        self.v_thresh = v_thresh
        self.v_reset = v_reset
        self.refractory_period = refractory_period_ms
        self.dt = dt_ms

        # 神经元状态
        self.v_mem = v_reset  # 膜电位
        self.last_spike_time = -refractory_period  # 上次发放时间，初始化为足够早
        self.spike_count = 0

        # 计算常数，用于优化
        self.exp_factor = np.exp(-dt_ms / tau_mem)
        self.resistance_factor = 1.0 # 简化，假设输入电流直接积分

    def reset(self):
        """重置神经元状态。"""
        self.v_mem = self.v_reset
        self.last_spike_time = -self.refractory_period
        self.spike_count = 0

    def step(self, current_input: float, current_time_ms: float) -> bool:
        """
        模拟神经元一个时间步的动态。
        参数:
            current_input: 当前时间步的输入电流（或来自其他神经元的加权脉冲）。
            current_time_ms: 当前仿真时间。
        返回:
            bool: 当前时间步是否发放了脉冲。
        """
        # 检查是否处于不应期
        time_since_last_spike = current_time_ms - self.last_spike_time
        if time_since_last_spike < self.refractory_period:
            self.v_mem = self.v_reset
            return False

        # 膜电位积分与漏电 (离散时间近似)
        # dv/dt = (-v + R*I) / tau
        # 离散解: v(t+dt) = v(t)*exp(-dt/tau) + R*I*(1 - exp(-dt/tau))
        # 简化: 令 R*I = current_input
        self.v_mem = self.v_mem * self.exp_factor + current_input * (1 - self.exp_factor)

        # 检查是否达到阈值
        if self.v_mem >= self.v_thresh:
            # 发放脉冲
            self.v_mem = self.v_reset
            self.last_spike_time = current_time_ms
            self.spike_count += 1
            return True
        return False

    def get_state(self):
        """返回当前神经元状态。"""
        return {
            'v_mem': self.v_mem,
            'last_spike_time': self.last_spike_time,
            'spike_count': self.spike_count
        }

import numpy as np
from .neuron_models import LIFNeuron
from typing import List

class EventInputLayer:
    """
    事件输入层。将DVS事件 (x, y, pol) 映射到输入神经元（或特征）。
    这里为了简化，我们将每个像素的两种极性（正/负）视为独立的输入通道。
    因此，输入维度为 height * width * 2。
    本层不包含可学习的参数，仅负责将稀疏事件转换为突触前输入。
    """
    def __init__(self, input_shape: List[int]):
        self.height, self.width = input_shape
        # 输入特征数：每个像素有正负两个极性通道
        self.num_features = self.height * self.width * 2

    def event_to_input_vector(self, event: tuple) -> np.ndarray:
        """
        将单个事件转换为一个稠密的输入向量（多数为0）。
        参数:
            event: (x, y, polarity, timestamp)
        返回:
            input_vec: 形状为 (num_features,) 的numpy数组，仅在对应位置为1或-1。
        """
        x, y, pol, _ = event
        # 计算一维索引
        if pol == 1:
            # 正极性通道
            idx = y * self.width * 2 + x * 2
            val = 1.0
        else: # pol == -1
            # 负极性通道
            idx = y * self.width * 2 + x * 2 + 1
            val = 1.0 # 我们也用正值表示事件发生，极性信息已由通道编码
        vec = np.zeros(self.num_features)
        vec[idx] = val
        return vec

class DenseSpikingLayer:
    """
    全连接脉冲神经元层。
    接受来自前一层（或输入层）的加权输入，包含一组LIF神经元。
    """
    def __init__(self, num_inputs: int, num_neurons: int, neuron_params: dict, dt_ms: float):
        self.num_neurons = num_neurons
        self.dt = dt_ms
        # 初始化权重和偏置
        # 注意：SNN中权重通常可正可负，表示兴奋/抑制性连接
        self.weights = np.random.randn(num_inputs, num_neurons) * 0.1
        self.bias = np.full(num_neurons, neuron_params.get('bias', 0.01))

        # 创建神经元池
        self.neurons = [
            LIFNeuron(
                tau_mem=neuron_params['tau_mem'],
                v_thresh=neuron_params['v_thresh'],
                v_reset=neuron_params['v_reset'],
                refractory_period_ms=neuron_params['refractory_period_ms'],
                dt_ms=dt_ms
            ) for _ in range(num_neurons)
        ]

        # 记录每次的脉冲输出，用于后续学习或分析
        self.spike_history = [] # 列表，每个元素是时间步的脉冲数组

    def reset(self):
        """重置层内所有神经元状态。"""
        for neuron in self.neurons:
            neuron.reset()
        self.spike_history.clear()

    def forward(self, input_vector: np.ndarray, current_time_ms: float) -> np.ndarray:
        """
        前向传播一步。
        参数:
            input_vector: 当前输入向量，形状 (num_inputs,)
            current_time_ms: 当前时间
        返回:
            spikes: 当前时间步神经元的脉冲输出，形状 (num_neurons,)，元素为0或1。
        """
        # 计算总输入电流： I = W^T * x + b (事件驱动下，x通常是稀疏的)
        # 这里我们做完整计算以简化，在实际芯片中，这是稀疏矩阵向量乘。
        synaptic_current = np.dot(input_vector, self.weights) + self.bias

        spikes = np.zeros(self.num_neurons, dtype=np.int8)
        for i in range(self.num_neurons):
            if self.neurons[i].step(synaptic_current[i], current_time_ms):
                spikes[i] = 1

        self.spike_history.append(spikes.copy())
        return spikes

import numpy as np
from typing import List
from .data_generator import DVSDataGenerator
from .snn_layers import EventInputLayer, DenseSpikingLayer

class EventDrivenSNNSimulator:
    """
    事件驱动的SNN模拟器核心。
    它不按固定时间步迭代，而是按事件的时间戳推进。
    在事件之间，神经元状态根据漏电方程衰减（但本简化版本仅在事件到达时更新目标神经元）。
    """
    def __init__(self, config: dict):
        self.config = config
        self.input_shape = config['input_shape']
        self.simulation_time_ms = config['simulation_time_ms']

        # 初始化组件
        self.data_gen = DVSDataGenerator(config['data_generation'])
        self.input_layer = EventInputLayer(self.input_shape)
        num_input_features = self.input_layer.num_features

        # 构建一个简单的两层SNN: 输入 -> 隐藏层 -> 输出层
        neuron_common_params = config['snn_model']

        self.hidden_layer = DenseSpikingLayer(
            num_inputs=num_input_features,
            num_neurons=10, # 隐藏神经元数量
            neuron_params=neuron_common_params,
            dt_ms=config['simulation']['time_step_ms']
        )

        self.output_layer = DenseSpikingLayer(
            num_inputs=10,
            num_neurons=config['simulation']['num_classes'],
            neuron_params=neuron_common_params,
            dt_ms=config['simulation']['time_step_ms']
        )

        # 状态记录
        self.events = []
        self.hidden_spikes_over_time = []
        self.output_spikes_over_time = []
        self.current_time_ms = 0.0
        self.compute_operations = 0 # 模拟计算操作计数

    def reset(self):
        """重置模拟器状态。"""
        self.hidden_layer.reset()
        self.output_layer.reset()
        self.events = []
        self.hidden_spikes_over_time.clear()
        self.output_spikes_over_time.clear()
        self.current_time_ms = 0.0
        self.compute_operations = 0

    def run_simulation(self):
        """运行完整的模拟。"""
        self.reset()
        # 1. 生成事件流
        self.events = self.data_gen.generate_events()
        print(f"生成 {len(self.events)} 个事件.")

        # 2. 按事件时间戳顺序处理
        last_processed_time = 0.0
        for event_idx, event in enumerate(self.events):
            x, y, pol, event_time_ms = event
            self.current_time_ms = event_time_ms

            # ** 事件驱动计算的核心 **
            # a) 将事件转换为输入特征向量 (稀疏 -> 稠密，仅用于演示)
            input_vec = self.input_layer.event_to_input_vector(event)
            # 统计操作： 一次向量化索引赋值 (O(1))，实际芯片是路由到特定神经元
            self.compute_operations += 1

            # b) 隐藏层前向传播 (使用当前输入向量)
            #    注意： 这里我们假设事件输入只影响与该事件像素相关的权重连接。
            #    在真实稀疏计算中，只有相关的权重列被激活。
            #    我们模拟为一次稠密计算以简化，但记录操作数时考虑稀疏性。
            num_active_inputs = 1 # 每个事件只激活一个输入特征
            hidden_spikes = self.hidden_layer.forward(input_vec, event_time_ms)
            # 统计操作: 模拟稀疏点积 (num_active_inputs * num_hidden_neurons) 次乘加
            self.compute_operations += num_active_inputs * self.hidden_layer.num_neurons

            # c) 输出层前向传播 (如果隐藏层有神经元发放)
            if np.any(hidden_spikes):
                output_spikes = self.output_layer.forward(hidden_spikes, event_time_ms)
                # 统计操作: 只有发放脉冲的隐藏神经元才参与计算
                num_active_hidden = np.sum(hidden_spikes)
                self.compute_operations += int(num_active_hidden) * self.output_layer.num_neurons
            else:
                output_spikes = np.zeros(self.output_layer.num_neurons)

            # 记录该事件时刻的脉冲 (可选，如果精确到每个事件)
            self.hidden_spikes_over_time.append((event_time_ms, hidden_spikes.copy()))
            self.output_spikes_over_time.append((event_time_ms, output_spikes.copy()))

            # 打印进度
            if (event_idx + 1) % 100 == 0:
                print(f"处理事件 {event_idx + 1}/{len(self.events)}， 时间: {event_time_ms:.1f}ms")

        print(f"模拟完成。总计算操作（模拟）: {self.compute_operations}")
        return self._get_inference_result()

    def _get_inference_result(self):
        """
        根据输出层神经元的累计脉冲数决定分类结果。
        脉冲发放最多的神经元对应的类别即为预测结果。
        """
        # 收集所有输出脉冲
        total_output_spikes = np.zeros(self.output_layer.num_neurons)
        for _, spikes in self.output_spikes_over_time:
            total_output_spikes += spikes

        predicted_class = int(np.argmax(total_output_spikes))
        confidence = total_output_spikes[predicted_class] / (np.sum(total_output_spikes) + 1e-8)
        return {
            'predicted_class': predicted_class,
            'confidence': confidence,
            'total_spikes_per_neuron': total_output_spikes.tolist(),
            'total_compute_ops': self.compute_operations
        }

import yaml
import numpy as np
import matplotlib.pyplot as plt
from .event_simulator import EventDrivenSNNSimulator

class NeuroomorphicInferenceEngine:
    """
    高级推理引擎，封装模拟器，提供配置加载、运行和结果可视化功能。
    """
    def __init__(self, config_path: str = 'config.yaml'):
        with open(config_path, 'r') as f:
            self.config = yaml.safe_load(f)
        self.simulator = EventDrivenSNNSimulator(self.config)

    def run(self):
        """运行一次完整的推理模拟。"""
        print("="*50)
        print("启动神经形态边缘AI推理模拟...")
        print(f"手势类型: {self.config['data_generation']['gesture_type']}")
        print(f"输入分辨率: {self.config['simulation']['input_shape']}")
        print("="*50)

        result = self.simulator.run_simulation()

        print("\n" + "="*50)
        print("推理结果:")
        print(f"  预测类别: {result['predicted_class']}")
        class_names = ["Swipe_Left", "Swipe_Right", "Circle"]
        print(f"  解释: {class_names[result['predicted_class']]}")
        print(f"  置信度 (基于脉冲数): {result['confidence']:.3f}")
        print(f"  各输出神经元总脉冲数: {result['total_spikes_per_neuron']}")
        print(f"  模拟计算操作总数: {result['total_compute_ops']}")
        print("="*50)

        # 对比传统CNN的粗略估计 (假设每帧全连接稠密计算)
        self._print_efficiency_comparison(result['total_compute_ops'])
        return result

    def _print_efficiency_comparison(self, snn_ops: int):
        """与传统帧-based CNN进行能效对比的粗略模拟。"""
        input_pixels = self.config['simulation']['input_shape'][0] * self.config['simulation']['input_shape'][1]
        # 假设一个简单的CNN分类器，输入层->隐藏层(10)->输出层(3)，使用全连接。
        # 对于一帧图像，计算量为 input_pixels * 10 + 10 * 3 (忽略激活函数)。
        ops_per_frame = input_pixels * 10 + 10 * 3
        # 假设CNN以30FPS处理，总仿真时间内需要处理的帧数
        fps = 30
        num_frames = fps * (self.config['simulation']['simulation_time_ms'] / 1000.0)
        cnn_total_ops = ops_per_frame * num_frames

        print("\n能效对比 (粗略估计):")
        print(f"  模拟SNN总操作: {snn_ops}")
        print(f"  等效CNN ({fps} FPS) 总操作: ~{int(cnn_total_ops)}")
        if cnn_total_ops > 0:
            ratio = cnn_total_ops / max(snn_ops, 1)
            print(f"  CNN操作数 / SNN操作数 ≈ {ratio:.1f}x")
            print("  **注: 此比较高度简化，真实芯片优势可能达1000x以上。**")

    def visualize(self, result: dict, save_path: str = './results'):
        """可视化事件、脉冲活动和膜电位。"""
        import os
        os.makedirs(save_path, exist_ok=True)

        config = self.config
        events = self.simulator.events
        hidden_spikes_rec = self.simulator.hidden_spikes_over_time
        output_spikes_rec = self.simulator.output_spikes_over_time

        # 1. 可视化输入事件 (散点图)
        if config['visualization']['plot_events']:
            fig, ax = plt.subplots(1, 2, figsize=(12, 5))
            # 左图：事件在空间中的分布
            times = [e[3] for e in events]
            xs = [e[0] for e in events]
            ys = [e[1] for e in events]
            colors = ['red' if e[2]==1 else 'blue' for e in events]
            sc1 = ax[0].scatter(xs, ys, c=colors, s=5, alpha=0.6, edgecolors='none')
            ax[0].invert_yaxis() # 图像坐标系
            ax[0].set_xlabel('X pixel')
            ax[0].set_ylabel('Y pixel')
            ax[0].set_title(f'DVS Event Map (Gesture: {config["data_generation"]["gesture_type"]})')
            # 添加图例
            import matplotlib.patches as mpatches
            red_patch = mpatches.Patch(color='red', label='ON (+1)')
            blue_patch = mpatches.Patch(color='blue', label='OFF (-1)')
            ax[0].legend(handles=[red_patch, blue_patch])

            # 右图：事件的时间分布
            ax[1].scatter(times, [1]*len(times), c=colors, s=5, alpha=0.6)
            ax[1].set_xlabel('Time (ms)')
            ax[1].set_yticks([])
            ax[1].set_title('Event Timeline')
            plt.tight_layout()
            plt.savefig(f'{save_path}/events_visualization.png', dpi=config['visualization']['dpi'])
            print(f"事件图已保存至: {save_path}/events_visualization.png")
            # plt.show()
            plt.close(fig)

        # 2. 可视化膜电位 (选择一个隐藏层神经元)
        if config['visualization']['plot_membrane'] and hasattr(self.simulator.hidden_layer.neurons[0], 'v_mem'):
            # 注意：我们的模拟只在事件时刻更新神经元，所以膜电位轨迹不是连续的。
            # 我们可以记录每次事件后某个神经元的膜电位。
            neuron_idx = 0
            mem_potentials = []
            event_times_for_plot = []
            # 简化：我们取第一次事件处理后的膜电位
            # 实际需要一个更精细的模拟器来记录状态历史。
            print("(膜电位可视化在此简化版本中受限，需更精细的状态记录。)")
            # 这里我们仅示意一个静态图
            fig, ax = plt.subplots(figsize=(10,4))
            # 假设一个衰减和积分的过程
            t_vals = np.linspace(0, config['simulation']['simulation_time_ms'], 200)
            v_vals = []
            v = 0.0
            tau = config['snn_model']['tau_mem']
            for t in t_vals:
                # 模拟随机输入事件
                if np.random.rand() < 0.02:
                    v += 0.3 # 事件输入
                v = v * np.exp(-1/tau) # 漏电
                if v > config['snn_model']['v_thresh']:
                    v = config['snn_model']['v_reset']
                v_vals.append(v)
            ax.plot(t_vals, v_vals, label=f'Neuron {neuron_idx} Membrane Potential')
            ax.axhline(y=config['snn_model']['v_thresh'], color='r', linestyle='--', label='Threshold')
            ax.axhline(y=config['snn_model']['v_reset'], color='g', linestyle='--', label='Reset')
            ax.set_xlabel('Time (ms)')
            ax.set_ylabel('Membrane Potential')
            ax.set_title('Example LIF Neuron Dynamics (Conceptual)')
            ax.legend()
            ax.grid(True, alpha=0.3)
            plt.tight_layout()
            plt.savefig(f'{save_path}/membrane_potential_trace.png', dpi=config['visualization']['dpi'])
            print(f"膜电位示意图已保存至: {save_path}/membrane_potential_trace.png")
            # plt.show()
            plt.close(fig)

import numpy as np

def softmax(x):
    """Softmax函数，用于将脉冲计数转换为概率（可选）。"""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)

def decode_class_label(predicted_class_idx: int, class_names: list = None):
    """将预测的类别索引解码为可读标签。"""
    if class_names is None:
        class_names = ["Swipe_Left", "Swipe_Right", "Circle"]
    if 0 <= predicted_class_idx < len(class_names):
        return class_names[predicted_class_idx]
    else:
        return f"Unknown_Class_{predicted_class_idx}"

#!/usr/bin/env python3
"""
神经形态边缘AI推理模拟器 - 主运行脚本。
"""
import sys
import argparse
from src.inference_engine import NeuroomorphicInferenceEngine

def main():
    parser = argparse.ArgumentParser(description='运行神经形态SNN边缘推理模拟。')
    parser.add_argument('--config', type=str, default='config.yaml',
                        help='配置文件路径 (默认: config.yaml)')
    parser.add_argument('--gesture', type=str, choices=['swipe_left', 'swipe_right', 'circle'],
                        help='覆盖配置文件中指定的手势类型')
    parser.add_argument('--no-viz', action='store_true',
                        help='禁用可视化')

    args = parser.parse_args()

    # 加载引擎
    engine = NeuroomorphicInferenceEngine(config_path=args.config)

    # 覆盖手势配置（如果通过命令行指定）
    if args.gesture:
        engine.config['data_generation']['gesture_type'] = args.gesture
        print(f"手势类型被覆盖为: {args.gesture}")

    # 运行模拟
    result = engine.run()

    # 可视化（除非禁用）
    if not args.no_viz:
        engine.visualize(result)

    # 简单判断是否正确（基于生成的手势类型）
    gesture_map = {'swipe_left': 0, 'swipe_right': 1, 'circle': 2}
    expected_class = gesture_map.get(engine.config['data_generation']['gesture_type'])
    if expected_class is not None:
        if result['predicted_class'] == expected_class:
            print("\n✅ 模拟成功：预测与生成的手势类型一致。")
        else:
            print(f"\n⚠️  模拟结果：预测类别({result['predicted_class']})与生成手势({expected_class})不一致。")
            print("   这在意料之中，因为网络权重是随机的，并未经过训练。")
    else:
        print("\n⚠️  无法验证结果，未知的手势类型。")

if __name__ == '__main__':
    main()

# 空文件，用于将tests目录标记为Python包

import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

import numpy as np
from src.neuron_models import LIFNeuron

def test_lif_neuron_integration():
    """测试LIF神经元的积分与发放行为。"""
    dt = 1.0 # ms
    neuron = LIFNeuron(tau_mem=10.0, v_thresh=1.0, v_reset=0.0, refractory_period_ms=2.0, dt_ms=dt)

    # 测试1: 无输入，膜电位应漏电至0
    neuron.reset()
    for i in range(10):
        spiked = neuron.step(0.0, i*dt)
        assert not spiked, f"无输入时不应发放脉冲，但在步 {i} 发放。"
    assert neuron.v_mem < 0.1, f"膜电位应漏电至接近0，实际为 {neuron.v_mem}"

    # 测试2: 恒定强输入，应快速发放脉冲
    neuron.reset()
    spike_times = []
    for i in range(20):
        t = i * dt
        spiked = neuron.step(0.5, t) # 强输入
        if spiked:
            spike_times.append(t)
    # 由于不应期，发放频率不应过高
    assert len(spike_times) > 0, "在强输入下应至少发放一次脉冲。"
    print(f"测试通过: 强输入下在时间 {spike_times} 发放脉冲。")

    # 测试3: 不应期测试
    neuron.reset()
    # 诱导一次发放
    neuron.step(10.0, 0.0) # 超强输入，确保发放
    # 紧接着在不应期内给予另一个强输入
    spiked_in_refractory = neuron.step(10.0, 0.5) # 0.5ms < 2ms 不应期
    assert not spiked_in_refractory, "神经元在不应期内不应再次发放。"

    print("所有神经元单元测试通过。")

if __name__ == '__main__':
    test_lif_neuron_integration()

import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

import yaml
import tempfile
from src.event_simulator import EventDrivenSNNSimulator

def test_simulator_runs():
    """测试模拟器能否成功运行一轮而不崩溃。"""
    # 创建一个最小配置
    config = {
        'simulation': {
            'input_shape': [8, 8],
            'num_classes': 2,
            'simulation_time_ms': 50,
            'time_step_ms': 1.0
        },
        'snn_model': {
            'tau_mem': 20.0,
            'v_thresh': 1.0,
            'v_reset': 0.0,
            'refractory_period_ms': 5.0
        },
        'data_generation': {
            'gesture_type': 'swipe_right',
            'event_rate_hz': 100,
            'noise_level': 0.05
        }
    }

    simulator = EventDrivenSNNSimulator(config)
    result = simulator.run_simulation()

    # 基本断言
    assert 'predicted_class' in result
    assert 'confidence' in result
    assert 'total_spikes_per_neuron' in result
    assert len(result['total_spikes_per_neuron']) == config['simulation']['num_classes']
    assert isinstance(result['total_compute_ops'], (int, float))

    print(f"模拟器运行测试通过。预测类别: {result['predicted_class']}, 操作数: {result['total_compute_ops']}")

if __name__ == '__main__':
    test_simulator_runs()

mkdir neuromorphic_edge_ai_simulator
    cd neuromorphic_edge_ai_simulator

pip install -r requirements.txt

python run_simulation.py

python run_simulation.py --gesture circle

python run_simulation.py --no-viz

cp config.yaml my_config.yaml
    # 编辑 my_config.yaml，例如修改分辨率或仿真时间
    python run_simulation.py --config my_config.yaml

# 运行所有测试
pytest tests/

# 运行特定测试文件
pytest tests/test_neuron.py -v

# 直接运行测试脚本（如果不想用pytest）
python tests/test_neuron.py
python tests/test_inference.py