Python 百萬神經元的皮層活動模擬：從原理到實現

百萬神經元的皮層活動模擬：從原理到實現

摘要

本文將深入探討如何使用Python構建大規模神經網絡模擬，實現百萬級神經元皮層活動的計算建模。我們將從神經科學基礎出發，逐步構建完整的模擬框架，並提供高效計算策略以應對大規模模擬的挑戰。

1. 神經科學基礎與建模原理

1.1 生物神經元的計算模型

大腦皮層神經元通常採用泄露積累發放模型(Leaky Integrate-and-Fire, LIF) 進行建模：

python

import numpy as np from typing import Dict, List, Tuple, Optional import numba from dataclasses import dataclass @dataclass class NeuronParameters: """神經元參數配置""" tau_m: float = 20.0 # 膜時間常數 (ms) v_rest: float = -65.0 # 靜息電位 (mV) v_reset: float = -65.0 # 重置電位 (mV) v_thresh: float = -50.0 # 閾值電位 (mV) r_m: float = 1.0 # 膜電阻 (MΩ) c_m: float = 20.0 # 膜電容 (pF) refrac_period: int = 5 # 不應期 (ms)

1.2 突觸模型與連接性

皮層神經元之間的連接具有複雜的拓撲結構：

python

@dataclass class SynapseParameters: """突觸參數配置""" tau_s: float = 5.0 # 突觸時間常數 (ms) e_rev: float = 0.0 # 反轉電位 (mV) w: float = 0.5 # 突觸權重 (nS) delay: int = 1 # 傳輸延遲 (ms)

2. 大規模神經網絡架構設計

2.1 分層皮層結構

python

class CorticalColumn: """皮層柱模型 - 基本功能單元""" def __init__(self, num_neurons: int = 1000, layers: Dict[str, Tuple[int, int]] = None): self.num_neurons = num_neurons # 默認分層結構 (L2/3, L4, L5, L6) if layers is None: self.layers = { 'L23': (0, 250), # 層2/3 'L4': (250, 500), # 層4 'L5': (500, 750), # 層5 'L6': (750, 1000) # 層6 } # 初始化神經元群組 self.neurons = self._initialize_neurons() self.synapses = self._initialize_synapses() def _initialize_neurons(self) -> np.ndarray: """初始化神經元狀態矩陣""" # 狀態矩陣: [電壓, 恢復變量, 不應期計數器] return np.zeros((self.num_neurons, 3), dtype=np.float32) def _initialize_synapses(self): """初始化突觸連接""" # 稀疏連接矩陣 - 節省記憶體 from scipy import sparse # 皮層內連接概率 (~10%) connection_prob = 0.1 n = self.num_neurons # 創建稀疏連接矩陣 connections = sparse.random(n, n, density=connection_prob, format='csr', dtype=np.float32) # 應用層特異性連接規則 connections = self._apply_layer_specific_rules(connections) return connections

2.2 百萬神經元網絡實現

python

class LargeScaleCorticalNetwork: """百萬級神經元皮層網絡""" def __init__(self, total_neurons: int = 1_000_000, num_columns: int = 1000, use_gpu: bool = False): self.total_neurons = total_neurons self.num_columns = num_columns self.use_gpu = use_gpu # 分佈式神經元到皮層柱 neurons_per_column = total_neurons // num_columns # 初始化皮層柱 self.columns = [ CorticalColumn(neurons_per_column) for _ in range(num_columns) ] # 柱間連接 self.inter_column_connections = self._create_intercolumn_connections() # 時間步追蹤 self.timestep = 0 # 活動記錄 self.activity_history = [] # 初始化計算後端 if use_gpu: self._init_gpu_backend() def _create_intercolumn_connections(self) -> sparse.csr_matrix: """創建皮層柱間連接""" # 使用小世界網絡拓撲 from networkx import watts_strogatz_graph import networkx as nx # 創建小世界網絡 G = watts_strogatz_graph(self.num_columns, 4, 0.3) # 轉換為連接矩陣 adj_matrix = nx.to_scipy_sparse_array(G, format='csr') return adj_matrix

3. 高效計算策略

3.1 使用Numba進行JIT編譯

python

@numba.jit(nopython=True, parallel=True) def update_neurons_numba(neurons: np.ndarray, inputs: np.ndarray, params: Dict, dt: float = 0.1) -> Tuple[np.ndarray, np.ndarray]: """使用Numba加速的神經元更新函數""" n_neurons = neurons.shape[0] v = neurons[:, 0] # 電壓 u = neurons[:, 1] # 恢復變量 refrac = neurons[:, 2] # 不應期計數器 # 參數 tau_m = params['tau_m'] v_rest = params['v_rest'] v_reset = params['v_reset'] v_thresh = params['v_thresh'] r_m = params['r_m'] # 預分配輸出 spikes = np.zeros(n_neurons, dtype=np.bool_) new_v = np.zeros_like(v) new_u = np.zeros_like(u) new_refrac = np.zeros_like(refrac) # 並行更新所有神經元 for i in numba.prange(n_neurons): if refrac[i] > 0: # 不應期內的神經元 new_v[i] = v_reset new_refrac[i] = refrac[i] - 1 else: # LIF模型更新 dv = (-(v[i] - v_rest) + r_m * inputs[i]) / tau_m new_v[i] = v[i] + dv * dt # 檢查是否發放 if new_v[i] >= v_thresh: spikes[i] = True new_v[i] = v_reset new_refrac[i] = params['refrac_period'] else: new_refrac[i] = 0 # 組裝新的神經元狀態 new_neurons = np.zeros_like(neurons) new_neurons[:, 0] = new_v new_neurons[:, 1] = new_u new_neurons[:, 2] = new_refrac return new_neurons, spikes

3.2 稀疏矩陣運算優化

python

class SparseNetworkSimulator: """稀疏網絡模擬器 - 高效處理大規模連接""" def __init__(self, num_neurons: int): self.num_neurons = num_neurons # 使用壓縮稀疏行格式 (CSR) self.connections = sparse.csr_matrix( (num_neurons, num_neurons), dtype=np.float32 ) # 突觸延遲緩衝區 self.delay_buffers = [] def propagate_spikes(self, spikes: np.ndarray) -> np.ndarray: """傳播尖峰信號 - 優化版本""" # 找出發放神經元的索引 spike_indices = np.where(spikes)[0] if len(spike_indices) == 0: return np.zeros(self.num_neurons, dtype=np.float32) # 使用稀疏矩陣的行切片高效計算 post_synaptic_input = np.zeros(self.num_neurons, dtype=np.float32) # 只對發放的神經元進行計算 for idx in spike_indices: # 獲取該神經元的突觸權重 start = self.connections.indptr[idx] end = self.connections.indptr[idx + 1] post_indices = self.connections.indices[start:end] weights = self.connections.data[start:end] # 累加突觸後輸入 post_synaptic_input[post_indices] += weights return post_synaptic_input

4. 完整模擬框架

4.1 主模擬引擎

python

class CorticalSimulation: """皮層活動主模擬引擎""" def __init__(self, network: LargeScaleCorticalNetwork, simulation_time: float = 1000.0, # ms dt: float = 0.1): # ms self.network = network self.simulation_time = simulation_time self.dt = dt self.num_steps = int(simulation_time / dt) # 監測器配置 self.monitors = { 'spike_monitor': SpikeMonitor(), 'voltage_monitor': VoltageMonitor(), 'field_potential_monitor': LFPMonitor(), 'connectivity_monitor': ConnectivityMonitor() } # 可視化工具 self.visualizer = NetworkVisualizer() def run(self) -> Dict: """執行完整模擬""" print(f"開始模擬: {self.network.total_neurons:,} 神經元") print(f"模擬時間: {self.simulation_time} ms, 時間步長: {self.dt} ms") # 預分配記憶體用於記錄 spike_trains = [] voltage_samples = [] # 主模擬循環 for step in range(self.num_steps): current_time = step * self.dt # 更新所有皮層柱 for i, column in enumerate(self.network.columns): # 計算外部輸入 (可加入刺激) external_input = self._generate_external_input( i, current_time ) # 更新神經元狀態 new_neurons, spikes = update_neurons_numba( column.neurons, external_input, column.params, self.dt ) column.neurons = new_neurons # 處理突觸傳播 synaptic_input = column.propagate_spikes(spikes) # 記錄數據 if step % 10 == 0: # 每10步記錄一次 self._record_data(i, spikes, column.neurons[:, 0]) # 更新監測器 for monitor in self.monitors.values(): monitor.update(spikes, column.neurons, current_time) # 柱間通信 if step % 5 == 0: # 每5步同步一次 self._synchronize_columns() # 進度顯示 if step % 1000 == 0: progress = (step / self.num_steps) * 100 print(f"進度: {progress:.1f}%") # 分析結果 results = self._analyze_results() return results def _generate_external_input(self, column_idx: int, time: float) -> np.ndarray: """生成外部輸入（可配置為感覺輸入或隨機噪聲）""" # 基本噪聲輸入 base_noise = np.random.normal(0, 0.5, self.network.columns[0].num_neurons) # 可選的節律性輸入（如theta振蕩） theta_rhythm = 0.3 * np.sin(2 * np.pi * 8 * time / 1000) # 空間調製 spatial_modulation = np.sin( np.linspace(0, 2*np.pi, self.network.columns[0].num_neurons) ) return base_noise + theta_rhythm * spatial_modulation def _synchronize_columns(self): """同步皮層柱間的活動""" # 實現柱間信息交換 pass

4.2 數據記錄與分析

python

class DataRecorder: """高效數據記錄器""" def __init__(self, max_steps: int, num_neurons: int): # 使用記憶體映射文件處理大數據 self.spike_file = np.memmap( 'spikes.dat', dtype=np.bool_, mode='w+', shape=(max_steps // 10, num_neurons // 100) # 下采樣 ) self.voltage_file = np.memmap( 'voltages.dat', dtype=np.float32, mode='w+', shape=(max_steps // 100, num_neurons // 1000) # 下采樣 ) def record_spikes(self, step: int, spikes: np.ndarray): """記錄尖峰活動（下采樣以節省空間）""" if step % 10 == 0: idx = step // 10 sampled_spikes = spikes[::100] # 每100個神經元取一個 self.spike_file[idx, :len(sampled_spikes)] = sampled_spikes def record_voltages(self, step: int, voltages: np.ndarray): """記錄膜電位（下采樣）""" if step % 100 == 0: idx = step // 100 sampled_voltages = voltages[::1000] # 每1000個神經元取一個 self.voltage_file[idx, :len(sampled_voltages)] = sampled_voltages

5. 可視化與分析工具

5.1 實時可視化

python

import matplotlib.pyplot as plt from matplotlib.animation import FuncAnimation import plotly.graph_objects as go from plotly.subplots import make_subplots class NetworkVisualizer: """網絡活動可視化""" def __init__(self): self.fig = None self.animation = None def create_raster_plot(self, spike_data: np.ndarray, time_range: Tuple[float, float]): """創建尖峰發放光柵圖""" fig, ax = plt.subplots(figsize=(15, 8)) # 找出尖峰時間和神經元索引 spike_times, neuron_indices = np.where(spike_data) # 繪製光柵圖 ax.scatter(spike_times * 0.1, neuron_indices, s=1, c='black', alpha=0.5) ax.set_xlabel('時間 (ms)') ax.set_ylabel('神經元索引') ax.set_title('神經網絡尖峰發放光柵圖') return fig def create_network_graph(self, connectivity: sparse.csr_matrix, neuron_positions: np.ndarray, activity: np.ndarray): """創建網絡連接可視化""" fig = go.Figure() # 繪製神經元節點（顏色編碼活動水平） fig.add_trace(go.Scatter3d( x=neuron_positions[:, 0], y=neuron_positions[:, 1], z=neuron_positions[:, 2], mode='markers', marker=dict( size=3, color=activity, colorscale='Viridis', opacity=0.8 ), name='神經元' )) # 繪製突觸連接（只繪製部分避免雜亂） connections = self._sample_connections(connectivity, 0.01) for i, j in connections: fig.add_trace(go.Scatter3d( x=[neuron_positions[i, 0], neuron_positions[j, 0]], y=[neuron_positions[i, 1], neuron_positions[j, 1]], z=[neuron_positions[i, 2], neuron_positions[j, 2]], mode='lines', line=dict(color='rgba(150, 150, 150, 0.1)', width=0.5), showlegend=False )) fig.update_layout( title='三維神經網絡結構', scene=dict( xaxis_title='X', yaxis_title='Y', zaxis_title='層' ) ) return fig

5.2 分析工具集

python

class NetworkAnalyzer: """網絡活動分析工具""" @staticmethod def compute_firing_rates(spike_data: np.ndarray, dt: float, window_size: float = 50.0) -> np.ndarray: """計算發放率""" window_steps = int(window_size / dt) num_neurons = spike_data.shape[1] num_windows = spike_data.shape[0] // window_steps firing_rates = np.zeros((num_windows, num_neurons)) for w in range(num_windows): start = w * window_steps end = start + window_steps window_spikes = spike_data[start:end, :] # 計算每個神經元的發放率 firing_rates[w, :] = np.sum(window_spikes, axis=0) / (window_size / 1000) return firing_rates @staticmethod def compute_synchrony(spike_data: np.ndarray) -> Dict: """計算網絡同步性指標""" # 總尖峰數 total_spikes = np.sum(spike_data) # 尖峰時間方差 spike_times = np.where(spike_data)[0] if len(spike_times) > 0: synchrony_index = 1.0 / (np.std(spike_times) + 1e-10) else: synchrony_index = 0 # 計算交叉關聯 cross_corr = np.corrcoef(spike_data.T) return { 'total_spikes': total_spikes, 'synchrony_index': synchrony_index, 'mean_correlation': np.nanmean(cross_corr) } @staticmethod def detect_oscillations(firing_rates: np.ndarray, dt: float, fs: float = 1000.0) -> Dict: """檢測振蕩活動""" from scipy import signal # 計算頻譜 frequencies, powers = {}, {} for i in range(min(100, firing_rates.shape[1])): # 取樣本神經元 f, Pxx = signal.welch(firing_rates[:, i], fs=fs, nperseg=min(256, len(firing_rates[:, i]))) # 識別頻段峰值 bands = { 'delta': (1, 4), 'theta': (4, 8), 'alpha': (8, 12), 'beta': (12, 30), 'gamma': (30, 80) } band_powers = {} for band, (low, high) in bands.items(): mask = (f >= low) & (f <= high) if np.any(mask): band_powers[band] = np.trapz(Pxx[mask], f[mask]) frequencies[i] = f powers[i] = band_powers return { 'frequencies': frequencies, 'band_powers': powers }

6. 性能優化與並行計算

6.1 GPU加速（可選）

python

try: import cupy as cp import cupyx.scipy.sparse as csparse class GPUNetworkSimulator: """GPU加速的網絡模擬器""" def __init__(self, num_neurons: int): self.num_neurons = num_neurons # 在GPU上初始化數據 self.neurons_gpu = cp.zeros((num_neurons, 3), dtype=cp.float32) self.spikes_gpu = cp.zeros(num_neurons, dtype=cp.bool_) # GPU稀疏矩陣 self.connections_gpu = csparse.csr_matrix( (num_neurons, num_neurons), dtype=cp.float32 ) def update_gpu(self, dt: float) -> cp.ndarray: """GPU上的神經元更新""" # 自定義CUDA內核 kernel_code = ''' extern "C" __global__ void update_neurons(float* v, float* u, float* refrac, const float* inputs, bool* spikes, float dt, int n_neurons, float tau_m, float v_rest, float v_reset, float v_thresh, float r_m, int refrac_period) { int idx = blockIdx.x * blockDim.x + threadIdx.x; if (idx < n_neurons) { if (refrac[idx] > 0) { v[idx] = v_reset; refrac[idx] -= 1; spikes[idx] = false; } else { // LIF模型 float dv = (-(v[idx] - v_rest) + r_m * inputs[idx]) / tau_m; v[idx] += dv * dt; // 檢查閾值 if (v[idx] >= v_thresh) { spikes[idx] = true; v[idx] = v_reset; refrac[idx] = refrac_period; } else { spikes[idx] = false; } } } } ''' # 編譯和執行CUDA內核 # ... GPU特定實現 ... return self.spikes_gpu except ImportError: print("CuPy未安裝，GPU加速不可用")

6.2 多進程並行

python

from multiprocessing import Pool, cpu_count import concurrent.futures class ParallelSimulator: """多進程並行模擬""" def __init__(self, num_processes: int = None): self.num_processes = num_processes or cpu_count() self.pool = Pool(processes=self.num_processes) def simulate_columns_parallel(self, columns: List[CorticalColumn], steps: int) -> List: """並行模擬多個皮層柱""" # 準備任務 tasks = [(column, steps, i) for i, column in enumerate(columns)] # 並行執行 results = self.pool.starmap( self._simulate_single_column, tasks ) return results @staticmethod def _simulate_single_column(column: CorticalColumn, steps: int, column_id: int) -> Dict: """單個皮層柱的模擬（工作進程）""" column_results = { 'spikes': [], 'voltages': [], 'column_id': column_id } for step in range(steps): # 模擬邏輯 new_neurons, spikes = update_neurons_numba( column.neurons, np.random.normal(0, 0.5, column.num_neurons), column.params, 0.1 ) column.neurons = new_neurons if step % 100 == 0: column_results['spikes'].append(spikes.copy()) column_results['voltages'].append( column.neurons[:, 0].copy() ) return column_results

7. 應用案例：工作記憶模擬

python

class WorkingMemorySimulation: """工作記憶的神經基礎模擬""" def __init__(self, network: LargeScaleCorticalNetwork): self.network = network self.memory_items = [] def encode_memory(self, stimulus: np.ndarray, duration: float = 500.0): """編碼記憶項目""" # 創建刺激特定的神經元集群 stimulus_neurons = np.random.choice( self.network.total_neurons, size=int(self.network.total_neurons * 0.01), # 1%的神經元 replace=False ) memory_item = { 'neurons': stimulus_neurons, 'strength': 1.0, 'decay_rate': 0.995, 'persistent_activity': np.zeros(len(stimulus_neurons)) } self.memory_items.append(memory_item) # 施加刺激 self._apply_stimulus(stimulus_neurons, duration) def maintain_memory(self, maintenance_time: float = 2000.0): """維持工作記憶""" steps = int(maintenance_time / 0.1) for step in range(steps): # 更新持續性活動 for item in self.memory_items: # 遞減活動強度 item['strength'] *= item['decay_rate'] # 通過循環連接維持活動 recurrent_input = self._get_recurrent_input( item['neurons'] ) # 更新神經元 self._update_memory_neurons( item['neurons'], recurrent_input * item['strength'] ) def recall_memory(self, cue_strength: float = 0.3) -> np.ndarray: """回憶記憶項目""" recalled_patterns = [] for item in self.memory_items: # 使用部分線索重新激活 cue_neurons = np.random.choice( item['neurons'], size=int(len(item['neurons']) * cue_strength), replace=False ) # 重新激活完整模式 reactivated = self._pattern_completion(cue_neurons) recalled_patterns.append(reactivated) return recalled_patterns

8. 結果驗證與模型評估

python

class ModelValidator: """模型驗證與性能評估""" @staticmethod def compare_with_biological_data(simulation_results: Dict, experimental_data: Dict) -> Dict: """與實驗數據比較""" metrics = {} # 發放率分布比較 sim_rates = simulation_results['firing_rates'] exp_rates = experimental_data['firing_rates'] metrics['rate_distribution_ks'] = ks_2samp( sim_rates.flatten(), exp_rates.flatten() ) # 尖峰間隔比較 sim_isi = simulation_results['inter_spike_intervals'] exp_isi = experimental_data['inter_spike_intervals'] metrics['isi_correlation'] = pearsonr(sim_isi, exp_isi)[0] # 網絡特性比較 sim_metrics = NetworkAnalyzer.compute_synchrony( simulation_results['spike_data'] ) metrics['synchrony_difference'] = abs( sim_metrics['synchrony_index'] - experimental_data['synchrony_index'] ) return metrics @staticmethod def scalability_analysis(network_sizes: List[int], runtimes: List[float]) -> Dict: """可擴展性分析""" # 擬合複雜度曲線 from scipy.optimize import curve_fit def linear_model(n, a, b): return a * n + b def quadratic_model(n, a, b, c): return a * n**2 + b * n + c # 嘗試不同模型擬合 popt_linear, _ = curve_fit(linear_model, network_sizes, runtimes) popt_quad, _ = curve_fit(quadratic_model, network_sizes, runtimes) # 計算R² residuals_linear = runtimes - linear_model(network_sizes, *popt_linear) residuals_quad = runtimes - quadratic_model(network_sizes, *popt_quad) ss_res_linear = np.sum(residuals_linear**2) ss_res_quad = np.sum(residuals_quad**2) ss_tot = np.sum((runtimes - np.mean(runtimes))**2) r2_linear = 1 - (ss_res_linear / ss_tot) r2_quad = 1 - (ss_res_quad / ss_tot) return { 'linear_fit': {'params': popt_linear, 'r2': r2_linear}, 'quadratic_fit': {'params': popt_quad, 'r2': r2_quad}, 'actual_complexity': 'O(n)' if r2_linear > r2_quad else 'O(n²)' }

9. 部署與使用示例

python

def main(): """主執行函數 - 完整模擬流程""" print("=" * 60) print("百萬神經元皮層活動模擬") print("=" * 60) # 1. 創建網絡 print("\n1. 初始化網絡...") network = LargeScaleCorticalNetwork( total_neurons=1_000_000, num_columns=1000, use_gpu=False # 設置為True如果GPU可用 ) # 2. 配置模擬 print("\n2. 配置模擬參數...") simulation = CorticalSimulation( network=network, simulation_time=5000.0, # 5秒模擬 dt=0.1 ) # 3. 運行模擬 print("\n3. 開始模擬...") results = simulation.run() # 4. 分析結果 print("\n4. 分析結果...") analyzer = NetworkAnalyzer() # 計算發放率 firing_rates = analyzer.compute_firing_rates( results['spike_data'], dt=0.1 ) # 檢測振蕩 oscillations = analyzer.detect_oscillations( firing_rates, dt=0.1 ) # 5. 可視化 print("\n5. 生成可視化...") visualizer = NetworkVisualizer() # 光柵圖 raster_fig = visualizer.create_raster_plot( results['spike_data'][:10000, :1000], # 取子集 time_range=(0, 1000) ) raster_fig.savefig('raster_plot.png', dpi=150) # 網絡結構圖 if hasattr(network, 'neuron_positions'): network_fig = visualizer.create_network_graph( network.columns[0].synapses, network.neuron_positions[:1000], # 取樣本 firing_rates[0, :1000] ) network_fig.write_html('network_3d.html') # 6. 保存結果 print("\n6. 保存結果...") import pickle with open('simulation_results.pkl', 'wb') as f: pickle.dump({ 'parameters': network.__dict__, 'results': results, 'analysis': { 'firing_rates': firing_rates, 'oscillations': oscillations } }, f) print("\n模擬完成！") print(f"總尖峰數: {np.sum(results['spike_data']):,}") print(f"平均發放率: {np.mean(firing_rates):.2f} Hz") # 顯示資源使用情況 import psutil import os process = psutil.Process(os.getpid()) print(f"記憶體使用: {process.memory_info().rss / 1e9:.2f} GB") print(f"CPU使用時間: {process.cpu_times().user:.2f} 秒") if __name__ == "__main__": # 設置環境 import warnings warnings.filterwarnings('ignore') # 確保可重現性 np.random.seed(42) # 執行模擬 main()

10. 挑戰與未來方向

10.1 當前限制與挑戰

1. 計算資源：百萬神經元模擬需要大量記憶體和計算能力

2. 生物真實性：簡化模型無法完全捕捉生物神經元的複雜性

3. 驗證困難：大規模模擬結果難以與實驗數據完全對照

4. 參數空間：巨大的參數空間使得參數優化困難

10.2 改進方向

1. 多尺度建模：結合分子、細胞、網絡多個層次

2. 在線學習：實現可塑性和學習過程的動態模擬

3. 分布式計算：利用集群計算資源進行更大規模模擬

4. 神經形態計算：利用專用硬體提高效率

結論

本文展示了使用Python實現百萬神經元皮層活動模擬的完整框架。通過高效的算法設計、稀疏矩陣運算、並行計算和適當的簡化，我們可以在現代計算硬體上實現大規模神經網絡的模擬。這種模擬雖然是對真實大腦的高度簡化，但對於理解皮層計算原理、網絡動力學和認知功能的神經基礎具有重要價值。

模擬代碼提供了從網絡構建、動態模擬到結果分析的完整工具鏈，研究人員可以在此基礎上進行修改和擴展，以探索特定科學問題。隨著計算技術的發展，這類大規模模擬將在神經科學和人工智慧研究中發揮越來越重要的作用。

附錄：安裝與配置

bash

# 必需依賴 pip install numpy scipy numba matplotlib plotly networkx # 可選依賴（GPU加速） pip install cupy-cuda11x # 根據CUDA版本選擇 # 可選依賴（並行計算） pip install dask distributed # 可選依賴（數據分析） pip install pandas scikit-learn

系統要求：

• RAM: 32GB+（推薦64GB）

• CPU: 8核+（推薦16核）

• 存儲: 100GB+可用空間（用於數據記錄）

• 可選: NVIDIA GPU（8GB+ VRAM）

這個框架為研究人員提供了一個強大的工具，用於探索大規模神經網絡的集體行為和湧現特性，推動我們對大腦工作原理的理解。