智脉以多尺度生物可塑性原理为基础，支持全脉冲神经网络建模，具备脑启发的人工智能模型以及脑功能和结构模拟能力。智脉为类脑人工智能和计算神经科学的研究者提供了一套完整的、系统化的接口组件。
智脉涵盖了不同精细程度的神经元模型、多种脉冲编码方式、丰富的突触可塑性学习模型，以这些基本组件为基础，实现了不同脑区及神经环路，并在此基础上实现了不同类型的认知功能、对多个物种的生物脑进行了不同尺度的模拟。智脉分别从类脑人工智能计算模型（目前发布约20个算法模型及源代码）、脑结构和功能模拟（覆盖鼠脑、猴脑、人脑模拟）方面提供了相当数量的应用案例，这为研发基于脉冲神经网络的人工智能和计算神经科学研究提供了强有力的基础设施。
## 类脑人工智能
智脉目前提供的认知功能组件可分为5类：
* 感知和学习
* 决策
* 运动控制
* 知识表征和推理
* 社会认知
## 脑模拟
目前智脉包括两部分的脑模拟，分别为：
* 脑认知功能模拟
* 脑结构模拟
从解剖到成像的多尺度连接数据从多个方面支撑我们的模拟。
## 学习资源
### 视频
- [[智脉说] 第20期 用BrainCog实现发育可塑性的脉冲神经网络自适应剪枝](https://www.bilibili.com/video/BV1iD4y1P7XE/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第19期 用BrainCog实现多脑区协同类脑情感共情脉冲神经网络](https://www.bilibili.com/video/BV16Y411q7b2/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第18期 用BrainCog实现前额叶功能柱模型在工作记忆任务中的应用](https://www.bilibili.com/video/BV1As4y1t7wF/?vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第17期 基于BrainCog的类脑心理揣测模型以及在帮助其他智能体避免安全风险任务中的应用](https://www.bilibili.com/video/BV12A411f74Q/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第16期 用BrainCog实现基于脉冲神经网络的类脑身体自我感知模型](https://www.bilibili.com/video/BV1pK411i7Jk/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第15期 用BrainCog实现基于脉冲神经网络的音乐记忆与创作模型](https://www.bilibili.com/video/BV1M3411X7C2/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第14期 用BrainCog实现基于多感觉融合的概念学习框架](https://www.bilibili.com/video/BV1Ae411P7tY/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第13期 用BrainCog实现基于群体编码机制启发的符号表征与推理](https://www.bilibili.com/video/BV1DW4y1p7kg/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第12期 用BrainCog实现基于脉冲时序依赖可塑性的无监督脉冲神经网络](https://www.bilibili.com/video/BV1MR4y1Z7Be/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第11期 用Braincog实现类脑脉冲神经网络高效时空调节训练](https://www.bilibili.com/video/BV1EK411Z71F/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第10期 用Braincog实现多脑区协同的类脑自主决策脉冲神经网络](https://www.bilibili.com/video/BV1jD4y1x7PU/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第9期 用BrainCog实现全局反馈连接脉冲神经网络](https://www.bilibili.com/video/BV1qv4y1D74Y/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第8期 用BrainCog实现从人工神经网络到脉冲神经网络的转换](https://www.bilibili.com/video/BV17e4y147H6/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第7期 用BrainCog实现受量子叠加态启发的脉冲时空编码](https://www.bilibili.com/video/BV1BG41177Z6/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
- [[智脉说] 第6期 用BrainCog实现深度强化学习脉冲神经网络](https://www.bilibili.com/video/BV1XN4y1c7Kn/?spm_id_from=333.337.search-card.all.click&vd_source=ffca9a0cf41b21082e79f7f6ad9a5301)
- [[智脉说] 第5期 BrainCog系统功能进阶](https://www.bilibili.com/video/BV1tT411N7c9/?spm_id_from=333.337.search-card.all.click&vd_source=ffca9a0cf41b21082e79f7f6ad9a5301)
- [[智脉说] 第4期 构建脑区的认知脉冲神经网络模型](https://www.bilibili.com/video/BV19d4y1679Y/?spm_id_from=333.788&vd_source=ffca9a0cf41b21082e79f7f6ad9a5301)
- [[智脉说] 第3期 高效构建脉冲神经网络](https://www.bilibili.com/video/BV1Be4y1874W/?spm_id_from=333.788&vd_source=ffca9a0cf41b21082e79f7f6ad9a5301)
- [[智脉说] 第2期 脉冲神经元计算建模](https://www.bilibili.com/video/BV16K411f7vQ/?spm_id_from=333.788&vd_source=ffca9a0cf41b21082e79f7f6ad9a5301)
- [[智脉说] 第1期 BrainCog系统部署](https://www.bilibili.com/video/BV1AW4y1b7v1/?spm_id_from=333.788&vd_source=ac84fc93f3c82d1cd96648079077afd3)
### 教程
- [智脉的部署](https://mp.weixin.qq.com/s/fX-S3fKKDfR3NV4ISAHrZg)
- [智脉的全面介绍](https://mp.weixin.qq.com/s/ywgQ5ydQxr6W7d_Y_XqC6w)
- [用智脉实现脉冲神经元建模](https://mp.weixin.qq.com/s/pCdlbkrdnMNHj7wcwi9D2Q)
- [用智脉构建高效深度脉冲神经网络](https://mp.weixin.qq.com/s/NIz7MSAOJQ79m97hkP3HVg)
- [用智脉构建认知脉冲网络](https://mp.weixin.qq.com/s/K0pY6V8TupJgYXH4WvS9jg)
- [用智脉实现深度强化学习脉冲神经网络](https://mp.weixin.qq.com/s/Zt78vj_sKn5jffEyeh86Cw)
- [用智脉实现受量子叠加态启发的脉冲序列时空编码](https://mp.weixin.qq.com/s/YVNkwDwuF9FG-YqQyd3KTg)
- [用智脉实现从人工神经网络到脉冲神经网络的转换](https://mp.weixin.qq.com/s/4g8WBoa4SOcb_VQ24wO-Xw)
- [用智脉实现全局反馈连接脉冲神经网络](https://mp.weixin.qq.com/s/-AS0BihlXdFwCt1hgzFx3g)
- [用智脉实现多脑区协同的类脑自主决策脉冲神经网络](https://mp.weixin.qq.com/s/dltOGjhUZ9yTzSssIvkhtA)
- [用智脉实现类脑脉冲神经网络高效时空调节训练](https://mp.weixin.qq.com/s/6ZtaWtiY9K96UhVnvhfP7w)
- [用智脉实现基于脉冲时序依赖可塑性的无监督脉冲神经网络](https://mp.weixin.qq.com/s/v_svhQ0N3JAYo1l8NQ1W1w)
- [用智脉实现基于群体编码机制启发的符号表征与推理](https://mp.weixin.qq.com/s/UXc5QDbg8tUKVU3L6dhvxw)
- [用智脉实现基于脉冲神经网络的多感觉融合概念学习](https://mp.weixin.qq.com/s/s9gXF5NkPUGXkcFAFtsCMw)
- [用Braincog实现基于脉冲神经网络的音乐记忆与创作模型](https://mp.weixin.qq.com/s/y-t9rFEXYSmI_-rnVk_usw)
- [用BrainCog实现基于脉冲神经网络的类脑身体自我感知模型](https://mp.weixin.qq.com/s/RLbS3GmhE8ScyZTKJKl_SQ)
- [基于BrainCog的类脑心理揣测模型以及在帮助其他智能体避免安全风险任务中的应用](https://mp.weixin.qq.com/s/xzFF6IK86W4h2CMs7jt7Xw)
- [用BrainCog实现前额叶功能柱模型在工作记忆任务中的应用](https://mp.weixin.qq.com/s/E6pb5W0Q4noK72NGf4SNGQ)
- [用BrainCog实现多脑区协同类脑情感共情脉冲神经网络](https://mp.weixin.qq.com/s/xUnal4I5tM-Rl49fu0ZRVw)
## 智脉数据引擎
除了静态数据集之外，智脉还支持常用的神经形态数据集，如DVSGesture、DVSCIFAR10、NCALTECH101、ES-ImageNet。同时，我们自己设计的用于小样本学习的神经形态数据集N-Omniglot也被整合到智脉的数据接口中。
**[DVSGesture](https://openaccess.thecvf.com/content_cvpr_2017/papers/Amir_A_Low_Power_CVPR_2017_paper.pdf)**
该数据集包含了使用DVS128记录的29名被试在3种照明条件下的11种手势。
**[DVSCIFAR10](https://www.frontiersin.org/articles/10.3389/fnins.2017.00309/full)**
该数据集使用DVS将CIFAR10数据集中的10,000幅基于帧的图像转换为10,000个事件流。
**[NCALTECH101](https://www.frontiersin.org/articles/10.3389/fnins.2015.00437/full)**
该数据集使用ATIS，通过拍摄在显示器上呈现的Caltech101数据集获得，同时将”Faces“这一类从N-Caltech101中删除，只有100个类和一个背景。
**[ES-ImageNet](https://arxiv.org/abs/2110.12211)**
该数据集使用全向离散梯度（ODG）方法将ImageNet数据集中的1,300,000张基于帧的图像转换为事件流，共有1000类。
**[N-Omniglot](https://www.nature.com/articles/s41597-022-01851-z)**
该数据集包括1623类手写字符，每类只有20个样本。该数据集是用DVS相机拍摄在显示器上播放的视频（由原始的Omniglot数据集生成），并由Robotic Process Automation软件自动收集获得。
数据集的接口开放在braincog/datasets文件夹中，以DVSCIFAR10为例
```python
loader_train, loader_eval,_,_ = get_dvsc10_data(batch_size=128,step=10)
```
## 依赖包
* python == 3.8
* CUDA toolkit == 11.
* numpy >= 1.21.2
* scipy >= 1.8.0
* h5py >= 3.6.0
* torch >= 1.10
* torchvision >= 0.12.0
* torchaudio >= 0.11.0
* timm >= 0.5.4
* matplotlib >= 3.5.1
* einops >= 0.4.1
* thop >= 0.0.31
* pyyaml >= 6.0
* loris >= 0.5.3
* pandas >= 1.4.2
* tonic
* pandas >= 1.4.2
* xlrd == 1.2.0
## 安装
### 在线安装
1. 你可以通过运行以下命令来安装智脉
> `pip install braincog`
2. 你也可以基于启智平台下载:
> `pip install git+https://openi.pcl.ac.cn/BrainCogLab/braincog.git`
### 本地安装
1. 如果你是一个开发者，我们推荐你下载或者从启智平台上clone一份到本地安装。
> `git clone https://openi.pcl.ac.cn/BrainCogLab/braincog.git`
2. 进入braincog文件夹
> `cd Brain-Cog`
3. 本地安装braincog
> `pip install -e .`
## 样例
1. 静态图片分类样例
```shell
cd ./examples/Perception_and_Learning/img_cls/bp
python main.py --model cifar_convnet --dataset cifar10 --node-type LIFNode --step 8 --device 0
```
2. 事件数据分类样例
```shell
cd ./examples/Perception_and_Learning/img_cls/bp
python main.py --model dvs_convnet --node-type LIFNode --dataset dvsc10 --step 10 --batch-size 128 --act-fun QGateGrad --device 0
```
其他BrainCog的功能和教程可以在以下网站找到 http://www.brain-cog.network/docs/
## BrainCog小助手
BrainCog（添加微信号，会由小助手拉您进入BrainCog研发者群）
 braincog/braincog/ 0000775 0000000 0000000 00000000000 14404341503 0014424 5 ustar 00root root 0000000 0000000 braincog/braincog/__init__.py 0000664 0000000 0000000 00000000210 14404341503 0016526 0 ustar 00root root 0000000 0000000 # __all__ = ['base', 'datasets', 'model_zoo', 'utils']
#
# from . import (
# base,
# datasets,
# model_zoo,
# utils
# )
braincog/braincog/base/ 0000775 0000000 0000000 00000000000 14404341503 0015336 5 ustar 00root root 0000000 0000000 braincog/braincog/base/__init__.py 0000664 0000000 0000000 00000000343 14404341503 0017447 0 ustar 00root root 0000000 0000000 __all__ = ['node', 'connection', 'learningrule', 'brainarea', 'encoder', 'utils', 'conversion']
from . import (
node,
strategy,
connection,
conversion,
learningrule,
brainarea,
utils,
encoder
)
braincog/braincog/base/brainarea/ 0000775 0000000 0000000 00000000000 14404341503 0017262 5 ustar 00root root 0000000 0000000 braincog/braincog/base/brainarea/BrainArea.py 0000664 0000000 0000000 00000007734 14404341503 0021473 0 ustar 00root root 0000000 0000000 import numpy as np
import torch, os, sys
from torch import nn
from torch.nn import Parameter
import abc
import math
from abc import ABC
import numpy as np
import torch
from torch import nn
from torch.nn import Parameter
import torch.nn.functional as F
from braincog.base.node.node import *
from braincog.base.learningrule.STDP import *
from braincog.base.connection.CustomLinear import *
class BrainArea(nn.Module, abc.ABC):
"""
脑区基类
"""
@abc.abstractmethod
def __init__(self):
"""
"""
super().__init__()
@abc.abstractmethod
def forward(self, x):
"""
计算前向传播过程
:return:x是脉冲
"""
return x
def reset(self):
"""
计算前向传播过程
:return:x是脉冲
"""
pass
class ThreePointForward(BrainArea):
"""
三点前馈脑区
"""
def __init__(self, w1, w2, w3):
"""
"""
super().__init__()
self.node = [IFNode(), IFNode(), IFNode()]
self.connection = [CustomLinear(w1), CustomLinear(w2), CustomLinear(w3)]
self.stdp = []
self.stdp.append(STDP(self.node[0], self.connection[0]))
self.stdp.append(STDP(self.node[1], self.connection[1]))
self.stdp.append(STDP(self.node[2], self.connection[2]))
def forward(self, x):
"""
计算前向传播过程
:return:x是脉冲
"""
x, dw1 = self.stdp[0](x)
x, dw2 = self.stdp[1](x)
x, dw3 = self.stdp[2](x)
return x, (*dw1, *dw2, *dw3)
class Feedback(BrainArea):
"""
反馈网络
"""
def __init__(self, w1, w2, w3):
"""
"""
super().__init__()
self.node = [IFNode(), IFNode()]
self.connection = [CustomLinear(w1), CustomLinear(w2), CustomLinear(w3)]
self.stdp = []
self.stdp.append(MutliInputSTDP(self.node[0], [self.connection[0], self.connection[2]]))
self.stdp.append(STDP(self.node[1], self.connection[1]))
self.x1 = torch.zeros(1, w3.shape[0])
def forward(self, x):
"""
计算前向传播过程
:return:x是脉冲
"""
x, dw1 = self.stdp[0](x, self.x1)
self.x1, dw2 = self.stdp[1](x)
return self.x1, (*dw1, *dw2)
def reset(self):
self.x1 *= 0
class TwoInOneOut(BrainArea):
"""
反馈网络
"""
def __init__(self, w1, w2):
"""
"""
super().__init__()
self.node = [IFNode()]
self.connection = [CustomLinear(w1), CustomLinear(w2)]
self.stdp = []
self.stdp.append(MutliInputSTDP(self.node[0], [self.connection[0], self.connection[1]]))
def forward(self, x1, x2):
"""
计算前向传播过程
:return:x是脉冲
"""
x, dw1 = self.stdp[0](x1, x2)
return x, dw1
class SelfConnectionArea(BrainArea):
"""
反馈网络
"""
def __init__(self, w1, w2 ):
"""
"""
super().__init__()
self.node = [IFNode() ]
self.connection = [CustomLinear(w1), CustomLinear(w2) ]
self.stdp = []
self.stdp.append(MutliInputSTDP(self.node[0], [self.connection[0], self.connection[1]]))
self.x1 = torch.zeros(1, w2.shape[0])
def forward(self, x):
"""
计算前向传播过程
:return:x是脉冲
"""
self.x1, dw1 = self.stdp[0](x, self.x1)
return self.x1, dw1
def reset(self):
self.x1 *= 0
if __name__ == "__main__":
T = 20
w1 = torch.tensor([[1., 1], [1, 1]])
w2 = torch.tensor([[1., 1], [1, 1]])
w3 = torch.tensor([[0.4, 0.4], [0.4, 0.4]])
ba = TwoInOneOut(w1, w2)
for i in range(T):
x = ba(torch.tensor([[0.1, 0.1]]), torch.tensor([[0.1, 0.1]]))
print(x[0])
braincog/braincog/base/brainarea/IPL.py 0000664 0000000 0000000 00000005440 14404341503 0020263 0 ustar 00root root 0000000 0000000
from braincog.base.learningrule.STDP import *
from braincog.base.node.node import *
from braincog.base.connection.CustomLinear import *
import random
import numpy as np
import torch
import os
import sys
from torch import nn
from torch.nn import Parameter
import abc
import math
from abc import ABC
import numpy as np
import torch
from torch import nn
from torch.nn import Parameter
import torch.nn.functional as F
import matplotlib.pyplot as plt
from braincog.base.strategy.surrogate import *
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
class IPLNet(nn.Module):
"""
inferior parietal lobule (IPL)
"""
def __init__(self, connection):
"""
Setting the network structure of IPL
"""
super().__init__()
# IPLM, IPLV
self.num_subMB = 2
self.node = [IzhNodeMU(threshold=30., a=0.02, b=0.2, c=-65., d=6., mem=-70.) for i in range(self.num_subMB)]
self.connection = connection
self.learning_rule = []
self.learning_rule.append(STDP(self.node[0], self.connection[0])) # vPMC_input-IPLM
self.learning_rule.append(MutliInputSTDP(self.node[1], [self.connection[1], self.connection[2]])) # STS_input-IPLV, IPLM-IPLV
self.out_IPLM = torch.zeros((self.connection[0].weight.shape[1]), dtype=torch.float)
self.out_IPLV = torch.zeros((self.connection[1].weight.shape[1]), dtype=torch.float)
def forward(self, input1, input2): # input from vPMC and STS
"""
Calculate the output of IPLv and the weight update between IPLm and IPLv
:param input1: input from vPMC
:param input2: input from STS
:return: output of IPLv, weight update between IPLm and IPLv
"""
self.out_IPLM = self.node[0](self.connection[0](input1))
self.out_IPLV, dw_IPLv = self.learning_rule[1](input2, self.out_IPLM)
if sum(sum(self.out_IPLV)) == 1:
dw_IPLv = dw_IPLv[0][torch.nonzero(dw_IPLv[1])[0][1]][torch.nonzero(dw_IPLv[1])[0][1]] * dw_IPLv[1]
else:
dw_IPLv = dw_IPLv[0]
return self.out_IPLV, dw_IPLv
def UpdateWeight(self, i, dw):
"""
Update the weight
:param i: index of the connection to update
:param dw: weight update
:return: None
"""
self.connection[i].update(dw)
def reset(self):
"""
reset the network
:return: None
"""
for i in range(self.num_subMB):
self.node[i].n_reset()
for i in range(len(self.learning_rule)):
self.learning_rule[i].reset()
def getweight(self):
"""
Get the connection and weight in IPL
:return: connection
"""
return self.connection
braincog/braincog/base/brainarea/Insula.py 0000664 0000000 0000000 00000004354 14404341503 0021075 0 ustar 00root root 0000000 0000000 import numpy as np
import torch,os,sys
from torch import nn
from torch.nn import Parameter
import abc
import math
from abc import ABC
import numpy as np
import torch
from torch import nn
from torch.nn import Parameter
import torch.nn.functional as F
import matplotlib.pyplot as plt
from braincog.base.strategy.surrogate import *
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
import random
from braincog.base.connection.CustomLinear import *
from braincog.base.node.node import *
from braincog.base.learningrule.STDP import *
class InsulaNet(nn.Module):
"""
Insula
"""
def __init__(self,connection):
"""
Setting the network structure of Insula
"""
super().__init__()
# Insula
self.num_subMB = 1
self.node = [IzhNodeMU(threshold=30., a=0.02, b=0.2, c=-65., d=6., mem=-70.) for i in range(self.num_subMB)]
self.connection = connection
self.learning_rule = []
self.learning_rule.append(MutliInputSTDP(self.node[0], [self.connection[0],self.connection[1]]))# IPLv-Insula, STS-Insula
self.Insula=torch.zeros((self.connection[1].weight.shape[1]), dtype=torch.float)
def forward(self, input1, input2): # input from IPLv and STS
"""
Calculate the output of Insula
:param input1: input from IPLv
:param input2: input from STS
:return: output of Insula, weight update (unused)
"""
self.out_Insula, dw_Insula = self.learning_rule[0](input1, input2)
return self.out_Insula
def UpdateWeight(self,i,dw):
"""
Update the weight
:param i: index of the connection to update
:param dw: weight update
:return: None
"""
self.connection[i].update(dw)
def reset(self):
"""
reset the network
:return: None
"""
for i in range(self.num_subMB):
self.node[i].n_reset()
for i in range(len(self.learning_rule)):
self.learning_rule[i].reset()
def getweight(self):
"""
Get the connection and weight in Insula
:return: connection
"""
return self.connection braincog/braincog/base/brainarea/PFC.py 0000664 0000000 0000000 00000002461 14404341503 0020247 0 ustar 00root root 0000000 0000000 import torch
from torch import nn
from braincog.base.brainarea import BrainArea
from braincog.model_zoo.base_module import BaseLinearModule, BaseModule
class PFC:
"""
PFC
"""
def __init__(self):
"""
"""
super().__init__()
def forward(self, x):
"""
:return:x
"""
return x
def reset(self):
"""
:return:x
"""
pass
class dlPFC(BaseModule, PFC):
"""
SNNLinear
"""
def __init__(self,
step,
encode_type,
in_features:int,
out_features:int,
bias,
*args,
**kwargs):
super().__init__(step, encode_type, *args, **kwargs)
self.bias = bias
self.in_features = in_features
self.out_features = out_features
self.fc = self._create_fc()
self.c = self._rest_c()
def _rest_c(self):
c = torch.rand((self.out_features, self.in_features)) # eligibility trace
return c
def _create_fc(self):
"""
the connection of the SNN linear
@return: nn.Linear
"""
fc = nn.Linear(in_features=self.in_features,
out_features=self.out_features, bias=self.bias)
return fc
braincog/braincog/base/brainarea/__init__.py 0000664 0000000 0000000 00000000605 14404341503 0021374 0 ustar 00root root 0000000 0000000 from .basalganglia import basalganglia
from .BrainArea import BrainArea, ThreePointForward, Feedback, TwoInOneOut, SelfConnectionArea
from .Insula import InsulaNet
from .IPL import IPLNet
from .PFC import PFC, dlPFC
__all__ = [
'basalganglia',
'BrainArea', 'ThreePointForward', 'Feedback', 'TwoInOneOut', 'SelfConnectionArea',
'InsulaNet',
'IPLNet',
'PFC', 'dlPFC'
]
braincog/braincog/base/brainarea/basalganglia.py 0000664 0000000 0000000 00000014367 14404341503 0022254 0 ustar 00root root 0000000 0000000 import numpy as np
import torch
import os
import sys
from torch import nn
from torch.nn import Parameter
import abc
import math
from abc import ABC
import numpy as np
import torch
import torch.nn.functional as F
from braincog.base.strategy.surrogate import *
from braincog.base.node.node import IFNode, SimHHNode
from braincog.base.learningrule.STDP import STDP, MutliInputSTDP
from braincog.base.connection.CustomLinear import CustomLinear
class basalganglia(nn.Module):
"""
Basal Ganglia
"""
def __init__(self, ns, na, we, wi, node_type):
super().__init__()
"""
:param ns: 状态个数
:param na:动作个数
:param we:兴奋性连接权重
:param wi:抑制性连接权重
"""
num_state = ns
num_action = na
num_STN = 2
weight_exc = we
weight_inh = wi
# connetions: 0DLPFC-StrD1 1DLPFC-StrD2 2DLPFC-STN 3StrD1-GPi 4StrD2-GPe 5Gpe-Gpi 6STN-Gpi 7STN-Gpe 8Gpe-STN
bg_connection = []
bg_con_mask = []
# DLPFC-StrD1
con_matrix1 = torch.zeros((num_state, num_state * num_action), dtype=torch.float)
for i in range(num_state):
for j in range(num_action):
con_matrix1[i, i * num_action + j] = 1
bg_con_mask.append(con_matrix1)
bg_connection.append(CustomLinear(weight_exc * con_matrix1, con_matrix1))
# DLPFC-StrD2
bg_connection.append(CustomLinear(weight_exc * con_matrix1, con_matrix1))
bg_con_mask.append(con_matrix1)
# DLPFC-STN
con_matrix3 = torch.ones((num_state, num_STN), dtype=torch.float)
bg_con_mask.append(con_matrix3)
bg_connection.append(CustomLinear(weight_exc * con_matrix3, con_matrix3))
# StrD1-GPi
con_matrix4 = torch.zeros((num_state * num_action, num_action), dtype=torch.float)
for i in range(num_state):
for j in range(num_action):
con_matrix4[i * num_action + j, j] = 1
bg_con_mask.append(con_matrix4)
bg_connection.append(CustomLinear(weight_inh * con_matrix4, con_matrix4))
# StrD2-GPe
bg_con_mask.append(con_matrix4)
bg_connection.append(CustomLinear(weight_inh * con_matrix4, con_matrix4))
# Gpe-Gpi
con_matrix5 = torch.eye((num_action), dtype=torch.float)
bg_con_mask.append(con_matrix5)
bg_connection.append(CustomLinear(weight_inh * con_matrix5, con_matrix5))
# STN-Gpi
con_matrix6 = torch.ones((num_STN, num_action), dtype=torch.float)
bg_con_mask.append(con_matrix6)
bg_connection.append(CustomLinear(0.5 * weight_exc * con_matrix6, con_matrix6))
# STN-Gpe
bg_con_mask.append(con_matrix6)
bg_connection.append(CustomLinear(0.5 * weight_exc * con_matrix6, con_matrix6))
# Gpe-STN
con_matrix7 = torch.ones((num_action, num_STN), dtype=torch.float)
bg_con_mask.append(con_matrix7)
bg_connection.append(CustomLinear(0.5 * weight_inh * con_matrix7, con_matrix7))
self.num_subBG = 5
self.node_type = node_type
if self.node_type == "hh":
self.node = [SimHHNode() for i in range(self.num_subBG)]
if self.node_type == "lif":
self.node = [IFNode() for i in range(self.num_subBG)]
self.connection = bg_connection
self.mask = bg_con_mask
self.learning_rule = []
trace_stdp = 0.99
self.learning_rule.append(STDP(self.node[0], self.connection[0], trace_stdp)) # DLPFC-StrD1
self.learning_rule.append(STDP(self.node[1], self.connection[1], trace_stdp)) # DLPFC-StrD2
self.learning_rule.append(MutliInputSTDP(self.node[2], [self.connection[2], self.connection[8]])) # DLPFC-STN
self.learning_rule.append(MutliInputSTDP(self.node[3], [self.connection[4], self.connection[7]])) # StrD2-GPe STN-Gpe
self.learning_rule.append(MutliInputSTDP(self.node[4], [self.connection[3], self.connection[5], self.connection[6]])) # StrD1-GPi Gpe-Gpi STN-Gpi
self.out_StrD1 = torch.zeros((self.connection[0].weight.shape[1]), dtype=torch.float)
self.out_StrD2 = torch.zeros((self.connection[1].weight.shape[1]), dtype=torch.float)
self.out_STN = torch.zeros((self.connection[2].weight.shape[1]), dtype=torch.float)
self.out_Gpi = torch.zeros((self.connection[3].weight.shape[1]), dtype=torch.float)
self.out_Gpe = torch.zeros((self.connection[4].weight.shape[1]), dtype=torch.float)
def forward(self, input):
"""
计算由当前输入基底节网络的输出
:param input: 输入电流
:return: 输出脉冲
"""
self.out_StrD1, dw_strd1 = self.learning_rule[0](input)
self.out_StrD2, dw_strd2 = self.learning_rule[1](input)
self.out_STN, dw_stn = self.learning_rule[2](input, self.out_Gpe)
self.out_Gpe, dw_gpe = self.learning_rule[3](self.out_StrD2, self.out_STN)
self.out_Gpi, dw_gpi = self.learning_rule[4](self.out_StrD1, self.out_Gpe, self.out_STN)
return self.out_Gpi
def UpdateWeight(self, i, dw):
"""
更新基底节内第i组连接的权重 根据传入的dw值
:param i: 要更新的连接的索引
:param dw: 更新的量
:return: None
"""
self.connection[i].update(dw)
self.connection[i].weight.data = F.normalize(self.connection[i].weight.data.float(), p=1, dim=1)
def reset(self):
"""
reset神经元或学习法则的中间量
:return: None
"""
for i in range(self.num_subMB):
self.node[i].n_reset()
for i in range(len(self.learning_rule)):
self.learning_rule[i].reset()
def getweight(self):
"""
获取基底节网络的连接(包括权值等)
:return: 基底节网络的连接
"""
return self.connection
def getmask(self):
"""
获取基底节网络的连接（仅连接矩阵）
:return: 基底节网络的连接矩阵
"""
return self.mask
if __name__ == "__main__":
BG = basalganglia(4, 2, 0.2, -4)
con = BG.getweight()
print(con)
braincog/braincog/base/brainarea/dACC.py 0000664 0000000 0000000 00000010626 14404341503 0020373 0 ustar 00root root 0000000 0000000 import torch
import matplotlib.pyplot as plt
import numpy as np
np.set_printoptions(threshold=np.inf)
from utils.one_hot import *
import os
import time
import sys
from tqdm import tqdm
from braincog.base.encoder.population_coding import *
from braincog.model_zoo.base_module import BaseLinearModule, BaseModule
from braincog.base.learningrule.STDP import *
import sys
sys.path.append("..")
class dACC(BaseModule):
"""
SNNLinear
"""
def __init__(self,
step,
encode_type,
in_features:int,
out_features:int,
bias,
node,
*args,
**kwargs):
super().__init__(step, encode_type, *args, **kwargs)
self.bias = bias
self.in_features = in_features
self.out_features = out_features
self.node1 = node(threshold=0.5, tau=2.)
self.node_name1 = node
self.node2 = node(threshold=0.1, tau=2.)
self.node_name2 = node
self.fc = self._create_fc()
self.c = self._rest_c()
def _rest_c(self):
c = torch.rand((self.out_features, self.in_features)) # eligibility trace
return c
def _create_fc(self):
"""
the connection of the SNN linear
@return: nn.Linear
"""
fc = nn.Linear(in_features=self.in_features,
out_features=self.out_features, bias=self.bias)
return fc
def update_c(self, c, STDP, tau_c=0.2):
"""
update the trace of eligibility
@param c: a tensor to record eligibility
@param STDP: the results of STDP
@param tau_c: the parameter of trace decay
@return: a update tensor to record eligibility
Equation:
delta_c = (-(c / tau_c) + STDP) * dela_t
c = c + delta_c
reference: -] iԴQYs!;ߊcaiE;u켾˖W% o]_I}]{k'I"l5xƉszĜE
=3"ߊ|]jׄ[uZc<zk |1]+ĺO# "U/6tL]e䌟}F[[_eZ/'eh('/o37 OG/&mGÚ]$ v &xV V{m&Uݘ
rs\ Jmˍ\?/Ay !?O
ˮwFIFhn#SuJ3ARS}&fߑC
7W5NwIygo4֩e/
u/4ۻ)m<%\ѴSq*͟ WuI𥮃my[+Xl"hW27bk+SJa./=LDoV~ xw<'c6 zڳ;j f7*+p0 #3^B
`W1 6~Xj곯Ϗ`
|RrwOUǁaE(5Zyg 8?,lѴMs,< BEn|bL=б,u}EODi>PG?P+k>4[p6ZBoʼn?L?sE_ySxäu~?W
}72)y$UGRMCjz =v)y%(zǫĺYC&lIu2
!=ѡݠ+VmB
{/B\j / b{˩?q}# ct&Cӭ,-㵳]TTXZmm
Ao(*TV_ f'dQEr AEPEPEPEPEPEPEPEPEP WCvP&2+Q3xRigl da܂z{ t+5o J>0G ,,Oo𬿵#vU,nyx8 %nRBP |q t?s|u5}3ix¡q]o'~#Q7C/+}@^Ag'< pc34'/$KNOdTIA9d II7N
Qz<t>Qgs̎wn}qͷ;\sN. k }\8|xJI YnLuMNyc`ִG:Bߞ}A3zg<(#uy/.~ c.JFUF q5|D_mF gRVL^ti*2+ x(` +-GJ&E$0"qUIF ,|H,
fS-H;0pxPqN[Jxb
om&Wv4[L3nfbrFF9|3WC4 Eag}\jRp %rpj*琪x~<ѼqMBt.~oX\Z6Ȼ{yޗ bW\ď66Xo /j:9WZD{1]:.h;3*Z
*um#Z%нkXlUJaC#`4 '| 7 { 5G2w# UP¿Qg c z߆x?կwz
;Tm$a*̧t5U| G p:ZWT QE QE QE QE QE QE QE QE_sg[m^^_u '9؟w QE Vg<7Eu(u
:vKo2XB;ȭ:)N.)EI8] #okvZZ Æ`Ӄ% s^!IwhPhmPGR2#)]A$3ƓC"xPx W|%?[54&Ó;y٢LTp;+ba)ӎw_>
^}%"d5Zaf~'rL%KS ~ {2NL fmW/Uck{Hlqߋ7mJQMF# jLf-N8fF^6t22f #?|V;R&liG-L\ [WރPe >C"],{%+OLr3_?{Q1"~mk_ w|&X=ۤ=VoAn]idQG{f SkRvfĖn,|qi [&H?>v%DI"g+ndUf[= q;u]#An$$jd>o%,1l[cnEG(
BѲq0(ıJ'BI
g|n
T! HC](d1R]0?; . 1m&F)m/qnvK"S
5F2
\)3F$tFS !sT
F1
B86:'t_ϩ'o/ oT7oU[,ce(y{4N5Bo8E+:tX&yN!yO {LGo[/[/VǦuX_[L)fto¬-1pB-],E0z'ֳ}"⎰ā>ߴ/y^8f%K1":+
$| 7STVXXTȫބ qrAˮXTg"* UR*7ɹP\n8K&-w+B H)uMyN+F-Ρgl(Ln:h9Iʵ}%Rc*v=1Zu"2x =h[RGg"뒯člr~(ۇ5zM!ŚBEBZ (-XBlBSSiV-m،rl@-F,GeRƑ&F|"yoICUI Kȴ[#--arV6'}oWi}%.(X9f%_F x>O(I[3b
euJ6kD {qY^)D>ox -gQ 1G+\O)g"( L@^t/FdYYs;Q a&b{ȑW#CJ2v֑FlY<6Q1ͲR7f
RH8(; kUDi(UH[(
BPp L"Jku8 EHab+pM267b'ck]6"n"ո)&|# qb%1I!\7Xtw:
fuNIrP0:':@zK0pY(-
ǀeQMrxi8qЇέq