Questions about using tiles

[ElinorG11]

Hello,

I have a few questions about using the tiles:

1. what is exactly the difference between analog tile and inference tile? I thought that analog tile is an abstract object and we can't really use it, but as I seen in some of your examples you use it explicitly (as seen in example 01 where you use SingleRPUConfig() which uses AnalogTiles).

2. How can I specify the size of the tile after defining an rpu configuration? from looking at you documentation, I saw that when creating a tile, the user can specify it's size, as following tile = InferenceTile(32, 32). but when creating a model or when using an existing one and converting it to analog counterpart, we use rpu_config = InferenceRPUConfig(). I'd appreciate if you could explain to me:

• What is the difference between the configuration and the tile itself? the configuration just allows the user to specify more parameters for a specific tile right?
• When defining configuration as follows rpu_config = InferenceRPUConfig() Suppose now I want to change the tile to be 32x32. how can I do it? by viewing you documentation I saw the functions rpu_config.forward.inp_res and rpu_config.forward.out_res which quantise the ADC and DAC. so should I specify rpu_config.forward.inp_res = 1/32 and rpu_config.forward.out_res = 1/32 or did I misinterpreted the meaning of the last two functions? I saw this example also:

from aihwkit.simulator.tiles import AnalogTile
from aihwkit.simulator.configs import SingleRPUConfig
from aihwkit.simulator.configs.devices import ConstantStepDevice

config = SingleRPUConfig(device=ConstantStepDevice())
tile = AnalogTile(32, 32, rpu_config=config)

how can I make sure this tile will be used in the configuration which is sent to the model as seen in example 03:

def create_analog_network(input_size, hidden_sizes, output_size):
   ...
    model = AnalogSequential(
        AnalogLinear(input_size, hidden_sizes[0], True,
                     rpu_config=SingleRPUConfig(device=ConstantStepDevice())),
        ...

• When using InferenceRPUConfig I saw that the default Tile type is InferenceTile but of what size (out_size and in_size)? and I also saw that you're using ConstantStepDevice as defult, but of what precision?

3. Is there any way to create our own configuration? this is, specify explicitly the tile with it's parameters, and the device and create an rpu configuration from it to send to the model?

Thank you very much for your help.

[maljoras]

Hi @ElinorG11 ,
thanks for your questions !
to 1: The InferenceRPUConfig (which generates an InferenceTile) has a number of features that are useful for hardware that only support inference, whereas the other AnalogTile implement some realistic way of investigating analog training directly on the crossbar array. The difference is that for hardware that only support analog inference, backward and update is not supported on the chip itself. For these chip designs, InferenceRPUConfig is used. Note that one can still train a network with the InferenceTile with AIHWKIT which in this case however uses a perfect backward and update step and thus does "hardware-aware" (software) training, in that only the forward pass is non-ideal. It also provides a mechanism to use realstic PCM calibrated programming noise and drift during the inference. Please consult the documentation for more details

to 2: The rpu configuration sets all the meta-parameter that essentially define the hardware design, such as noise strengths, device-to-device variations etc. The size of the tile is currently determined solely be the DNN layer. So it will be as big as needed for a layer. If one wants to restrict the tile size, currently one needs to change the DNN accordingly so that it has smaller weight matrices (e.g. by simply splitting a linear layer into multiple parts and adding/concatenating the outputs). We will however soon a new layer where the maximal physical tile size can be defined. Note that only the maximal tile size is of concern. If you have a DNN where all layers are smaller than the max tile size, the current simulation is accurate with the assumption that non-used devices do not contribute to the non-idealities, which should be true in first approximation.

Note that the inp_res and out_res are just the DAC/ADC converter resolutions, it has nothing to do with the tile size. Weights are not sliced across multiple crossbar arrays. If you want to investigate this, you can simple generate multiple tiles for each slice. See also here #287

Note again that SingleRPUConfig and ConstantStepDevice define a hardware that is capable of doing analog training (in contrast to hardware designs that support only inference).

to 3: Sure that is the idea. You can just define the setting of your hardware by specifying your own rpu_config

[ElinorG11]

Thank you very much for the detailed answer. I just want to make sure I understood correctly: the number of cross-points at the crossbar array (i.e. the size of the tile) is determined by the layer with the maximal input*output size (thus making sure that the crossbar will contain enough devices to store all the weight for every layer)? what confused me was the fact that I can create a tile of a specific size such as: tile = InferenceTile(10,20,config) but I suppose that the user has no use of it, and it is only used internally by InferenceRPUConfig() ?

[maljoras]

Oh, I see what you mean. Typically, the rpu_config will specify the Tile class that is constructed. Typically you just construct say a linear layer, e.g. layer=AnalogLinear(5, 6, rpu_config) and then it will use a tile that is specified by the rpu_config. You don't need to call InferenceTile directly. Working on the tile level is more low-level and only useful if one wanted to implement new layers that for instance would use multiple tiles under the hood.

For example, you can see that the AnalogLinear will create a tile here which is determined by the rpu_config class. The tile is stored in the field layer.analog_tile (see here)

[ElinorG11]

Thank you for your guidance!