安装指南#

作者: Shawn

本文主要介绍 NeurAI 的安装方法，系统环境为 Ubuntu 20.04 及以上版本。

如果使用南湖类脑云平台，APU、GPU、CPU三种平台分别对应的镜像为公共镜像中标签为南湖官方的镜像： neurai:x.x.x-lyngorx.x.x.x 、 neurai:x.x.x-cuda12.2-cudnn8-devel 、 neurai:x.x.x ，镜像都安装了NeurAI，无需再参照此教程进行安装。

在安装之前需要确保系统已经安装了以下依赖软件：

Python 3.8/3.9
OpenMPI 4.0+ (可选)
CUDA 11.0+ (可选)

Python安装方法参考 https://wiki.python.org/moin/BeginnersGuide/Download;

安装时需要使用 pip，如果没有安装，请先安装 pip , 在 Ubuntu环境下，可通过以下命令来安装和更新pip:

apt update && apt install -y python3-pip python3-dev
python3 -m pip install --upgrade pip

安装前设置pip的索引有两种方式，一种方式是修改配置文件：

# 首先创建一个pip的配置目录：
mkdir -p ~/.config/pip
# 然后编辑pip的配置文件：
vim ~/.config/pip/pip.conf

pip.conf 文件内容如下：

[global]
index-url = https://mirrors.aliyun.com/pypi/simple/

[install]
extra-index-url = https://nexus.nanhubrain.com/repository/pypi-hosted/simple/

另一种方式是每次安装时指定索引：

pip install neurai -i https://mirrors.aliyun.com/pypi/simple/ --extra-index-url https://nexus.nanhubrain.com/repository/pypi-hosted/simple/

pip安装#

pip 安装 NeurAI，支持的平台有类脑芯片、CPU、GPU。

安装命令如下:

APU

pip install -U "neurai[apu]"

CPU

pip install -U "neurai[cpu]"

GPU (CUDA 11.0)

pip install -U "neurai[cuda11]"

GPU (CUDA 12.0)

pip install -U "neurai[cuda12]"

Note

目前APU版本只支持Python3.8，且需在包含有Lynxi芯片的机器上运行，同时需要安装相匹配的驱动和SDK，建议使用`南湖类脑云平台 <https://console.nanhubrain.com/>`_ ，使用公共镜像 neurai:0.x.x-lyngorx.x.x.x ；
GPU/CPU版本支持Python3.8/3.9。
推荐使用ubuntu20.04环境，在GPU环境下，确保nvidia driver已安装好，可通过 nvidia-smi 来查看驱动版本。
如果环境已安装有cuda和cudnn(可通过 nvcc -V 来查看cuda版本, find / -name cudnn_version.h 找到这个文件，确认cudnn版本)，在安装neurai时，需要使用 neurai[cuda11_local] ,或者是 neurai[cuda12_local] ,这表明安装neurai时，不会安装nvidia相关的包；在cuda11环境下，需要cudnn86版本，在cuda12环境下，需要cudnn88版本。
如果未在配置文件中设置pip的索引，则需要在安装 neurai 包时，指定索引， -i https://mirrors.aliyun.com/pypi/simple/ --extra-index-url https://nexus.nanhubrain.com/repository/pypi-hosted/simple/ 。

这样就安装成功了，可通过验证安装来验证安装。

源码安装#

NeurAI是基于Apache2.0开源协议的软件，除了提供pip的安装方式，也提供基于源码编译的安装方案，这样，您可以根据自己的需求，在源码中进行更改，再安装软件。

以下为基于源码的安装步骤:

安装NeurAI#

git clone https://gitee.com/cnaeit/neurai.git

# Navigate into the cloned directory
cd neurai

各平台本地源码安装命令如下：

APU

pip install -U ".[apu]"

CPU

pip install -U ".[cpu]"

GPU (CUDA 11.0)

pip install -U ".[cuda11]"

GPU (CUDA 12.0)

pip install -U ".[cuda12]"

Note

目前APU版本只支持Python3.8，且需在包含有Lynxi芯片的机器上运行，同时需要安装相匹配的驱动和SDK，建议在南湖类脑云平台上运行，在容器云环境中，使用公共镜像中 neurai_apu_runtime 镜像的最新版本，该镜像已内置最新版neurai；
GPU/CPU版本支持Python3.8/3.9。
推荐使用ubuntu20.04环境，在GPU环境下，确保nvidia driver已安装好，可通过 nvidia-smi 来查看驱动版本。
如果环境已安装有cuda和cudnn(可通过 nvcc -V 来查看cuda版本, find / -name cudnn_version.h 找到这个文件，确认cudnn版本)，在安装neurai时，需要使用 neurai[cuda11_local] ,或者是 neurai[cuda12_local] ,这表明安装neurai时，不会安装nvidia相关的包；在cuda11环境下，需要cudnn86版本，在cuda12环境下，需要cudnn88版本。

这样就安装成功了，可通过验证安装来验证安装。

如果想修改neurailib源码，可以参照安装neurailib ，如果想多机运行，参照多机环境准备.

安装neurailib#

neurailib中主要包含脑仿真及脉冲神经网络相关的算子, 一般不需要单独安装，但如果需要修改neurailib的源码，您可以按照以下命令来安装它。

首先，安装依赖包：

cd neurai/lib
pip install -r requirements.txt

然后，安装neurailib:

APU/CPU

pip install .

GPU (CUDA 11.0)

CUDA_VERSION=11 pip install .

GPU (CUDA 12.0)

CUDA_VERSION=12 pip install .

Note

如果安装cuda版本的neurailib，需要先安装cuda。

多机环境准备#

在运行多机环境时，需要用到 mpi4jax 库，目前多机只支持CPU和GPU平台。

Note

在CPU平台，需要先安装openmpi, 在ubuntu系统中，可通过以下命令安装：

sudo apt update && sudo apt install -y libopenmpi-dev

安装完成后，再安装mpi4jax：

pip install mpi4jax

在GPU平台，需要先安装 cuda，再安装 ucx、 openmpi ，最后再安装 mpi4jax 库。

以下为在GPU平台安装mpi4jax的步骤：

安装cuda#

CUDA安装方法参考 https://developer.nvidia.com/cuda-downloads ，安装完成后，运行以下命令：

nvcc -V

如果运行成功，能输出cuda版本信息，说明cuda安装成功：

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2023 NVIDIA Corporation
Built on Tue_Jun_13_19:16:58_PDT_2023
Cuda compilation tools, release 12.2, V12.2.91
Build cuda_12.2.r12.2/compiler.32965470_0

安装ucx#

编译安装 ucx 库，安装方法参考:

wget https://github.com/openucx/ucx/releases/download/v1.11.2/ucx-1.11.2.tar.gz && \
  tar xvf ucx-1.11.2.tar.gz && \
  cd ucx-1.11.2 && \
  ./configure --prefix=/usr/local/ucx --enable-mt --with-cuda=/usr/local/cuda && \
  make -j$(nproc) && \
  make install && \
  cd .. && \
  rm -rf ucx-1.11.2 ucx-1.11.2.tar.gz

运行完成后，运行以下命令：

ucx_info -v

输出如下的形式，说明ucx安装成功：

# UCT version=1.11.2 revision ef2bbcf
# configured with: --prefix=/usr/local/ucx --enable-mt --with-cuda=/usr/local/cuda

如果找不到ucx命令，请将以下目录添加到PATH环境变量中：

export PATH=/usr/local/ucx/bin:$PATH

安装openmpi#

安装前先卸载使用apt安装的openmpi包：

sudo apt update && apt purge -y libopenmpi-dev

卸载成功后，再编译安装 openmpi 库，安装方法参考:

wget https://download.open-mpi.org/release/open-mpi/v4.1/openmpi-4.1.2.tar.gz && \
    tar xvf openmpi-4.1.2.tar.gz && \
    cd openmpi-4.1.2 && \
    ./configure --prefix=/usr/local/openmpi --with-cuda=/usr/local/cuda --with-ucx=/usr/local/ucx && \
    make -j$(nproc) && \
    make install && \
    cd .. && \
    rm -rf openmpi-4.1.2 openmpi-4.1.2.tar.gz

安装完成后，运行以下命令：

mpirun --version

输出如下的形式，说明openmpi安装成功：

mpirun (Open MPI) 4.1.2

Report bugs to http://www.open-mpi.org/community/help/

如果找不到mpirun命令，请将以下目录添加到PATH环境变量中：

export PATH=/usr/local/openmpi/bin:$PATH

安装mpi4jax#

安装支持cuda的mpi4jax时，需要先编译安装支持cuda的 ucx，以及 openmpi，然后再安装mpi4jax。安装前，请确认PATH环境变量：

echo $PATH

如果没有有openmpi、ucx、cuda 的bin目录，请将以下目录添加到PATH环境变量中：

export PATH=/usr/local/openmpi/bin:/usr/local/ucx/bin:/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/openmpi/lib:/usr/local/ucx/lib:/usr/local/cuda/lib64:$LD_LIBRARY_PATH

pip install mpi4jax

Note

如果安装时提示找不到Python头文件，请先安装python3-dev：

apt install -y python3-dev

验证安装#

单机版本安装验证#

运行以下代码：

import neurai

如果能输出neurai版本，说明安装成功。

多机版本安装验证#

采用多机脑仿真示例来验证安装是否成功。 ParallelizeExample 示例支持在 gpu 、 cpu 平台运行，验证多机环境是否安装成功, 以下为在 gpu 平台运行的示例：

运行以下脚本前，请修改成对应的平台, set_platform(platform='gpu') 这一行代码中的 platform 的可选值为 'gpu' 、 'cpu' 中的一个。

parallelize_example.py:

import sys
import os

from neurai.config import set_platform, set_simulate_status

set_platform('gpu')
set_simulate_status(enable_simulate_jit=True)
from neurai.util.mpi_init import mpi_size, mpi_rank, MPI

if mpi_rank <= mpi_size // 2:
  os.environ["CUDA_VISIBLE_DEVICES"] = "0"
else:
  os.environ["CUDA_VISIBLE_DEVICES"] = "1"
from neurai.monitor import MonitorBS, MonitorConf, MemoryRecorder
from neurai.parallelize import parallelize
from neurai.nn.neuron import ExpLIF, PoissonGenerator
from neurai.nn.synapse import StaticSynapse
from neurai import nn
from neurai.util import visualization
import jax.numpy as jnp
import matplotlib.pyplot as plt

size = 4
sim_t = 5
dt = 0.1


class SimpleNet(nn.SNet):

  @parallelize
  def setup(self):
    self.lif0 = ExpLIF(
      size=size,
      v_init=-55,
      V_rest=-60.0,
      V_th=-50.0,
      V_reset=-60.0,
      tau=20.0,
      R=1,
      I_e=200.0,
    )
    self.lif1 = ExpLIF(
      size=size,
      v_init=-55,
      V_rest=-60.0,
      V_th=-51.0,
      V_reset=-60.0,
      tau=20.0,
      R=1,
      I_e=100.0,
    )
    self.lif2 = ExpLIF(
      size=size,
      v_init=-55,
      V_rest=-60.0,
      V_th=-52.0,
      V_reset=-60.0,
      tau=20.0,
      R=1,
      I_e=50.0,
    )
    self.lif3 = ExpLIF(
      size=size,
      v_init=-55,
      V_rest=-60.0,
      V_th=-53.0,
      V_reset=-60.0,
      tau=20.0,
      R=1,
      I_e=0.0,
    )
    self.lif4 = ExpLIF(
      size=size,
      v_init=-55,
      V_rest=-60.0,
      V_th=-54.0,
      V_reset=-60.0,
      tau=20.0,
      R=1,
      I_e=0.0,
    )
    self.lif5 = ExpLIF(
      size=size,
      v_init=-55,
      V_rest=-60.0,
      V_th=-55.0,
      V_reset=-60.0,
      tau=20.0,
      R=1,
      I_e=0.0,
    )
    self.p = PoissonGenerator(size=size, rate=10000)

    self.synapse1 = StaticSynapse(
      pre=self.lif3,
      post=self.lif0,
      conn=nn.One2One(),
      weight=10.0,
      delay_step=2,
    )
    self.synapse2 = StaticSynapse(
      pre=self.lif1,
      post=self.lif4,
      conn=nn.One2One(),
      weight=10.0,
      delay_step=2,
    )
    self.synapse3 = StaticSynapse(
      pre=self.lif2,
      post=self.lif5,
      conn=nn.One2One(),
      weight=500.0,
      delay_step=2,
    )

    self.conn1 = StaticSynapse(self.p, self.lif3, conn=nn.One2One(), weight=10, delay_step=2)


class AllModule(nn.Module):

  def setup(self):
    self.network = nn.SNetLayer(SimpleNet)

  def __call__(self, input=None, t=0, monitor=None):
    _, mon = self.network(input, t=t, monitor=monitor)

    return mon


monitorbs = MonitorBS(
  monitors=[
    MonitorConf("ExpLIF_0", "spike"),
    MonitorConf("ExpLIF_0", "v"),
    MonitorConf("ExpLIF_1", "spike"),
    MonitorConf("ExpLIF_1", "v"),
    MonitorConf("ExpLIF_2", "spike"),
    MonitorConf("ExpLIF_2", "v"),
    MonitorConf("ExpLIF_3", "spike"),
    MonitorConf("ExpLIF_3", "v"),
    MonitorConf("ExpLIF_4", "spike"),
    MonitorConf("ExpLIF_4", "v"),
    MonitorConf("ExpLIF_5", "spike"),
    MonitorConf("ExpLIF_5", "v"),
  ],
  recorder=MemoryRecorder(),
)

net = AllModule()
param = net.init()
mon = net.run(param, t=sim_t, monitor=monitorbs)

fig = plt.figure(figsize=(4, 12), dpi=150)

for i, key in enumerate(mon.keys()):
  if key == 'ts':
    continue
  ax = fig.add_subplot(len(mon) - 1, 1, i + 1)
  if key[-1] == 'v':
    visualization.line_plot(
      mon["ts"],
      jnp.asarray(mon[key])[:, 0:size],
      ax=ax,
      xlabel="Time(ms)",
      ylabel=key + "(mv)",
      show=False,
      save=False,
      title=key,
    )
  elif key[-1] == 'e':
    visualization.raster_plot(mon["ts"], jnp.asarray(mon[key]), ax=ax, show=False, save=False, title=key)
  ax.set_xlim(0, sim_t)
fig.tight_layout()
fig.savefig(f"remote_rank_{mpi_rank}.png")
MPI.Finalize()

# Run the Python script of parallelize_example with 2 processes
mpirun -n 2 python3 parallelize_example.py

Note

如果是root用户，请在mpirun命令后面加上 --allow-run-as-root 参数，以允许root用户运行mpi程序。

祝你找到乐趣!

安装指南

Contents

安装指南#

pip安装#

源码安装#

安装NeurAI#

安装neurailib#

多机环境准备#

安装cuda#

安装ucx#

安装openmpi#

安装mpi4jax#

验证安装#

单机版本安装验证#

多机版本安装验证#