sapicore 0.1.1

安装

Sapicore 的要求很少。它需要

• Python 3.7+

• Pytorch 1.5+（请参阅 PyTorch 安装）。

• 科学库（请参阅 setup.py 中的列表）。

• Tensorboard 和 tensorboardx（可选）。

  最简单的方法是使用 conda 安装它们，如下所示

  conda install -c conda-forge numpy tqdm pandas ruamel.yaml tensorboard tensorboardx

  或者使用 pip，简单地（pip 会自动安装其余的依赖项）

  python -m pip install tensorboard tensorboardx

一旦安装了依赖项，就可以在当前的 conda/pip 环境中安装 Sapicore

pip install sapicore

pip install https://github.com/cplab/sapicore/archive/refs/heads/main.zip

示例模型

以下是一个简短的、可运行的示例。一个类似但更完整的示例，包括配置和日志记录，可以在 sapicore/examples 下找到。

import torch
from sapicore.model import SapicoreModel
from sapicore.neuron.analog import AnalogNeuron
from sapicore.synapse import SapicoreSynapse
from sapicore.pipeline import PipelineBase
from sapicore.learning import SapicoreLearning


class SimpleNeuron(AnalogNeuron):
    """Represents a neuron or matrix of neurons."""

    activation: torch.Tensor

    def forward(self, data: torch.tensor) -> torch.tensor:
        self.activation = torch.clip(data, -2, 2)
        return self.activation


class SimpleSynapse(SapicoreSynapse):
    """Represents a synapse connecting a neuron or matrix of neurons."""

    weight: torch.Tensor

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # register weight as part of the state so it is saved with the model
        self.register_buffer("weight", torch.zeros(0))
        self.weight = torch.normal(0, 1, size=(5, ))

    def forward(self, data: torch.tensor) -> torch.tensor:
        return data * self.weight


class SimpleLearning(SapicoreLearning):
    """Learns the synapse weight based on pre-post activation."""

    def apply_learning(
            self, pre_neuron: SimpleNeuron, synapse: SimpleSynapse,
            post_neuron: SimpleNeuron, **kwargs):
        synapse.weight *= torch.abs(pre_neuron.activation) * \
            torch.abs(post_neuron.activation)


class MyModel(SapicoreModel):
    """Network model that contains neurons/synapses."""

    neuron_1: SimpleNeuron

    synapse: SimpleSynapse

    neuron_2: SimpleNeuron

    learning: SimpleLearning

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.neuron_1 = SimpleNeuron()
        self.synapse = SimpleSynapse()
        self.neuron_2 = SimpleNeuron()

        self.add_neuron(None, 'entry_neuron', self.neuron_1)
        self.add_synapse(self.neuron_1, 'synapse', self.synapse)
        self.add_neuron(self.synapse, 'exit_neuron', self.neuron_2)

        self.learning = SimpleLearning()
        self.add_learning_rule('learning', self.learning)

    def initialize_learning_state(self) -> None:
        self.learning.initialize_state()

    def forward(self, data: torch.tensor) -> torch.tensor:
        data = self.neuron_1(data)
        data = self.synapse(data)
        data = self.neuron_2(data)
        return data

    def apply_learning(self, **kwargs) -> None:
        self.learning.apply_learning(self.neuron_1, self.synapse, self.neuron_2)


class SimplePipeline(PipelineBase):
    """Training pipeline."""

    def run(self) -> None:
        use_cuda = torch.cuda.is_available()
        cuda_device = torch.device("cuda:0" if use_cuda else "cpu")

        model = MyModel()
        model.initialize_state()
        model.initialize_learning_state()
        model.to(cuda_device)

        print('Pre-learning weight: ', model.synapse.weight.cpu().numpy())

        # these models don't use gradients
        with torch.no_grad():
            for i in range(3):
                # fake data
                data = torch.normal(0, 1, size=(5, ))
                # pass it through the model
                model.forward(data)
                # apply model learning
                model.apply_learning()

        print('Post-learning weight: ', model.synapse.weight.cpu().numpy())


if __name__ == '__main__':
    # create and run the model
    pipeline = SimplePipeline()
    pipeline.run()

当运行时，此程序会打印

Pre-learning weight:  [-0.95982265 -0.2735969   0.6473335  -0.37592512  0.05847792]
Post-learning weight:  [-6.0495706e-09 -8.3768668e-08  3.3906079e-05 -3.3586942e-09
  1.3144294e-32]

作者

康奈尔大学计算生理学实验室的项目。

• 神经形态算法由 Ayon Borthakur 和 Thomas Cleland 完成。

• 框架架构由 Matthew Einhorn 完成。