How to use this method "AbstractSubProcessModel"

[XinhaoLuo666]

I read the document "https://lava-nc.org/lava/lava.magma.core.model.sub.html#lava-magma-core-model-sub-model" to learn how to use AbstractSubProcessModel. It says that: "Sub classes must implement the init method which must accept the Process, that the SubProcessModel implements, as an argument. This allows SubProcessModel to access all process attributes such as Vars, Ports or initialization arguments passed to the Process constructor via proc.init_args."
but when I run the code "shape = proc.init_args.get("shape",(1,1))" or "self.lif = LIF(**proc.init_args)", it occurs "DenseLayer' object has no attribute 'init_args'". the 173th line of the following code is where the error occured. I want to know how to how to use this method "AbstractSubProcessModel". Thanks!

#from lava.proc.dense.process import Dense
import numpy as np
from lava.magma.core.model.py.ports import PyInPort, PyOutPort
from lava.magma.core.model.py.type import LavaPyType
from lava.magma.core.resources import CPU
from lava.magma.core.decorator import implements, requires
from lava.magma.core.model.py.model import PyLoihiProcessModel
from lava.magma.core.process.process import AbstractProcess
from lava.magma.core.process.variable import Var
from lava.magma.core.process.ports.ports import InPort, OutPort
from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol
from lava.magma.core.decorator import implements
from lava.magma.core.run_configs import RunConfig, Loihi1SimCfg
from lava.magma.core.run_conditions import RunSteps
from lava.magma.core.model.sub.model import AbstractSubProcessModel

class Dense(AbstractProcess):
    """Dense connections between neurons.
    Realizes the following abstract behavior:
    a_out = W * s_in
    """

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        shape = kwargs.get("shape", (1, 1))
        self.s_in = InPort(shape=(shape[1],))
        self.a_out = OutPort(shape=(shape[0],))
        self.weights = Var(shape=shape, init=kwargs.pop("weights", 0))



@implements(proc=Dense, protocol=LoihiProtocol)
@requires(CPU)
class PyDenseModel(PyLoihiProcessModel):
    s_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, bool)
    a_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, np.float)
    weights: np.ndarray = LavaPyType(np.ndarray, np.float)

    def run_spk(self):
        s_in = self.s_in.recv()
        a_out = self.weights[:, s_in].sum(axis=1) #dense层就是简单的根据权重和输入求和而已
        self.a_out.send(a_out)




class LIF(AbstractProcess):
    """Leaky-Integrate-and-Fire (LIF) neural Process.
    LIF dynamics abstracts to:
    u[t] = u[t-1] * (1-du) + a_in         # neuron current
    v[t] = v[t-1] * (1-dv) + u[t] + bias  # neuron voltage
    s_out = v[t] > vth                    # spike if threshold is exceeded
    v[t] = 0                              # reset at spike
    Parameters
    ----------
    du: Inverse of decay time-constant for current decay.
    dv: Inverse of decay time-constant for voltage decay.
    bias: Neuron bias.
    vth: Neuron threshold voltage, exceeding which, the neuron will spike.
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        shape = kwargs.get("shape", (1,))
        du = kwargs.pop("du", 0)
        dv = kwargs.pop("dv", 0)
        bias = kwargs.pop("bias", 0)
        vth = kwargs.pop("vth", 10)

        self.shape = shape
        self.a_in = InPort(shape=shape)
        self.s_out = OutPort(shape=shape)
        self.u = Var(shape=shape, init=0)
        self.v = Var(shape=shape, init=0)
        self.du = Var(shape=(1,), init=du)
        self.dv = Var(shape=(1,), init=dv)
        self.bias = Var(shape=shape, init=bias)
        self.vth = Var(shape=(1,), init=vth)
        self.spikes = Var(shape=shape, init=0)


#from lava.proc.lif.process import LIF


@implements(proc=LIF, protocol=LoihiProtocol)
@requires(CPU)
class PyLifModel(PyLoihiProcessModel):
    a_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, np.float)
    s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, bool, precision=1)
    u: np.ndarray = LavaPyType(np.ndarray, np.float)
    v: np.ndarray = LavaPyType(np.ndarray, np.float)
    bias: np.ndarray = LavaPyType(np.ndarray, np.float)
    du: float = LavaPyType(float, np.float)
    dv: float = LavaPyType(float, np.float)
    vth: float = LavaPyType(float, np.float)
    spikes: np.ndarray = LavaPyType(np.ndarray, bool)

    def run_spk(self):
        a_in_data = self.a_in.recv()
        self.u[:] = self.u * (1 - self.du)
        self.u[:] += a_in_data
        self.v[:] = self.v * (1 - self.dv) + self.u + self.bias
        s_out = self.v >= self.vth
        self.v[s_out] = 0  # Reset voltage to 0
        self.spikes = s_out
        self.s_out.send(s_out)



@implements(proc=LIF, protocol=LoihiProtocol)
@requires(CPU)
class PyLifModel(PyLoihiProcessModel):
    a_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, np.float)
    s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, bool, precision=1)
    u: np.ndarray = LavaPyType(np.ndarray, np.float)
    v: np.ndarray = LavaPyType(np.ndarray, np.float)
    bias: np.ndarray = LavaPyType(np.ndarray, np.float)
    du: float = LavaPyType(float, np.float)
    dv: float = LavaPyType(float, np.float)
    vth: float = LavaPyType(float, np.float)
    spikes: np.ndarray = LavaPyType(np.ndarray, bool)

    def run_spk(self):
        a_in_data = self.a_in.recv()
        self.u[:] = self.u * (1 - self.du)
        self.u[:] += a_in_data
        self.v[:] = self.v * (1 - self.dv) + self.u + self.bias
        s_out = self.v >= self.vth
        self.v[s_out] = 0  # Reset voltage to 0
        self.spikes = s_out
        self.s_out.send(s_out)


class DenseLayer(AbstractProcess):
    """Combines Dense and LIF Processes.
    """
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        shape = kwargs.get("shape", (1, 1))
        du = kwargs.pop("du", 0)
        dv = kwargs.pop("dv", 0)
        bias = kwargs.pop("bias", 0)
        bias_exp = kwargs.pop("bias_exp", 0)
        vth = kwargs.pop("vth", 10)
        weights = kwargs.pop("weights", 0)

        self.s_in = InPort(shape=(shape[1],))
        #output of Dense synaptic connections is only used internally
        #self.a_out = OutPort(shape=(shape[0],))
        self.weights = Var(shape=shape, init=weights)
        #input to LIF population from Dense synaptic connections is only used internally
        #self.a_in = InPort(shape=(shape[0],))
        self.s_out = OutPort(shape=(shape[0],))
        self.u = Var(shape=(shape[0],), init=0)
        self.v = Var(shape=(shape[0],), init=0)
        self.bias = Var(shape=(shape[0],), init=bias)
        self.du = Var(shape=(1,), init=du)
        self.dv = Var(shape=(1,), init=dv)
        self.vth = Var(shape=(1,), init=vth)
        self.spikes = Var(shape=(shape[0],), init=0)






@implements(proc=DenseLayer, protocol=LoihiProtocol)
class SubDenseLayerModel(AbstractSubProcessModel):  #演示如何用SubPricessModel链接网络

    def __init__(self, proc: AbstractProcess):
        """Builds sub Process structure of the Process."""
        # Instantiate child processes
        #input shape is a 2D vec (shape of weight mat)
        shape = proc.init_args.get("shape",(1,1)) #lava说明文档上说要用init_args初始化的，但是初始化却报错
        weights = proc.init_args.get("weights",(1,1))
        bias = proc.init_args.get("bias",(1,1))
        vth = proc.init_args.get("vth",(1,1))

        #shape is a 2D vec (shape of weight mat)
        # self.lif = LIF(**proc.init_args)
        # self.dense = Dense(**proc.init_args)
        # #shape is a 1D vec
        self.dense = Dense(shape=shape, weights=weights)
        self.lif = LIF(shape=(shape[0],),bias=bias,vth=vth)


        # connect Parent in port to child Dense in port
        proc.in_ports.s_in.connect(self.dense.in_ports.s_in)
        # connect Dense Proc out port to LIF Proc in port
        self.dense.out_ports.a_out.connect(self.lif.in_ports.a_in)
        # connect child LIF out port to parent out port
        self.lif.out_ports.s_out.connect(proc.out_ports.s_out)

        proc.vars.u.alias(self.lif.vars.u)
        proc.vars.v.alias(self.lif.vars.v)
        proc.vars.bias.alias(self.lif.vars.bias)
        proc.vars.du.alias(self.lif.vars.du)
        proc.vars.dv.alias(self.lif.vars.dv)
        proc.vars.vth.alias(self.lif.vars.vth)
        proc.vars.weights.alias(self.dense.vars.weights)
        proc.vars.spikes.alias(self.lif.vars.spikes)



dim=(3,3)
# shape=dim
#set targeted weight mat
weights0 = np.zeros(shape=dim)
weights0[1,1]=1
weights1 = weights0
#instantiate 2 DenseLayers
layer0 = DenseLayer(shape=dim,weights=weights0, bias=4, vth=10)
layer1 = DenseLayer(shape=dim,weights=weights1, bias=4, vth=10)
#connect layer 0 to layer 1
layer0.s_out.connect(layer1.s_in) #在外层直接链接的示例

print('Layer 1 weights: \n', layer1.weights.get(),'\n')
print('\n ----- \n')

rcfg = Loihi1SimCfg(select_tag='floating_pt', select_sub_proc_model=True)

for t in range(9):
    #running layer 1 runs all connected layers (layer 0)
    layer1.run(condition=RunSteps(num_steps=1),run_cfg=rcfg)
    print('t: ',t)
    print('Layer 0 v: ', layer0.v.get())
    print('Layer 1 u: ', layer1.u.get())
    print('Layer 1 v: ', layer1.v.get())
    print('Layer 1 spikes: ', layer1.spikes.get())
    print('\n ----- \n')

[ar-roy]

Have you tried proc.shape.get()? I believe when you implement a procedure (eg. proc=DenseLayer), you can directly call Var's from that procedure without any init. I've been using the following structure without issue:

@implements(proc=ObjectDetector)
@requires(CPU)
class PyObjectDetectionModel(AbstractSubProcessModel):
    def __init__(self, proc):
        self.conv0 = Conv(
            input_shape=(proc.img_height.get(), proc.img_width.get(), proc.img_channels.get()),
            weight=proc.w_conv0.init,
            stride=np.array([1, 1]),
            padding=np.array([1, 1]))
        self.lif1 = LIF(
            shape=(proc.out_height.get(), proc.out_width.get(), proc.out_channels.get()),
            bias_mant=proc.b_lif1.init,
            vth=400,
            dv=0,
            du=4095
        )