콘텐츠로 이동

Bertha에서의 Broadcasting

이 페이지는 선택한 Bertha 백엔드가 지원하는 broadcast 패턴을 보여 줍니다. shape 규칙은 Broadcasting에서, 연산별 입력 제약은 Bertha API에서 확인하십시오. 전형적인 백엔드 설정의 팩토리를 사용합니다.

Broadcast 규칙 적용

앞쪽 batch 차원은 같은 연산을 서로 독립된 입력에 적용하는 것을 나타냅니다. 물리 padding은 저장 용량이며 추가 입력 원소가 아닙니다. 선언한 저장 kind, 논리 shape, 물리 용량을 서로 호환되게 유지하십시오.

Core의 PerformBroadcast는 leaf 연산 하나 또는 독립적인 batch 항목을 순회하는 prefix loop를 만듭니다. Bertha는 이 loop를 hscf.for에서 scf.for로 변환하고, 지원되는 leaf를 실행 유닛에 할당합니다.

Leaf 연산 실행 유닛
Rank 1 elementwise 산술 VPU(벡터 유닛)
마지막 축의 softmax, RMSNorm, LayerNorm VPU(벡터 유닛)
Batch 없는 convolution, pooling, depthwise convolution MPU(행렬 유닛)
Rank 2 matmul MPU(행렬 유닛)

VPU leaf

아래 예제는 앞쪽 차원의 크기가 1인 입력과 마지막 차원이 padding된 입력을 다룹니다. SRAM에서 마지막 차원이 크기 1로 연속 저장된 입력도 행에 broadcast할 수 있습니다. padding된 singleton 열은 아직 지원하지 않습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
@legato.compile(backend=get_bertha, param_kinds={"a": "universal", "b": "universal", "out": "universal"})
def add_leading_one(
    a: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [1, 256], "shared_memory"
    ),
    b: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [256, 256], "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [256, 256], "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(a, device.get_core(0), "sram")
        legato.tensor.request_load(b, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(a, 0, "sram")
        y = legato.tensor.receive(b, 0, "sram")
        legato.tensor.memcpy(out, x + y)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@legato.compile(backend=get_bertha, param_kinds={"a": "universal", "b": "universal", "out": "universal"})
def add_padded_last_dim(
    a: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), ((-1, 4), 2, (128, 256)), "shared_dram"
    ),
    b: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), ((-1, 4), 2, (128, 256)), "shared_dram"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), ((-1, 4), 2, (128, 256)), "shared_dram"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(a, device.get_core(0), "sram")
        legato.tensor.request_load(b, device.get_core(0), "sram")
    with device.get_core(0):
        seq_len = legato.tensor.get_dimension(a, 0)
        loaded_a = legato.tensor.receive(a, 0, "sram")
        loaded_b = legato.tensor.receive(b, 1, "sram")
        out_view = legato.tensor.view(
            out,
            (
                legato.range(0, seq_len),
                legato.range(0, 2),
                legato.range(0, 128),
            ),
        )
        legato.tensor.memcpy(out_view, loaded_a + loaded_b)

MPU leaf

이 연산들은 batch마다 같은 입력 규칙을 적용합니다. spatial weight에는 앞쪽 batch 차원을 붙이지 마십시오. 재사용 가능한 SRAM weight는 반복 사이에도 유지되지만, 한 번만 소비하는 스트림을 복제하거나 다시 소비할 수는 없습니다. Weight 저장 공간 요구 사항을 참고하십시오.

matmul RHS의 앞쪽 크기 1인 차원은 제거되고, 값이 달라지는 batch 차원은 반복마다 weight slice를 선택합니다. 이 패턴에서 weight를 재사용해야 하면 호환되는 SRAM 저장 공간을 사용하십시오. 재사용 횟수에는 설정된 max_reuse_num 한도(EVT0 기본값 32)가 적용됩니다. 지원되지 않는 스트림 재사용에는 LE0184가 보고됩니다.

conv_1d [8, 64] — 이미 leaf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@legato.compile(backend=get_bertha, param_kinds={"inp": "universal", "weight": "universal", "out": "universal"})
def conv1d_leaf(
    inp: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [8, 64], "shared_memory"
    ),
    weight: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [3, 64, 64], "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [8, 64], "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(inp, device.get_core(0), "sram")
        legato.tensor.request_load(weight, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(inp, 0, "sram")
        w = legato.tensor.receive(weight, 0, "sram")
        y = legato.math.conv_1d(x, w, None, (1,), (1,), (1, 1), "zeros")
        legato.tensor.memcpy(out, y)

Batch가 있는 conv_1d [2, 8, 64]

[8, 64] MPU convolution 두 개로 분해됩니다. [3, 64, 64] SRAM weight는 변경 없이 그대로 전달되며, replay할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@legato.compile(backend=get_bertha, param_kinds={"inp": "universal", "weight": "universal", "out": "universal"})
def conv1d_nstar(
    inp: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [2, 8, 64], "shared_memory"
    ),
    weight: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [3, 64, 64], "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [2, 8, 64], "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(inp, device.get_core(0), "sram")
        legato.tensor.request_load(weight, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(inp, 0, "sram")
        w = legato.tensor.receive(weight, 0, "sram")
        y = legato.math.conv_1d(x, w, None, (1,), (1,), (1, 1), "zeros")
        legato.tensor.memcpy(out, y)

Batch가 있는 dwconv_1d [2, 19, 256]

여기서도 같은 방식으로 prefix 루프를 씁니다. weight [4, 64]는 slice되지 않습니다. batch가 반복 실행되는 경우에는 weight를 SRAM에 두십시오.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@legato.compile(backend=get_bertha, param_kinds={"inp": "universal", "weight": "universal", "out": "universal"})
def dwconv1d_nstar(
    inp: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [2, 19, 256], "shared_memory"
    ),
    weight: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [4, 256], "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [2, 16, 256], "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(inp, device.get_core(0), "sram")
        legato.tensor.request_load(weight, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(inp, 0, "sram")
        w = legato.tensor.receive(weight, 0, "sram")
        y = legato.math.dwconv_1d(x, w)
        legato.tensor.memcpy(out, y)

avg_pool_1d [8, 64]

이미 leaf입니다. EVT0에서는 pad를 포함한 커널 전체 면적으로 나눕니다 (Bertha API 참고).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
@legato.compile(backend=get_bertha, param_kinds={"inp": "universal", "out": "universal"})
def avg_pool1d_leaf(
    inp: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [8, 64], "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [4, 64], "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(inp, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(inp, 0, "sram")
        y = legato.math.avg_pool_1d(x, (2,), (2,))
        legato.tensor.memcpy(out, y)

정규화 leaf

LayerNorm과 RMSNorm은 VPU에서 각 행의 마지막 논리 축을 정규화합니다. padding 용량은 나눗셈의 분모나 입력 원소 수에 더해지지 않습니다. RMSNorm과 LayerNorm을 참고하십시오.

layer_norm [4, 128]

[128] leaf 네 개로 분해됩니다. affine 행(weight, bias)은 현재 load 조건에 맞춰 (1, (128, 256))으로 저장하지만, 연산에는 그대로 길이 128을 사용합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@legato.compile(
    backend=get_bertha,
    param_kinds={"inp": "universal", "weight": "universal", "bias": "universal", "out": "universal"},
)
def layernorm_rows(
    inp: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [4, 128], "shared_memory"
    ),
    weight: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), (1, (128, 256)), "shared_memory"
    ),
    bias: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), (1, (128, 256)), "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), [4, 128], "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(inp, device.get_core(0), "sram")
        legato.tensor.request_load(weight, device.get_core(0), "sram")
        legato.tensor.request_load(bias, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(inp, 0, "sram")
        w = legato.tensor.receive(weight, 0, "sram")
        b = legato.tensor.receive(bias, 0, "sram")
        y = legato.math.layer_norm(x, w, b)
        legato.tensor.memcpy(out, y)

물리 256에 padding된 D=70의 rms_norm

이 경우에도 rank 1 leaf 네 개로 분해됩니다. 나누는 수는 256이 아니라 70입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@legato.compile(backend=get_bertha, param_kinds={"inp": "universal", "weight": "universal", "out": "universal"})
def rmsnorm_padded(
    inp: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), (4, (70, 256)), "shared_memory"
    ),
    weight: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), (1, (70, 256)), "shared_memory"
    ),
    out: legato.get_model().tensor_type(
        legato.types.float("bfloat16"), (4, (70, 256)), "shared_memory"
    ),
):
    device = legato.get_context().get_device()
    with device.get_top():
        legato.tensor.request_load(inp, device.get_core(0), "sram")
        legato.tensor.request_load(weight, device.get_core(0), "sram")
    with device.get_core(0):
        x = legato.tensor.receive(inp, 0, "sram")
        w = legato.tensor.receive(weight, 0, "sram")
        y = legato.math.rms_norm(x, w)
        legato.tensor.memcpy(out, y)