# Mobilint IR 연산 형식

이 페이지는 Mobilint IR 연산의 동작, 입력·출력 형상과 속성을 설명합니다. 형식 목록에 있다는 사실만으로 NPU 또는 CPU 오프로딩 실행이 보장되지는 않습니다. 실행 범위는 [NPU 연산 지원 범위](<https://docs.mobilint.com/compiler/kr/v1.4/operation_support/index.md>)와 [CPU 오프로딩](<https://docs.mobilint.com/compiler/kr/v1.4/cpu_offloading/#cpu-오프로딩-연산-범위>)을 확인하세요.

## 연산 정의 읽는 법

- 4차원 활성화 텐서는 NHWC 순서입니다. `N`은 배치, `H`는 높이, `W`는 너비, `C`는 채널이며 아래 형상의 배치 크기는 1입니다.
- 입력과 출력은 위치에 따라 `in[0]`, `out[0]`처럼 표기합니다.
- `Weight` 속성은 텐서 값이 아니라 텐서 인덱스(`TensorIndex`)를 저장합니다. 이 인덱스는 상수 텐서의 이름, 자료형, 형상, 저장 위치가 기록된 서브그래프 텐서 표를 가리킵니다. `-1`은 텐서가 없음을 뜻하며, 생략한 선택적 텐서 속성에도 사용합니다.
- 속성 표에서 **필수**는 반드시 지정해야 하는 값, **선택**은 생략할 수 있는 값입니다.

## 연산별 상세 정의

### Adding

두 활성화 텐서의 원소별 합.

두 활성화 텐서를 원소별로 더합니다.

```text
out[0] = in[0] + in[1]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |
| `in[1]` | in\[0\]과 broadcast 가능 | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], in[1])` | 출력 활성화 텐서. |

### AddingConstant

활성화 텐서에 상수 텐서를 더합니다.

모델에 저장된 상수를 활성화 텐서 하나에 더합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다.

```text
out[0] = constant + in[0]   if is_const_first
         in[0] + constant   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `constant` | `Weight` | 필수 | 상수 피연산자. in\[0\]에 맞춰 broadcast합니다. |
| `is_const_first` | `bool` | `false` | 상수가 왼쪽 피연산자이면 `true`. |
| `shape` | `int32[]` | `[]` | 저장된 `constant`를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in\[0\]), shape)입니다. 기본값 `[]`은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], shape)` | 출력 활성화 텐서. |

### Batchnorm

저장된 평균과 분산으로 채널별 정규화한 뒤 scale과 shift를 적용합니다.

추론 형태의 batch normalization입니다. 각 채널을 모델에 저장된 상수 `moving_mean`, `moving_var`로 정규화한 뒤 `gamma`를 곱하고 `beta`를 더합니다.

```text
out[0][n, h, w, c] = (in[0][n, h, w, c] - moving_mean[c]) / sqrt(moving_var[c] + epsilon)
                     * gamma[c] + beta[c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `gamma` | `Weight` | 필수 | 채널별 scale. |
| `beta` | `Weight` | 필수 | 채널별 shift. |
| `moving_mean` | `Weight` | 필수 | 입력에서 빼는 채널별 평균. |
| `moving_var` | `Weight` | 필수 | `epsilon`을 더하고 제곱근을 취해 입력을 나누는 채널별 분산. |
| `epsilon` | `Weight` | 필수 | 수치 안정성을 위해 분산에 더하는 scalar. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Celu

매개변수 `alpha`를 쓰는 연속 미분 가능 ELU.

양수 입력은 그대로 두고, 음수 입력은 `-alpha`로 포화하는 지수 함수로 바꿉니다.

```text
out[0] = max(0, in[0]) + min(0, alpha * (exp(in[0] / alpha) - 1))
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `alpha` | `float32` | 필수 | 음수 구간의 포화값이자 지수의 나눗수. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Clip

각 원소를 `[clip_min_value, clip_max_value]` 범위로 제한합니다.

모든 원소를 주어진 경계 안으로 제한합니다. 경계는 하나만 둘 수 있으며, 없는 쪽은 제한하지 않습니다.

```text
out[0] = min(max(in[0], clip_min_value), clip_max_value)
an absent bound is skipped
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `clip_max_value` | `float32` | 선택 | 상한. 없으면 상한을 두지 않습니다. |
| `clip_min_value` | `float32` | 선택 | 하한. 없으면 하한을 두지 않습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Concatenate

여러 활성화 텐서를 한 축을 따라 이어 붙입니다.

in\[0..K-1\]을 피연산자 순서대로 `axis` 축을 따라 이어 붙입니다. 모든 피연산자는 rank가 같고 나머지 축의 크기가 모두 같습니다.

```text
out[0] = concat(in[0], in[1], ..., in[K-1]) along axis
out[0].shape[axis] = in[0].shape[axis] + ... + in[K-1].shape[axis]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0..K-1]` | axis 축 외에는 모두 같음 | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `original_key` | `str` | 선택 | 더 이상 사용하지 않는 속성(deprecated)입니다. 키는 항상 있지만 값은 항상 `None`입니다. |
| `axis` | `int32` | 선택 | 이어 붙일 축. 음수는 마지막 축부터 셉니다. 텐서의 실제 배치 순서를 따르므로 NHWC 활성화 텐서에서는 `3`이 채널 축입니다. |
| `original_axis` | `int32` | 선택 | 더 이상 사용하지 않는 속성(deprecated)입니다. 키는 항상 있지만 값은 항상 `None`입니다. |
| `original_inputs` | `int32[]` | 선택 | 더 이상 사용하지 않는 속성(deprecated)입니다. 키는 항상 있지만 값은 항상 `None`입니다. |
| `input_index` | `int32[]` | 선택 | 항상 `[0, 1, ..., K-1]`입니다. |
| `input_names` | `str[]` | 선택 | 항상 이 연산의 실제 입력 활성화 텐서 이름과 같습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | axis 축 크기를 피연산자에 대해 합한 in\[0\] shape | 출력 활성화 텐서. |

### Convolution

NHWC 활성화 텐서과 상수 필터의 2-D convolution.

in\[0\]의 공간 축 위로 `weight`를 stride, dilation, zero padding에 맞춰 이동하며 곱해 더하고 `bias`를 더합니다. weight는 출력 채널 우선인 `[out_channels, in_channels / group_number, h_kernel, w_kernel]`로 저장합니다.

```text
G  = group_number,  Cg = in_channels / G,  Og = out_channels / G   (// : integer division)
xp = zero_pad(in[0], top=north_padding, bottom=south_padding,
                     left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx, c < Cg}
    weight[o, c, ky, kx]
    * xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, (o // Og)*Cg + c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, in_channels]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `in_channels` | `int32` | 필수 | 입력 채널 수. |
| `out_channels` | `int32` | 필수 | 출력 채널 수. |
| `h_kernel` | `int32` | 필수 | kernel 높이. |
| `w_kernel` | `int32` | 필수 | kernel 너비. |
| `h_stride` | `int32` | 필수 | H 방향 stride. |
| `w_stride` | `int32` | 필수 | W 방향 stride. |
| `h_dilation` | `int32` | 필수 | H 방향 dilation. |
| `w_dilation` | `int32` | 필수 | W 방향 dilation. |
| `west_padding` | `int32` | 필수 | W 시작(왼쪽)의 zero padding. |
| `east_padding` | `int32` | 필수 | W 끝(오른쪽)의 zero padding. |
| `north_padding` | `int32` | 필수 | H 시작(위쪽)의 zero padding. |
| `south_padding` | `int32` | 필수 | H 끝(아래쪽)의 zero padding. |
| `padding_list` | `int32[]` | `[]` | 원래 2-D padding `[top, left, bottom, right]`. 참고용이며 계산에는 네 `*_padding` 속성을 씁니다. |
| `group_number` | `int32` | 필수 | 채널 그룹 수를 의미하여 값은 1이어야 합니다. 1이 아닌 경우 `GroupConvolution` 또는 `DepthwiseConvolution`이어야 합니다. |
| `weight` | `Weight` | 필수 | 필터, `[out_channels, in_channels / group_number, h_kernel, w_kernel]`. |
| `bias` | `Weight` | 선택 | bias, `[out_channels]`. 없으면 0. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, out_channels]` | 출력 활성화 텐서. |

### Cos

원소별 cosine.

```text
out[0] = cos(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### DepthwiseConvolution

입력 채널마다 별도 필터를 쓰는 depthwise 2-D convolution.

입력 채널마다 그룹 하나를 두는(`group_number = in_channels`) `Convolution`입니다. 각 입력 채널은 자기 전용 필터 `M = out_channels / in_channels`개와만 convolution하고 다른 채널과 섞이지 않으며, 출력 채널 `o`는 입력 채널 `o / M`을 읽습니다. weight는 `[out_channels, 1, h_kernel, w_kernel]`로 저장합니다.

```text
M  = out_channels / in_channels
xp = zero_pad(in[0], top=north_padding, bottom=south_padding,
                     left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx}
    weight[o, 0, ky, kx]
    * xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, o / M]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, in_channels]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `in_channels` | `int32` | 필수 | 입력 채널 수. |
| `out_channels` | `int32` | 필수 | 출력 채널 수. `in_channels * M`입니다. |
| `h_kernel` | `int32` | 필수 | kernel 높이. |
| `w_kernel` | `int32` | 필수 | kernel 너비. |
| `h_stride` | `int32` | 필수 | H 방향 stride. |
| `w_stride` | `int32` | 필수 | W 방향 stride. |
| `h_dilation` | `int32` | 필수 | H 방향 dilation. |
| `w_dilation` | `int32` | 필수 | W 방향 dilation. |
| `west_padding` | `int32` | 필수 | W 시작(왼쪽)의 zero padding. |
| `east_padding` | `int32` | 필수 | W 끝(오른쪽)의 zero padding. |
| `north_padding` | `int32` | 필수 | H 시작(위쪽)의 zero padding. |
| `south_padding` | `int32` | 필수 | H 끝(아래쪽)의 zero padding. |
| `padding_list` | `int32[]` | `[]` | 원래 2-D padding `[top, left, bottom, right]`. 참고용이며 계산에는 네 `*_padding` 속성을 씁니다. |
| `group_number` | `int32` | 필수 | 채널 그룹 수. 입력 채널마다 그룹이 하나이므로 `in_channels`와 같습니다. |
| `weight` | `Weight` | 필수 | 필터, `[out_channels, 1, h_kernel, w_kernel]`. |
| `bias` | `Weight` | 선택 | bias, `[out_channels]`. 없으면 0. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, out_channels]` | 출력 활성화 텐서. |

### Div

두 활성화 텐서의 원소별 몫.

in\[0\]을 in\[1\]로 원소별로 나눕니다(실수 나눗셈).

```text
out[0] = in[0] / in[1]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |
| `in[1]` | in\[0\]과 broadcast 가능 | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], in[1])` | 출력 활성화 텐서. |

### DivConstant

활성화 텐서를 상수로 나누거나 상수를 활성화 텐서로 나눕니다.

피연산자 하나를 모델에 저장된 상수로 하여 나눗셈을 합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다. `is_const_first`가 `true`이면 `constant / in[0]`, `false`이면 `in[0] / constant`를 계산합니다.

```text
out[0] = constant / in[0]   if is_const_first
         in[0] / constant   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `constant` | `Weight` | 필수 | 상수 피연산자. in\[0\]에 맞춰 broadcast합니다. |
| `is_const_first` | `bool` | 필수 | 상수가 피제수(왼쪽 피연산자)이면 `true`, 제수이면 `false`. |
| `shape` | `int32[]` | `[]` | 저장된 `constant`를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in\[0\]), shape)입니다. 기본값 `[]`은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], shape)` | 출력 활성화 텐서. |

### Elu

음수 쪽 배율이 `leaky_alpha`인 exponential linear unit.

양수 입력은 그대로 두고, 나머지는 `-leaky_alpha`로 포화하는 `leaky_alpha * (exp(x) - 1)`로 바꿉니다.

```text
out[0] = in[0]                            if in[0] > 0
         leaky_alpha * (exp(in[0]) - 1)   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `leaky_alpha` | `float32` | 필수 | ELU의 alpha. 음수 구간의 배율. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Erf

원소별 Gauss 오차 함수(erf).

```text
out[0] = erf(in[0]) = 2 / sqrt(pi) * integral_0^in[0] exp(-t^2) dt
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Exp

원소별 자연 지수 함수.

```text
out[0] = exp(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Gelu

Gaussian error linear unit.

GELU를 원소별로 적용합니다. `approximate`로 `erf`를 쓰는 방식과 tanh 근사식 중 하나를 고릅니다.

```text
approximate = false:  out[0] = 0.5 * x * (1 + erf(x / sqrt(2)))
approximate = true:   out[0] = 0.5 * x * (1 + tanh(sqrt(2/pi) * (x + 0.044715 * x^3)))
where x = in[0]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `approximate` | `bool` | `false` | tanh 근사식이면 `true`, erf 정확식이면 `false`. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### GroupConvolution

NHWC 활성화 텐서과 상수 필터의 grouped 2-D convolution.

`Convolution`과 같은 grouped convolution을 계산합니다. 채널을 `group_number`개 그룹으로 나누고, 각 그룹의 출력 `out_channels / group_number`개는 같은 그룹의 입력 `in_channels / group_number`개만 봅니다.

```text
G  = group_number,  Cg = in_channels / G,  Og = out_channels / G   (// : integer division)
xp = zero_pad(in[0], top=north_padding, bottom=south_padding,
                     left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx, c < Cg}
    weight[o, c, ky, kx]
    * xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, (o // Og)*Cg + c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, in_channels]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `in_channels` | `int32` | 필수 | 입력 채널 수. |
| `out_channels` | `int32` | 필수 | 출력 채널 수. |
| `h_kernel` | `int32` | 필수 | kernel 높이. |
| `w_kernel` | `int32` | 필수 | kernel 너비. |
| `h_stride` | `int32` | 필수 | H 방향 stride. |
| `w_stride` | `int32` | 필수 | W 방향 stride. |
| `h_dilation` | `int32` | 필수 | H 방향 dilation. |
| `w_dilation` | `int32` | 필수 | W 방향 dilation. |
| `west_padding` | `int32` | 필수 | W 시작(왼쪽)의 zero padding. |
| `east_padding` | `int32` | 필수 | W 끝(오른쪽)의 zero padding. |
| `north_padding` | `int32` | 필수 | H 시작(위쪽)의 zero padding. |
| `south_padding` | `int32` | 필수 | H 끝(아래쪽)의 zero padding. |
| `padding_list` | `int32[]` | `[]` | 원래 2-D padding `[top, left, bottom, right]`. 참고용이며 계산에는 네 `*_padding` 속성을 씁니다. |
| `group_number` | `int32` | 필수 | 채널 그룹 수. `in_channels`와 `out_channels`를 모두 나누어떨어지게 합니다. |
| `weight` | `Weight` | 필수 | 필터, `[out_channels, in_channels / group_number, h_kernel, w_kernel]`. |
| `bias` | `Weight` | 선택 | bias, `[out_channels]`. 없으면 0. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, out_channels]` | 출력 활성화 텐서. |

### GroupNormalization

채널 그룹마다 H, W와 그룹 채널에 대해 정규화한 뒤 scale과 bias를 적용합니다.

C개 채널을 연속된 `num_groups`개 그룹으로 나누고, 배치 항목마다 각 그룹을 H, W와 그룹 채널에 대해 평균 0, 분산 1로 정규화합니다. 이어서 채널별 `scale`과 `bias`를 적용합니다. 분산은 모집단 분산입니다.

```text
G = num_groups,  Cg = C / G,  g(c) = floor(c / Cg)
S(n, g)   = in[0][n, :, :, g*Cg : (g+1)*Cg]
mu[n, g]  = mean(S(n, g))
var[n, g] = mean((S(n, g) - mu[n, g])^2)
out[0][n, h, w, c] = (in[0][n, h, w, c] - mu[n, g(c)]) / sqrt(var[n, g(c)] + epsilon)
                     * scale[c] + bias[c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `num_groups` | `int32` | 필수 | 채널 그룹 수. C를 나누어떨어지게 하며, 각 그룹은 연속된 `C / num_groups`개 채널입니다. |
| `scale` | `Weight` | 필수 | 채널별 scale(gamma). |
| `bias` | `Weight` | 선택 | 채널별 bias(beta). 없으면 0. |
| `epsilon` | `Weight` | 필수 | 수치 안정성을 위해 분산에 더하는 scalar. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### HardSigmoid

구간 선형 sigmoid, `clamp(alpha * x + beta, 0, 1)`.

\[0, 1\]로 제한한 선형 경사입니다. `alpha`나 `beta`가 없으면 각각 1/6, 0.5를 씁니다.

```text
out[0] = clamp(alpha * in[0] + beta, 0, 1)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `alpha` | `float32` | 선택 | 경사의 기울기. 없으면 1/6. |
| `beta` | `float32` | 선택 | 경사의 절편. 없으면 0.5. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### HardSwish

구간별 swish, `x * clamp(x + 3, 0, 6) / 6`.

```text
out[0] = in[0] * clamp(in[0] + 3, 0, 6) / 6
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### HeaderView

채널 축을 attention head로 나눠 H 축으로 쌓습니다.

`[1, H, W, heads*D]` projection을 head별 `D` 채널 행으로 바꾸는 reshape-transpose-reshape를 하나의 연산으로 표현합니다. 모든 head의 행을 H 축으로 쌓습니다.

```text
D = C / num_heads
batch_order = 0 (head-minor rows, row = h*num_heads + head):
  [1, H, W, C] -reshape-> [1, H, W, num_heads, D]
               -transpose(0,1,3,2,4)-> [1, H, num_heads, W, D]
               -reshape-> [1, H*num_heads, W, D]
batch_order = 1 (head-major rows, row = head*H + h):
  [1, H, W, C] -reshape-> [1, H, W, num_heads, D]
               -transpose(0,3,1,2,4)-> [1, num_heads, H, W, D]
               -reshape-> [1, num_heads*H, W, D]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `view_shape` | `int32[]` | `[]` | 사용 중단(deprecated)되었으며 무시합니다. `num_heads`를 씁니다. |
| `num_heads` | `int32` | `-1` | head 수. `C`를 나누어떨어지게 합니다. |
| `batch_order` | `int32` | `0` | 쌓인 head의 행 순서. `0`은 H의 각 행 안에서 head를 번갈아 두고, `1`은 head마다 H개 행을 연속으로 둡니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H*num_heads, W, C/num_heads]` | 출력 활성화 텐서. |

### HeaderViewRevert

H 축에 쌓인 attention head를 풀어 채널 축으로 다시 합칩니다.

H 축으로 쌓인 `D` 채널짜리 head별 행 `[1, num_heads*H, W, D]`를 채널 축으로 이어 붙여 `[1, H, W, num_heads*D]`로 만듭니다. `batch_order`는 행을 쌓을 때 쓴 값과 같아야 합니다.

```text
in[0] is [1, num_heads*H, W, D]
batch_order = 0 (input row = h*num_heads + head):
  -reshape-> [1, H, num_heads, W, D]
  -transpose(0,1,3,2,4)-> [1, H, W, num_heads, D]
  -reshape-> [1, H, W, num_heads*D]
batch_order = 1 (input row = head*H + h):
  -reshape-> [1, num_heads, H, W, D]
  -transpose(0,2,3,1,4)-> [1, H, W, num_heads, D]
  -reshape-> [1, H, W, num_heads*D]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, num_heads*H, W, D]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `revert_shape` | `int32[]` | `[]` | 사용 중단(deprecated)되었으며 무시합니다. `num_heads`를 씁니다. |
| `num_heads` | `int32` | `-1` | head 수. in\[0\]의 H 크기를 나누어떨어지게 합니다. |
| `batch_order` | `int32` | `0` | in\[0\]에 쌓인 head의 행 순서. `0`은 H의 각 행 안에서 head가 번갈아 있고, `1`은 head마다 H개 행이 연속으로 있습니다. `HeaderView`와 같은 의미입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H, W, num_heads*D]` | 출력 활성화 텐서. |

### Input

활성화 텐서를 그래프 입력으로 지정합니다.

in\[0\]이 그래프 밖에서 공급됨을 나타냅니다. 피연산자와 결과가 같은 활성화 텐서이므로 계산은 없으며, 그 활성화 텐서를 그래프 입력으로 지정할 뿐입니다.

```text
out[0] = in[0]      (the same activation)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `orig_name` | `str` | `""` | 원본 모델에서 이 입력의 사용자용 이름. 컴파일된 모델이 같은 입력 이름을 쓰도록 보존합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### InputConstant

모델에 저장된 상수를 활성화 텐서로 제공합니다.

피연산자가 없으며, 결과는 원소 타입 `dtype`, shape `shape`인 저장된 `constant`입니다.

```text
out[0] = constant
```

#### 입력

없음.

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `constant` | `Weight` | 필수 | 상수 값. |
| `dtype` | `str` | `""` | 상수의 원소 타입 이름. 예를 들어 `float32`, `int64`. |
| `shape` | `int32[]` | `[]` | 상수의 shape이며 out\[0\]의 shape입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `shape` | 출력 활성화 텐서. |

### InstanceNormalization

채널마다 H, W에 대해 정규화합니다.

배치 항목의 모든 채널을 H, W에 대해 평균 0, 분산 1로 정규화한 뒤 채널별 `scale`과 `bias`를 적용합니다. 분산은 모집단 분산입니다. 여러 채널이 통계를 공유하는 정규화(`num_groups`가 `-1`이 아닌 경우)는 `GroupNormalization`으로 표현합니다.

```text
mu[n, c]  = mean(in[0][n, :, :, c])
var[n, c] = mean((in[0][n, :, :, c] - mu[n, c])^2)
out[0][n, h, w, c] = (in[0][n, h, w, c] - mu[n, c]) / sqrt(var[n, c] + epsilon)
                     * scale[c] + bias[c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `scale` | `Weight` | 필수 | scale(gamma). |
| `bias` | `Weight` | 선택 | bias(beta). shape은 `scale`과 같습니다. 없으면 0. |
| `epsilon` | `Weight` | 필수 | 수치 안정성을 위해 분산에 더하는 scalar. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |
| `num_groups` | `int32` | `-1` | 항상 `-1`. 채널을 묶어 정규화하는 경우는 `GroupNormalization`입니다. |
| `group_order` | `int32` | `-1` | 항상 `-1`. 사용하지 않습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### InverseSigmoid

sigmoid의 역함수 `log(x / (1 - x))`. `eps`로 유한한 값을 유지합니다.

in\[0\]을 \[0, 1\]로 제한한 뒤 `x / (1 - x)`의 분자와 분모를 `eps` 이상으로 유지하므로, 0과 1 및 그 바깥의 입력에서도 결과가 유한합니다.

```text
x1 = max(clamp(in[0], 0, 1), eps)
x2 = max(1 - x1, eps)
out[0] = log(x1 / x2)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `eps` | `float32` | `1e-05` | 분자와 분모에 적용하는 하한. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### L1Normalization

지정한 축에 대한 절댓값 합으로 나눕니다.

in\[0\]을 `norm_axis` 방향 절댓값의 합이 1이 되도록 나누며, 나머지 축의 위치마다 따로 계산합니다. 나누는 값의 하한은 1e-12입니다.

```text
s      = sum(abs(in[0]), norm_axis, keep_dims=true)
out[0] = in[0] / max(s, 1e-12)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `norm_axis` | `int32[]` | 필수 | 정규화할 축. in\[0\]의 실제 배치 순서에 대한 index이며, 음수는 마지막 축부터 셉니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### L2Normalization

지정한 축에 대한 Euclidean norm으로 나눕니다.

in\[0\]을 `norm_axis` 방향 L2 norm이 1이 되도록 나누며, 나머지 축의 위치마다 따로 계산합니다. 0으로 나누지 않도록 norm의 하한을 `epsilon`으로 둡니다.

```text
r      = sqrt(sum(in[0]^2, norm_axis, keep_dims=true))
out[0] = in[0] / max(r, epsilon)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `norm_axis` | `int32[]` | 필수 | 정규화할 축. in\[0\]의 실제 배치 순서에 대한 index이며, 음수는 마지막 축부터 셉니다. |
| `epsilon` | `Weight` | 선택 | norm의 하한. 없으면 1e-12. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### LayerNormalization

마지막 축들에 대해 정규화한 뒤 scale과 bias를 적용합니다.

in\[0\]의 마지막 `len(normalized_shape)`개 축에 대해 평균 0, 분산 1로 정규화한 뒤 원소별 affine `scale`, `bias`를 적용합니다. 평균과 분산은 나머지 앞쪽 축의 위치마다 따로 구하며, 분산은 편향(모집단) 분산입니다.

```text
axes   = the last len(normalized_shape) axes of in[0]
mu     = mean(in[0], axes)
var    = mean((in[0] - mu)^2, axes)
out[0] = (in[0] - mu) / sqrt(var + epsilon) * scale + bias
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[..., *normalized_shape]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `normalized_shape` | `int64[]` | `[]` | 정규화할 마지막 축들의 shape. 예를 들어 NHWC 활성화 텐서의 채널 축을 정규화하면 `[C]`. |
| `scale` | `Weight` | 필수 | 원소별 scale(gamma). shape은 `normalized_shape`. |
| `bias` | `Weight` | 선택 | 원소별 bias(beta). shape은 `normalized_shape`. 없으면 0. |
| `epsilon` | `Weight` | 필수 | 수치 안정성을 위해 분산에 더하는 scalar. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### LeakyRelu

음수 입력에 scalar 기울기 `leaky_alpha`를 주는 ReLU.

음수 원소에 scalar 기울기 하나를 곱합니다.

```text
out[0] = in[0]                 if in[0] >= 0
         leaky_alpha * in[0]   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `leaky_alpha` | `float32` | 필수 | 음수 입력의 기울기. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Log

원소별 자연로그.

```text
out[0] = ln(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### MatMul

두 활성화 텐서의 마지막 두 축에 대한 batch 행렬 곱.

in\[0\]과 in\[1\]을 마지막 두 축에 대한 행렬로 보고 곱합니다. 앞쪽 축은 모두 batch 축이며 broadcast합니다. 4-D NHWC 활성화 텐서에서는 `[W, C]`가 행렬이고 N, H가 batch 축입니다.

```text
a = in[0],  b = in[1]
repeat = [0, R]:  a = repeat_interleave(a, R, axis=1)
repeat = [1, R]:  b = repeat_interleave(b, R, axis=1)
  where repeat_interleave(x, R, axis=1)[n, h, ...] = x[n, floor(h / R), ...]
out[0][..., m, p] = sum_k a[..., m, k] * b[..., k, p]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[..., M, K]` | 입력 활성화 텐서. |
| `in[1]` | `[..., K, P]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `constant` | `Weight` | 선택 | 사용하지 않는 속성으로 항상 `-1`입니다. 상수 행렬은 `InputConstant`에서 나온 활성화 텐서로 전달합니다. |
| `is_const_first` | `bool` | `false` | 사용하지 않는 속성으로 항상 `false`입니다. |
| `repeat` | `int32[2]` | `[-1, -1]` | `[operand, R]`. 곱하기 전에 `operand`번 피연산자(`0` = in\[0\], `1` = in\[1\])를 축 1(H)을 따라 `R`번 반복하며, 각 H slice를 제자리에서 `R`번 되풀이합니다(`h0 h1 h0 h1 ...`이 아니라 `h0 h0 h1 h1 ...`). `[-1, -1]`이면 반복하지 않습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | \[앞쪽 축의 broadcast 결과, M, P\] | 출력 활성화 텐서. |

### Mish

self-gated 활성화 텐서 `x * tanh(softplus(x))`.

```text
out[0] = in[0] * tanh(log(1 + exp(in[0])))
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Multiply

두 활성화 텐서의 원소별 곱.

두 활성화 텐서를 원소별로 곱합니다.

```text
out[0] = in[0] * in[1]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |
| `in[1]` | in\[0\]과 broadcast 가능 | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], in[1])` | 출력 활성화 텐서. |

### MultiplyConstant

활성화 텐서에 상수 텐서를 곱합니다.

활성화 텐서 하나에 모델에 저장된 상수를 곱합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다.

```text
out[0] = constant * in[0]   if is_const_first
         in[0] * constant   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `constant` | `Weight` | 필수 | 상수 피연산자. in\[0\]에 맞춰 broadcast합니다. |
| `is_const_first` | `bool` | `false` | 상수가 왼쪽 피연산자이면 `true`. |
| `shape` | `int32[]` | `[]` | 저장된 `constant`를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in\[0\]), shape)입니다. 기본값 `[]`은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], shape)` | 출력 활성화 텐서. |

### OrderedPatchify

H x W를 window로 나누고 픽셀을 window 단위로 재배치합니다.

`[1, H, W, C]` map을 `h_kernel x w_kernel` window의 `gh x gw` 격자로 자르고 H, W 위의 2-D 배치로 펼치는 reshape-transpose-reshape를 하나의 연산으로 표현합니다. `order=0`은 window마다 한 행이며 그 픽셀을 raster 순서로 담습니다. `order=1`은 이를 H/W 전치한 것으로 window 내 픽셀 위치마다 한 행입니다. `order=2`는 `order=1`을 되돌립니다. 채널은 통째로 옮겨지며 섞이지 않습니다.

```text
gh = H / h_kernel,  gw = W / w_kernel
x = reshape(in[0], [1, gh, h_kernel, gw, w_kernel, C])
order 0: out[0] = reshape(transpose(x, 0,1,3,2,4,5), [1, gh*gw, h_kernel*w_kernel, C])
order 1: out[0] = reshape(transpose(x, 0,2,4,1,3,5), [1, h_kernel*w_kernel, gh*gw, C])
order 2: out[0] = reshape(transpose(x, 0,3,1,4,2,5), [1, gw*gh, w_kernel*h_kernel, C])
Element map, p < gh, q < h_kernel, u < gw, v < w_kernel:
  in[0][0, p*h_kernel + q, u*w_kernel + v, c] =
    order 0: out[0][0, p*gw + u, q*w_kernel + v, c]
    order 1: out[0][0, q*w_kernel + v, p*gw + u, c]
    order 2: out[0][0, u*gh + p, v*h_kernel + q, c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `h_kernel` | `int32` | 필수 | window 높이. H를 나누어떨어지게 합니다. |
| `w_kernel` | `int32` | 필수 | window 너비. W를 나누어떨어지게 합니다. |
| `order` | `int32` | `0` | 배치 방식. `0`은 window마다 한 행, `1`은 window 내 위치마다 한 행(`0`의 전치), `2`는 `1`의 역변환입니다. formula를 참고합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | order 0, 2는 \[1, gh*gw, h\_kernel*w\_kernel, C\], order 1은 \[1, h\_kernel*w\_kernel, gh*gw, C\] | 출력 활성화 텐서. |

### Output

활성화 텐서를 그래프 출력으로 지정합니다.

in\[0\]을 그래프가 반환함을 나타냅니다. 피연산자와 결과가 같은 활성화 텐서이므로 계산은 없으며, 그 활성화 텐서를 그래프 출력으로 지정할 뿐입니다.

```text
out[0] = in[0]      (the same activation)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `orig_name` | `str` | `""` | 원본 모델에서 이 출력의 사용자용 이름. 컴파일된 모델이 같은 출력 이름을 쓰도록 보존합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Pad

NHWC 활성화 텐서의 H, W 축을 상수 또는 reflection으로 padding합니다.

in\[0\]의 위에 `north_padding`, 아래에 `south_padding`, 왼쪽에 `west_padding`, 오른쪽에 `east_padding`만큼 padding을 덧붙입니다. batch 축과 채널 축은 padding하지 않습니다.

```text
H_out = north_padding + H + south_padding
W_out = west_padding  + W + east_padding
out[0][n, north_padding + i, west_padding + j, c] = in[0][n, i, j, c]
other cells:
  constant:  constant
  reflect:   in[0] mirrored about its first/last row and column, edge not
             repeated (the row above row 0 is row 1)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `west_padding` | `int32` | `-1` | W 시작(왼쪽)에 추가하는 열 수. |
| `east_padding` | `int32` | `-1` | W 끝(오른쪽)에 추가하는 열 수. |
| `south_padding` | `int32` | `-1` | H 끝(아래쪽)에 추가하는 행 수. |
| `north_padding` | `int32` | `-1` | H 시작(위쪽)에 추가하는 행 수. |
| `pad_mode` | `str` | 필수 | `constant`이면 새 칸을 `constant`로 채우고, `reflect`이면 가장자리 행이나 열을 반복하지 않고 경계를 기준으로 in\[0\]을 거울상으로 채웁니다. |
| `constant` | `float32` | `0.0` | `pad_mode = constant`일 때 채우는 값. |
| `padding_list` | `int32[]` | 선택 | 같은 padding을 모든 축에 대해 `[x1_begin, x2_begin, ..., x1_end, x2_end, ...]`로 적은 값으로, NHWC에서는 `[0, top, left, 0, 0, bottom, right, 0]`입니다. 참고용이며 계산에는 네 `*_padding` 속성을 씁니다. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, C]` | 출력 활성화 텐서. |

### Pooling

NHWC 활성화 텐서의 슬라이딩 window에 대한 2-D max 또는 average pooling.

in\[0\]을 `*_padding` 속성만큼 `pad_mode`가 정한 값으로 padding한 뒤, stride만큼 이동하고 dilation만큼 벌어진 `h_kernel` x `w_kernel` window마다 최댓값(`MaxPool`) 또는 평균(`AvgPool`)을 구합니다. 채널은 서로 독립적으로 pooling합니다.

```text
xp = pad(in[0], top=north_padding, bottom=south_padding,
                left=west_padding, right=east_padding)    (fill per pad_mode)
win(n, y, x, c) = { xp[n, y*h_stride + ky*h_dilation, x*w_stride + kx*w_dilation, c]
                    : ky < h_kernel, kx < w_kernel }
MaxPool:  out[0][n, y, x, c] = max(win(n, y, x, c))
AvgPool:  out[0][n, y, x, c] = sum(win(n, y, x, c)) / cnt
          cnt = h_kernel * w_kernel                    if is_include_pad
                number of window cells inside in[0]    otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `h_kernel` | `int32` | 필수 | window 높이. |
| `w_kernel` | `int32` | 필수 | window 너비. |
| `h_stride` | `int32` | 필수 | H 방향 stride. |
| `w_stride` | `int32` | 필수 | W 방향 stride. |
| `h_dilation` | `int32` | `1` | H 방향 dilation. |
| `w_dilation` | `int32` | `1` | W 방향 dilation. |
| `west_padding` | `int32` | 필수 | W 시작(왼쪽)의 padding. |
| `east_padding` | `int32` | 필수 | W 끝(오른쪽)의 padding. |
| `north_padding` | `int32` | 필수 | H 시작(위쪽)의 padding. |
| `south_padding` | `int32` | 필수 | H 끝(아래쪽)의 padding. |
| `padding_list` | `int32[]` | `[]` | 원래 2-D padding `[top, left, bottom, right]`. 참고용이며 비어 있을 수 있습니다. 계산에는 네 `*_padding` 속성을 씁니다. |
| `pool_type` | `str` | 필수 | window 최댓값이면 `MaxPool`, window 평균이면 `AvgPool`. |
| `pad_mode` | `str` | 필수 | padding 영역을 채우는 값. `constant`(0), `-inf`(음의 무한대로, padding이 최댓값이 되지 않음), `reflect`(가장자리를 반복하지 않는 경계 기준 거울상) 중 하나입니다. `-inf`는 `AvgPool`과 `is_include_pad = true` 조합에 쓰지 않습니다. |
| `is_ceil_mode` | `bool` | `false` | 원래 pooling이 출력 크기를 올림했음을 기록합니다. 참고용이며, 출력 크기는 항상 아래의 내림 공식을 따르므로 올림한 크기는 `south_padding`(아래쪽), `east_padding`(오른쪽)의 추가 padding으로 표현됩니다. |
| `is_include_pad` | `bool` | `false` | `AvgPool`에만 적용합니다. `true`이면 padding 칸을 포함한 전체 window 크기 `h_kernel * w_kernel`로 나누고, `false`이면 window 중 in\[0\] 안에 있는 칸 수로 나눕니다. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, C]` | 출력 활성화 텐서. |

### Pow

각 원소를 상수 scalar 지수로 거듭제곱합니다.

in\[0\]의 모든 원소를 같은 지수로 거듭제곱합니다.

```text
out[0] = in[0] ^ exponent
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `exponent` | `float32` | 필수 | scalar 지수. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### PRelu

음수 기울기가 상수 텐서인 leaky ReLU.

음수 원소에 모델에 저장된 텐서 기울기 `leaky_alpha`를 곱합니다. 기울기는 in\[0\]에 마지막 축부터 맞춰 broadcast합니다.

```text
out[0] = in[0]                 if in[0] >= 0
         leaky_alpha * in[0]   otherwise   (leaky_alpha broadcast to in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `leaky_alpha` | `Weight` | 필수 | 음수 입력의 기울기. in\[0\]에 broadcast 가능해야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### QuickGelu

GELU의 sigmoid 근사, `x * sigmoid(1.702 * x)`.

`sigmoid(1.702 * x)`를 gate로 써서 `Gelu`를 근사합니다.

```text
out[0] = in[0] * sigmoid(1.702 * in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### ReduceMax

지정한 축에 대한 최댓값.

in\[0\]의 `reduce_axes` 축에서 가장 큰 원소를 고르며, 나머지 축의 위치마다 따로 구합니다.

```text
out[0] = max(in[0], reduce_axes, keep_dims)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `keep_dims` | `bool` | 필수 | `true`이면 축약한 축을 크기 1로 남기고, `false`이면 제거합니다. |
| `reduce_axes` | `int32[]` | 필수 | 축약할 축. in\[0\]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 `3`이 채널 축), 음수는 마지막 축부터 셉니다. |
| `noop_with_empty_axes` | `int32` | 필수 | `reduce_axes`가 비어 있을 때만 의미가 있습니다. `1`이면 in\[0\]을 그대로 돌려주고, `0`이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]에서 축약한 축을 1로 두거나 제거한 shape | 출력 활성화 텐서. |

### ReduceMean

지정한 축에 대한 산술 평균.

in\[0\]을 `reduce_axes` 축에 대해 평균하며, 나머지 축의 위치마다 따로 구합니다.

```text
out[0] = sum(in[0], reduce_axes, keep_dims) / (product of in[0]'s sizes on reduce_axes)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `keep_dims` | `bool` | 필수 | `true`이면 축약한 축을 크기 1로 남기고, `false`이면 제거합니다. |
| `reduce_axes` | `int32[]` | 필수 | 축약할 축. in\[0\]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 `3`이 채널 축), 음수는 마지막 축부터 셉니다. |
| `noop_with_empty_axes` | `int32` | 필수 | `reduce_axes`가 비어 있을 때만 의미가 있습니다. `1`이면 in\[0\]을 그대로 돌려주고, `0`이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]에서 축약한 축을 1로 두거나 제거한 shape | 출력 활성화 텐서. |

### ReduceMin

지정한 축에 대한 최솟값.

in\[0\]의 `reduce_axes` 축에서 가장 작은 원소를 고르며, 나머지 축의 위치마다 따로 구합니다.

```text
out[0] = min(in[0], reduce_axes, keep_dims)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `keep_dims` | `bool` | 필수 | `true`이면 축약한 축을 크기 1로 남기고, `false`이면 제거합니다. |
| `reduce_axes` | `int32[]` | 필수 | 축약할 축. in\[0\]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 `3`이 채널 축), 음수는 마지막 축부터 셉니다. |
| `noop_with_empty_axes` | `int32` | 필수 | `reduce_axes`가 비어 있을 때만 의미가 있습니다. `1`이면 in\[0\]을 그대로 돌려주고, `0`이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]에서 축약한 축을 1로 두거나 제거한 shape | 출력 활성화 텐서. |

### ReduceSum

지정한 축에 대한 합.

in\[0\]의 `reduce_axes` 축 원소를 모두 더하며, 나머지 축의 위치마다 따로 구합니다.

```text
out[0] = sum(in[0], reduce_axes, keep_dims)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `keep_dims` | `bool` | 필수 | `true`이면 축약한 축을 크기 1로 남기고, `false`이면 제거합니다. |
| `reduce_axes` | `int32[]` | 필수 | 축약할 축. in\[0\]의 실제 배치 순서에 대한 index이며(NHWC 활성화 텐서에서 `3`이 채널 축), 음수는 마지막 축부터 셉니다. |
| `noop_with_empty_axes` | `int32` | 필수 | `reduce_axes`가 비어 있을 때만 의미가 있습니다. `1`이면 in\[0\]을 그대로 돌려주고, `0`이면 모든 축을 축약합니다. IR은 보통 축약할 축을 명시합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]에서 축약한 축을 1로 두거나 제거한 shape | 출력 활성화 텐서. |

### RelShift

relative offset attention score를 absolute key 위치로 재배열합니다.

Transformer-XL 방식 attention의 relative position shift입니다. in\[0\]의 행 `i`는 query `i`의 `2Q - 1`개 relative offset score를 담으며, 열 `k`는 query - key `= Q - 1 - k`를 뜻합니다. 행 `i`를 왼쪽으로 `Q - 1 - i`만큼 밀고 `Q`개 열만 남기므로 결과의 열 `j`는 key `j`에 대한 score입니다.

```text
out[0][n, h, i, j] = in[0][n, h, i, Q - 1 - i + j],   i, j < Q
Equivalent sequence on [1, H, Q, P], P = 2Q - 1:
  pad one zero at the start of axis 3   -> [1, H, Q, P+1]
  reshape                               -> [1, H, P+1, Q]
  drop the first row of axis 2          -> [1, H, P, Q]
  reshape                               -> [1, H, Q, P]
  slice axis 3 to [0, Q)                -> [1, H, Q, Q]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, Q, 2Q-1]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H, Q, Q]` | 출력 활성화 텐서. |

### Relu

rectified linear unit, `max(x, 0)`.

```text
out[0] = max(in[0], 0)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Reshape

원소 순서를 바꾸지 않고 활성화 텐서의 shape만 바꿉니다.

in\[0\]을 `new_shape` shape으로 바꿔 반환합니다. 원소는 row-major 순서(마지막 축이 가장 빠름)를 그대로 유지합니다.

```text
out[0] = reshape(in[0], new_shape)
flatten(out[0]) == flatten(in[0])   (same elements, row-major order)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `new_shape` | `int32[]` | 선택 | 목표 shape. 한 항목은 `-1`일 수 있으며, 원소 수가 같도록 추론합니다. `0` 항목은 `allowzero`에 따라 해석하며, graph builder가 명시적인 크기를 기록하므로 보통 `0`은 나타나지 않습니다. |
| `allowzero` | `int32` | `0` | `new_shape`의 `0`을 해석하는 방식. `0`이면 같은 위치의 in\[0\] 크기를 복사하고, `1`이면 길이 0인 축이 됩니다. |
| `is_const_first` | `bool` | `false` | 계산에 쓰이지 않습니다. in\[0\]이 항상 데이터입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | \-1을 계산한 new\_shape | 출력 활성화 텐서. |

### Resize

nearest, bilinear, bicubic 보간으로 공간 축의 크기를 바꿉니다.

in\[0\]을 새 H x W로 다시 샘플링합니다. `sizes`와 `scales`는 in\[0\]의 축 순서대로 축마다 값 하나를 가지며, 입력과 달라질 수 있는 축은 두 공간 축뿐입니다.

```text
shape(out[0]) = sizes                     if sizes is given
                shape(in[0]) * scales     otherwise, axis by axis
s_h = H_out / H,  s_w = W_out / W         (or the matching scales entries)
nearest:  out[0][n, y, x, c] = in[0][n, floor(y / s_h), floor(x / s_w), c]
linear:   bilinear blend of the 2 x 2 input pixels around (ys, xs)
cubic:    bicubic blend of the 4 x 4 input pixels around (ys, xs)
where the source row ys of output row y follows transform_mode
(columns likewise with x, W, W_out, s_w):
  half_pixel:     ys = (y + 0.5) / s_h - 0.5
  align_corners:  ys = y * (H - 1) / (H_out - 1)
  asymmetric:     ys = y / s_h
source positions outside the input are clamped to the border
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `resize_type` | `str` | 선택 | 보간 방식. `nearest`, `linear`(H, W에 대한 bilinear), `cubic`(bicubic) 중 하나입니다. |
| `resize_mode` | `str` | 선택 | 그래프를 만들 때 기록한 보간 방식. 값은 `resize_type`과 같으며 없을 수도 있습니다. 계산에는 `resize_type`을 씁니다. |
| `nearest_mode` | `str` | 선택 | 원래 모델이 `nearest`에 쓰던 반올림 규칙(`round_prefer_floor`, `round_prefer_ceil`, `floor`, `ceil`). 기록용이며, `nearest`는 formula처럼 항상 내림합니다. |
| `transform_mode` | `str` | 선택 | `linear`와 `cubic`에서 출력 좌표를 입력 좌표로 옮기는 방식. `half_pixel`(픽셀 중심 정렬. 그 밖의 기록값도 이 방식을 따름), `align_corners`(모서리 픽셀 정렬), `asymmetric`(출력 인덱스를 배율로 나눔) 중 하나이며, 식은 formula를 따릅니다. `nearest`는 항상 asymmetric 방식을 씁니다. |
| `roi` | `int32[]` | 선택 | crop-and-resize의 관심 영역. 기록용이며 계산에 쓰지 않습니다. |
| `scales` | `float32[]` | 선택 | in\[0\]의 축별 배율. 크기가 그대로인 축은 `1.0`입니다. 예를 들어 `[1, 2, 2, 1]`은 NHWC 텐서의 H와 W를 두 배로 늘립니다. |
| `sizes` | `int32[]` | 선택 | 출력 shape. in\[0\]의 축마다 값 하나를 가집니다. |
| `cubic_coeff_a` | `float32` | 선택 | `cubic`의 cubic kernel 계수 `a`. 기록용이며 계산에 쓰지 않습니다. |
| `exclude_outside` | `int32` | 선택 | `cubic`에서 `1`이면 입력 밖의 kernel tap을 버리고 나머지 가중치를 다시 정규화합니다. 기록용이며 계산에 쓰지 않습니다. |
| `extrapolation_value` | `float32` | 선택 | crop-and-resize에서 원본 위치가 입력 밖인 출력 픽셀의 값. 기록용이며 계산에 쓰지 않습니다. |
| `antialias` | `int32` | 선택 | `1`이면 `linear`나 `cubic`으로 축소할 때 저역 통과(antialiasing) 필터를 적용하고, `0`이거나 없으면 적용하지 않습니다. |
| `axes` | `int32[]` | 선택 | 원래 resize가 배율이나 크기를 지정한 축. 기록용이며, IR의 `scales`와 `sizes`는 항상 모든 축을 다룹니다. |
| `keep_aspect_ratio_policy` | `str` | 선택 | 원래 resize가 종횡비를 지키며 목표 크기를 맞춘 방식(`stretch`, `not_larger`, `not_smaller`). 기록용이며 계산에 쓰지 않습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, C]` | 출력 활성화 텐서. |

### RmsNormalization

마지막 축들에 대한 root mean square로 나눈 뒤 scale을 곱합니다.

in\[0\]을 마지막 `len(normalized_shape)`개 축에 대한 root mean square로 나누고 `scale`을 곱합니다. `rms_center`가 있으면 RMS는 `in[0] - rms_center`로 구하지만 분자는 in\[0\] 그대로입니다.

```text
axes   = the last len(normalized_shape) axes of in[0]
center = rms_center if present, else 0
rms    = sqrt(mean((in[0] - center)^2, axes, keep_dims=true) + epsilon)
out[0] = in[0] / rms * scale
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[..., *normalized_shape]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `normalized_shape` | `int64[]` | `[]` | 정규화할 마지막 축들의 shape. 보통 NHWC 활성화 텐서의 채널 축인 `[C]`입니다. |
| `epsilon` | `Weight` | 필수 | 수치 안정성을 위해 제곱 평균에 더하는 scalar. |
| `scale` | `Weight` | 필수 | 원소별 scale(gamma). shape은 `normalized_shape`. |
| `rms_center` | `Weight` | 선택 | RMS 안에서만 in\[0\]에서 빼는 채널별 offset. 없으면 0. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Sigmoid

입력 배율 `alpha`를 둘 수 있는 logistic sigmoid.

`1 / (1 + exp(-alpha * x))`를 계산합니다.

```text
out[0] = 1 / (1 + exp(-alpha * in[0]))
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `alpha` | `float32` | `1.0` | sigmoid 전에 입력에 곱하는 배율. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Sin

원소별 sine.

```text
out[0] = sin(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Slice

하나 이상의 축을 따라 일정 간격의 부분 구간을 잘라냅니다.

나열된 각 축에서 `start`부터 `end` 직전까지 `step` 간격으로 원소를 남기고, 나머지 축은 그대로 둡니다. 목록은 위치별로 대응하므로 `start`, `end`, `step`의 k번째 항목이 `axis[k]` 축에 적용됩니다.

```text
for each k, along axis a = axis[k] with length D = in[0].shape[a]:
    s = start[k] (+ D if negative), clamped to [0, D]
    e = end[k]   (+ D if negative), clamped to [0, D]
    keep indices s, s + step[k], s + 2*step[k], ... while < e
out[0] = in[0] restricted to the kept indices on every listed axis
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `axis` | `int32[]` | 필수 | 자를 축 목록. 음수는 마지막 축부터 셉니다. |
| `start` | `int64[]` | 필수 | 각 축에서 남길 첫 인덱스(포함). |
| `end` | `int64[]` | 필수 | 각 축의 끝 인덱스(제외). 축 길이를 넘는 값은 축 길이로 맞추므로 `2147483647`처럼 큰 값은 "끝까지"를 뜻합니다. |
| `step` | `int64[]` | 선택 | 각 축의 간격. 없으면 모든 축에서 1. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | 자른 축만 줄어든 in\[0\] shape | 출력 활성화 텐서. |

### Softmax

한 축을 따라 지수값을 합이 1이 되도록 정규화합니다.

in\[0\]의 `axis` 축에 대해 softmax를 계산하며, 필요하면 먼저 입력에 `beta`를 곱합니다.

```text
z = beta * in[0]
out[0] = exp(z) / sum(exp(z), axis)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `beta` | `float32` | `1.0` | 지수 전에 입력에 곱하는 배율. 0이면 안 됩니다. |
| `axis` | `int32` | 필수 | 정규화할 축. 음수는 마지막 축부터 셉니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Softplus

부드러운 ReLU `log(1 + exp(beta * x)) / beta`. `threshold` 위에서는 선형입니다.

`beta * x`가 `threshold`를 넘는 곳에서는 출력이 `x` 자체입니다.

```text
out[0] = in[0]                               if beta * in[0] > threshold
         log(1 + exp(beta * in[0])) / beta   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `beta` | `float32` | `1.0` | 곡선의 날카로움. 클수록 ReLU에 가까워집니다. |
| `threshold` | `float32` | `20.0` | 출력이 선형으로 바뀌는 `beta * x`의 경계값. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Sqrt

원소별 제곱근.

```text
out[0] = sqrt(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### StaggeredPadding

각 행렬의 r번째 행을 r열만큼 밀고 0으로 채운 뒤 잘라냅니다.

`[1, H, W, C]`의 마지막 두 축을 길이 `C`인 행 `W`개로 보고, 각 행을 행 번호만큼 밀어 0으로 채운 행에 놓아 계단 형태를 만듭니다. `reverse=false`는 행 `r`을 오른쪽으로 `r`만큼 밀고 양쪽에서 `window_size`열을 잘라냅니다. `reverse=true`는 행 `r`마다 열 `r`을 중심으로 한 `2*window_size + 1`개 열을 읽습니다.

```text
x[n, h, r, k] = in[0][n, h, r, k] for 0 <= k < C, and 0 for any other k
reverse = false:
  o = 0 if window_size = -1, else window_size
  out[0][n, h, r, j] = x[n, h, r, j + o - r],        j < W + C - 1 - 2*o
reverse = true:
  out[0][n, h, r, j] = x[n, h, r, r + j - window_size],   j < 2*window_size + 1
Equivalent sequence for reverse = false:
  [1, H, W, C] -pad axis 3 end by W-> [1, H, W, C+W] -reshape-> [1, H, W*(C+W)]
  -drop the last W-> -reshape-> [1, H, W, W+C-1] -slice axis 3 [o, W+C-1-o)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `axis` | `int32` | `3` | 원소를 이동하는 축. `3`(마지막 축)만 정의되어 있으며, 행은 축 2를 따라 놓입니다. |
| `reverse` | `bool` | `false` | `false`이면 행 `r`이 열 `r`에서 시작합니다(오른쪽 아래로 내려가는 계단). `true`이면 행 `r`이 열 `W - 1 - r`에서 시작하고(왼쪽 아래로 내려가는 계단), 결과를 폭 `2*window_size + 1`의 band로 잘라냅니다. |
| `window_size` | `int32` | `-1` | `reverse=false`에서는 양쪽에서 잘라낼 열 수이며, `-1`이면 전체 폭 `W + C - 1`을 유지합니다. `reverse=true`에서는 band의 반폭이며 반드시 지정해야 하고(`-1` 불가), `W`와 `C`는 각각 `window_size + 1` 이상입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | reverse=false는 \[1, H, W, W + C - 1 - 2*o\], reverse=true는 \[1, H, W, 2*window\_size + 1\] | 출력 활성화 텐서. |

### StatefulAttentionMaskWrapper

attention score에 causal, sliding-window 또는 주어진 mask를 더합니다.

attention score에 mask를 적용합니다. `causal_mask`에서는 `Q`개 query를 `K`개 key 위치 중 마지막 `Q`개로 보고 score shape만으로 bias를 만듭니다. `custom_mask`에서는 bias를 두 번째 입력으로 받습니다.

```text
custom_mask:
  out[0] = in[0] + in[1]
causal_mask:
  qp(i) = K - Q + i                        key position of query i
  masked(i, j) = j > qp(i)  or  (is_sliding and j <= qp(i) - sliding_window)
  out[0][..., i, j] = -inf if masked(i, j) else in[0][..., i, j]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, heads, Q, K]` | 입력 활성화 텐서. |
| `in[1]` | in\[0\]과 broadcast 가능 | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `past_seqlen` | `int32` | `0` | graph를 trace할 때 query 앞에 있던 cache 위치 수. 참고용이며 mask는 실행 시 `Q`와 `K`를 따릅니다. |
| `is_sliding` | `bool` | `false` | `true`이면 query보다 `sliding_window` 이상 앞선 key도 가립니다(`causal_mask` 전용). |
| `sliding_window` | `int32` | `1024` | `is_sliding`일 때 query가 볼 수 있는 가장 최근 key 위치 수(query 자신 포함). |
| `mask_type` | `str` | `"causal_mask"` | `causal_mask`는 위치로 mask를 만들며 입력이 하나입니다. `custom_mask`는 in\[1\]을 더하며 입력이 둘입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### StatefulCachedStack

이전 호출에서 보관한 마지막 원소들을 한 축 앞에 붙입니다.

`axis` 방향 마지막 `cache_len`개 원소를 호출 사이에 보관하고 새 입력 앞에 붙입니다. 첫 호출에서는 0이 붙고, 이후 호출에서는 앞선 입력의 끝부분이 붙습니다. 보관하는 window는 연산이 가진 상태이며 피연산자가 아닙니다.

```text
state: entries of shape in[0] with axis extent cache_len, initially zeros
out[0] = concat(state, in[0], axis)
state  = last cache_len entries of out[0] along axis
cache_len = 0:  out[0] = in[0]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `axis` | `int32` | `2` | 이어 붙이는 축. 기본값 2는 NHWC의 sequence 축 W입니다. 음수는 마지막 축부터 셉니다. |
| `cache_len` | `int32` | `0` | 보관해서 앞에 붙이는 원소 수. `0`이면 identity입니다. |
| `cache_name` | `str` | 필수 | 보관하는 window의 이름. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]에서 axis 크기 + cache\_len | 출력 활성화 텐서. |

### StatefulGRUWrapper

시퀀스에 GRU를 적용해 단계별 출력과 최종 hidden state를 반환합니다.

in\[0\]의 시간 축을 따라 상수 weight `W`, `R`, `B`로 GRU recurrence를 한 방향 또는 양방향으로 계산합니다. 어떤 피연산자가 있는지는 `input_mask`로 나타내며, 결과는 항상 `out[0]` (모든 step의 hidden state)과 `out[1]` (최종 hidden state)입니다.

```text
batch_first = true; T = steps; @ = matrix product, * = element-wise product
for each direction d (0 = forward, 1 = backward):
  act_f, act_g = activations[2d .. 2d+1]          (activations[0..1] if only 2)
  Wz, Wr, Wh = W[d] split into 3 row blocks;  Rz, Rr, Rh = R[d] likewise
  Wbz, Wbr, Wbh, Rbz, Rbr, Rbh = B[d] split into 6   (zero if no B)
  h = in[h][:, 0, d, :]                              (zero if absent)
  for t = 0 .. T-1 (forward) or t = T-1 .. 0 (backward):
    x = in[0][:, 0, t, :]
    z = act_f(x @ Wz^T + h @ Rz^T + Wbz + Rbz)
    r = act_f(x @ Wr^T + h @ Rr^T + Wbr + Rbr)
    n = act_g(x @ Wh^T + Wbh + (r * h) @ Rh^T + Rbh)   if not linear_before_reset
        act_g(x @ Wh^T + Wbh + r * (h @ Rh^T + Rbh))   if linear_before_reset
    h = (1 - z) * n + z * h
    out[0][:, d, t, :] = h
  out[1][:, 0, d, :] = h
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, 1, T, input_size]` | 입력 활성화 텐서. |
| `in[s]` | `any` | 입력 활성화 텐서. |
| `in[h]` | `[1, 1, num_directions, hidden_size]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `W` | `Weight` | 필수 | 입력 weight, `[num_directions, 3*hidden_size, input_size]`. gate 블록 순서는 z(update), r(reset), h(candidate)입니다. |
| `R` | `Weight` | 필수 | recurrent weight, `[num_directions, 3*hidden_size, hidden_size]`. gate 순서는 z, r, h입니다. |
| `B` | `Weight` | 선택 | bias, `[num_directions, 6*hidden_size]`. 입력 bias(z, r, h) 다음에 recurrent bias(z, r, h)가 옵니다. 없으면 0입니다. |
| `input_mask` | `str` | 필수 | 있는 피연산자를 순서대로 나타내는 문자열. `i` 입력 시퀀스(항상 처음), `s` 시퀀스 길이, `h` 초기 hidden state입니다. 예를 들어 `ih`이면 in\[0\]이 시퀀스, in\[1\]이 hidden state입니다. |
| `output_mask` | `str` | 필수 | `o`, `h` 중 실제로 쓰이는 결과(out\[0\], out\[1\])를 나타내는 문자열. 두 결과의 위치는 바뀌지 않습니다. |
| `direction` | `str` | `"forward"` | `forward`, `backward`(`reverse`도 같음), `bidirectional` 중 하나. `bidirectional`은 두 방향을 모두 계산해 방향 축에 forward(index 0), backward(index 1)로 쌓으므로 `num_directions`가 2이고, 나머지는 1입니다. |
| `batch_first` | `bool` | `false` | 여기 표기한 shape인 batch 우선 배치이면 `true`. `false`는 시간 우선 배치로, in\[0\]이 `[T, 1, input_size]`, state가 `[num_directions, 1, hidden_size]`, out\[0\]이 `[T, num_directions, 1, hidden_size]`입니다. |
| `hidden_size` | `int32` | 필수 | 방향별 hidden unit 수. |
| `hidden_state_name` | `str` | 필수 | out\[1\]과 cell `subgraph`의 state 출력의 이름. |
| `subgraph` | `str` | 필수 | step 입력과 이전 hidden state로 한 time step을 계산하는 cell subgraph의 이름. |
| `activation_alpha` | `float32[]` | 선택 | `activations`의 함수에 쓰는 alpha 계수. 순서가 같습니다. `sigmoid`와 `tanh`는 계수를 쓰지 않습니다. |
| `activation_beta` | `float32[]` | 선택 | `activations`의 함수에 쓰는 beta 계수. 순서가 같습니다. `sigmoid`와 `tanh`는 계수를 쓰지 않습니다. |
| `activations` | `str[]` | 선택 | gate 함수 `[act_f, act_g]`. 보통 `[sigmoid, tanh]`입니다. `bidirectional`에서 4개를 주면 forward, backward 순서이고, 2개를 주면 두 방향에 같이 씁니다. 기준 구현은 `sigmoid`와 `tanh`를 정의합니다. |
| `clip` | `float32` | 선택 | cell clip 임계값. 값이 있으면 gate 입력을 활성화 전에 `[-clip, clip]`로 제한하며, 없으면 제한하지 않습니다. |
| `linear_before_reset` | `bool` | `false` | `false`이면 recurrent 곱 전에 이전 state에 reset gate를 곱하고, `true`이면 곱한 결과 `h @ Rh^T + Rbh`에 reset gate를 곱합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, num_directions, T, hidden_size]` | 출력 활성화 텐서. |
| `out[1]` | `[1, 1, num_directions, hidden_size]` | 출력 활성화 텐서. |

### StatefulKVCacheWrapper

새 key 또는 value state를 유지되는 cache에 추가하고 cache를 반환합니다.

한 layer의 key 또는 value cache를 호출 사이에 유지합니다. 매 호출마다 in\[0\]의 새 state `S`개를 해당 token의 절대 위치에 기록하고, 현재 attention이 볼 수 있는 모든 state를 위치 순서로 반환합니다. cache와 token 위치는 실행 시 상태이며 IR 피연산자가 아닙니다.

```text
pos = absolute positions of the S new tokens (from the runtime), p0 = pos[0]
the cache holds the states of earlier calls by position; in[0] is stored at pos
is_sliding = false:
  out[0] = states of positions 0 .. pos[S-1], concatenated on axis 2
is_sliding = true:
  out[0] = states of positions max(0, p0 - (sliding_window - 1)) .. pos[S-1]
  only the last sliding_window positions stay stored for later calls
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, heads, S, D]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `cache_name` | `str` | 필수 | 이 연산이 읽고 쓰는 cache 상태의 이름. |
| `past_seqlen` | `int32` | `0` | graph를 trace할 때 cache에 이미 있던 token 수. 정적 출력 길이는 `S + past_seqlen`이며 0이 아니면 dynamic 크기가 됩니다. 실행 시 길이는 token 위치를 따릅니다. `is_sliding`이면 `sliding_window - 1` 이하입니다. |
| `is_sliding` | `bool` | `false` | `true`이면 가장 최근 `sliding_window`개 위치만 유지합니다(sliding-window attention). |
| `sliding_window` | `int32` | `1024` | `is_sliding`일 때 token 단위 window 길이. 양수이며 `max_cache_len` 이하입니다. |
| `max_cache_len` | `int32` | `8192` | token 단위 cache 용량. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | \[1, heads, P + S, D\]. P는 보이는 과거 token 수(p0, sliding이면 min(p0, sliding\_window - 1)) | 출력 활성화 텐서. |

### StatefulLSTMWrapper

시퀀스에 LSTM을 적용해 단계별 출력과 최종 hidden/cell state를 반환합니다.

in\[0\]의 시간 축을 따라 상수 weight `W`, `R`, `B`와 선택적 peephole `P`로 LSTM recurrence를 한 방향 또는 양방향으로 계산합니다. 어떤 피연산자가 있는지는 `input_mask`로 나타내며, 결과는 항상 `out[0]` (모든 step의 hidden state), `out[1]` (최종 hidden state), `out[2]` (최종 cell state)입니다.

```text
batch_first = true; T = steps; @ = matrix product, * = element-wise product
for each direction d (0 = forward, 1 = backward):
  act_f, act_g, act_h = activations[3d .. 3d+2]   (activations[0..2] if only 3)
  Wi, Wo, Wf, Wc = W[d] split into 4 row blocks;  Ri, Ro, Rf, Rc = R[d] likewise
  Wbi, Wbo, Wbf, Wbc, Rbi, Rbo, Rbf, Rbc = B[d] split into 8   (zero if no B)
  Pi, Po, Pf = P[d] split into 3                                (zero if no P)
  h = in[h][:, 0, d, :],  c = in[c][:, 0, d, :]                 (zero if absent)
  for t = 0 .. T-1 (forward) or t = T-1 .. 0 (backward):
    x = in[0][:, 0, t, :]
    i = act_f(x @ Wi^T + h @ Ri^T + Wbi + Rbi + Pi * c)
    f = act_f(x @ Wf^T + h @ Rf^T + Wbf + Rbf + Pf * c)
    g = act_g(x @ Wc^T + h @ Rc^T + Wbc + Rbc)
    c = f * c + i * g
    o = act_f(x @ Wo^T + h @ Ro^T + Wbo + Rbo + Po * c)
    h = o * act_h(c)
    out[0][:, d, t, :] = h
  out[1][:, 0, d, :] = h
  out[2][:, 0, d, :] = c
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, 1, T, input_size]` | 입력 활성화 텐서. |
| `in[s]` | `any` | 입력 활성화 텐서. |
| `in[h]` | `[1, 1, num_directions, hidden_size]` | 입력 활성화 텐서. |
| `in[c]` | `[1, 1, num_directions, hidden_size]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `W` | `Weight` | 필수 | 입력 weight, `[num_directions, 4*hidden_size, input_size]`. gate 블록 순서는 i, o, f, c입니다. |
| `R` | `Weight` | 필수 | recurrent weight, `[num_directions, 4*hidden_size, hidden_size]`. gate 순서는 i, o, f, c입니다. |
| `B` | `Weight` | 선택 | bias, `[num_directions, 8*hidden_size]`. 입력 bias(i, o, f, c) 다음에 recurrent bias(i, o, f, c)가 옵니다. 없으면 0입니다. |
| `input_mask` | `str` | 필수 | 있는 피연산자를 순서대로 나타내는 문자열. `i` 입력 시퀀스(항상 처음), `s` 시퀀스 길이, `h` 초기 hidden state, `c` 초기 cell state입니다. 예를 들어 `ihc`이면 in\[0..2\]가 시퀀스, hidden state, cell state입니다. |
| `output_mask` | `str` | 필수 | `o`, `h`, `c` 중 실제로 쓰이는 결과(out\[0\], out\[1\], out\[2\])를 나타내는 문자열. 세 결과의 위치는 바뀌지 않습니다. |
| `P` | `Weight` | 선택 | peephole weight, `[num_directions, 3*hidden_size]`. 순서는 i, o, f입니다. 없으면 peephole을 쓰지 않습니다. |
| `direction` | `str` | `"forward"` | `forward`, `backward`(`reverse`도 같음), `bidirectional` 중 하나. `bidirectional`은 두 방향을 모두 계산해 방향 축에 forward(index 0), backward(index 1)로 쌓으므로 `num_directions`가 2이고, 나머지는 1입니다. |
| `batch_first` | `bool` | `false` | 여기 표기한 shape인 batch 우선 배치이면 `true`. `false`는 시간 우선 배치로, in\[0\]이 `[T, 1, input_size]`, state가 `[num_directions, 1, hidden_size]`, out\[0\]이 `[T, num_directions, 1, hidden_size]`입니다. |
| `hidden_size` | `int32` | 필수 | 방향별 hidden unit 수. |
| `hidden_state_name` | `str` | 필수 | out\[1\]과 cell `subgraph`의 hidden state 출력의 이름. |
| `cell_state_name` | `str` | 필수 | out\[2\]와 cell `subgraph`의 cell state 출력의 이름. |
| `subgraph` | `str` | 필수 | step 입력과 이전 hidden/cell state로 한 time step을 계산하는 cell subgraph의 이름. |
| `activation_alpha` | `float32[]` | 선택 | `activations`의 함수에 쓰는 alpha 계수. 순서가 같습니다. `sigmoid`와 `tanh`는 계수를 쓰지 않습니다. |
| `activation_beta` | `float32[]` | 선택 | `activations`의 함수에 쓰는 beta 계수. 순서가 같습니다. `sigmoid`와 `tanh`는 계수를 쓰지 않습니다. |
| `activations` | `str[]` | 선택 | gate 함수 `[act_f, act_g, act_h]`. 보통 `[sigmoid, tanh, tanh]`입니다. `bidirectional`에서 6개를 주면 forward, backward 순서이고, 3개를 주면 두 방향에 같이 씁니다. 기준 구현은 `sigmoid`와 `tanh`를 정의합니다. |
| `clip` | `float32` | 선택 | cell clip 임계값. 값이 있으면 gate 입력을 활성화 전에 `[-clip, clip]`로 제한하며, 없으면 제한하지 않습니다. |
| `input_forget` | `bool` | `false` | `true`이면 input gate와 forget gate를 결합합니다. 위 수식은 `false`인 경우입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, num_directions, T, hidden_size]` | 출력 활성화 텐서. |
| `out[1]` | `[1, 1, num_directions, hidden_size]` | 출력 활성화 텐서. |
| `out[2]` | `[1, 1, num_directions, hidden_size]` | 출력 활성화 텐서. |

### StatefulRNNWrapper

시퀀스에 단순 RNN을 적용해 단계별 출력과 최종 state를 반환합니다.

in\[0\]의 시간 축을 따라 상수 weight `W`, `R`, `B`로 recurrence `h = act_f(x W^T + h R^T + b)`를 한 방향 또는 양방향으로 계산합니다. 어떤 피연산자가 있는지는 `input_mask`로 나타내며, 결과는 항상 `out[0]` (모든 step의 hidden state)과 `out[1]` (최종 hidden state)입니다.

```text
batch_first = true; T = steps; @ = matrix product
for each direction d (0 = forward, 1 = backward):
  act_f = activations[d]            (activations[0] if only 1)
  Wb, Rb = B[d] split into 2        (zero if no B)
  h = in[h][:, 0, d, :]             (zero if absent)
  for t = 0 .. T-1 (forward) or t = T-1 .. 0 (backward):
    x = in[0][:, 0, t, :]
    h = act_f(x @ W[d]^T + h @ R[d]^T + Wb + Rb)
    out[0][:, d, t, :] = h
  out[1][:, 0, d, :] = h
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, 1, T, input_size]` | 입력 활성화 텐서. |
| `in[s]` | `any` | 입력 활성화 텐서. |
| `in[h]` | `[1, 1, num_directions, hidden_size]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `W` | `Weight` | 필수 | 입력 weight, `[num_directions, hidden_size, input_size]`. |
| `R` | `Weight` | 필수 | recurrent weight, `[num_directions, hidden_size, hidden_size]`. |
| `B` | `Weight` | 선택 | bias, `[num_directions, 2*hidden_size]`. 입력 bias 다음에 recurrent bias가 옵니다. 없으면 0입니다. |
| `input_mask` | `str` | 필수 | 있는 피연산자를 순서대로 나타내는 문자열. `i` 입력 시퀀스(항상 처음), `s` 시퀀스 길이, `h` 초기 hidden state입니다. 예를 들어 `ih`이면 in\[0\]이 시퀀스, in\[1\]이 hidden state입니다. |
| `output_mask` | `str` | 필수 | `o`, `h` 중 실제로 쓰이는 결과(out\[0\], out\[1\])를 나타내는 문자열. 두 결과의 위치는 바뀌지 않습니다. |
| `direction` | `str` | `"forward"` | `forward`, `backward`(`reverse`도 같음), `bidirectional` 중 하나. `bidirectional`은 두 방향을 모두 계산해 방향 축에 forward(index 0), backward(index 1)로 쌓으므로 `num_directions`가 2이고, 나머지는 1입니다. |
| `batch_first` | `bool` | `false` | 여기 표기한 shape인 batch 우선 배치이면 `true`. `false`는 시간 우선 배치로, in\[0\]이 `[T, 1, input_size]`, state가 `[num_directions, 1, hidden_size]`, out\[0\]이 `[T, num_directions, 1, hidden_size]`입니다. |
| `hidden_size` | `int32` | 필수 | 방향별 hidden unit 수. |
| `hidden_state_name` | `str` | 필수 | out\[1\]과 cell `subgraph`의 state 출력의 이름. |
| `subgraph` | `str` | 필수 | step 입력과 이전 hidden state로 한 time step을 계산하는 cell subgraph의 이름. |
| `activation_alpha` | `float32[]` | 선택 | `activations`의 함수에 쓰는 alpha 계수. 순서가 같습니다. `sigmoid`와 `tanh`는 계수를 쓰지 않습니다. |
| `activation_beta` | `float32[]` | 선택 | `activations`의 함수에 쓰는 beta 계수. 순서가 같습니다. `sigmoid`와 `tanh`는 계수를 쓰지 않습니다. |
| `activations` | `str[]` | 선택 | recurrence 함수 `[act_f]`. 보통 `[tanh]`입니다. `bidirectional`에서 2개를 주면 forward, backward 순서이고, 1개를 주면 두 방향에 같이 씁니다. 기준 구현은 `sigmoid`와 `tanh`를 정의합니다. |
| `clip` | `float32` | 선택 | cell clip 임계값. 값이 있으면 활성화 함수의 입력을 `[-clip, clip]`로 제한하며, 없으면 제한하지 않습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, num_directions, T, hidden_size]` | 출력 활성화 텐서. |
| `out[1]` | `[1, 1, num_directions, hidden_size]` | 출력 활성화 텐서. |

### StatefulRoPEWrapper

query 또는 key에 해당 위치의 rotary position embedding을 적용합니다.

위치에 따른 각도로 query 또는 key tensor의 채널 쌍을 회전합니다. 행 `p`가 위치 `p`에 해당하는 미리 계산된 cos/sin 표를 쓰며, 현재 호출 token의 절대 위치로 행을 고릅니다.

```text
x = in[0];  c, s = rows of in[1], in[2] for the S current positions
rot0(y) = concat(-y[..., h:], y[..., :h]),   h = width(y) / 2
rot1(y)[..., 2i] = -y[..., 2i+1],  rot1(y)[..., 2i+1] = y[..., 2i]
rope_type 0:  R = rotary_emb_dim if > 0, else width(c)
              y = x[..., :R]
              out[0] = concat(y * c[..., :R] + rot0(y) * s[..., :R], x[..., R:])
rope_type 1:  out[0] = x * c + rot1(x) * s
rope_type 2:  rope_type 0 with R = width(c)
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, heads, S, D]` | 입력 활성화 텐서. |
| `in[1]` | `[1, 1, L, R]` | 입력 활성화 텐서. |
| `in[2]` | `[1, 1, L, R]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `rope_type` | `int32` | `0` | 채널 짝 방식. `0`은 채널 `i`와 `i + R/2`를 짝짓고(rotary 채널을 반으로 나눔), `1`은 인접한 채널 `2i`, `2i+1`을 짝짓습니다. `2`는 rotary 폭을 cos 표에서 가져오는 `0`입니다. |
| `seqlen` | `int32` | `0` | graph를 만들 때 in\[0\]의 sequence 길이 `S`. 참고용이며 계산에는 실행 시 shape을 씁니다. |
| `rotary_emb_dim` | `int32` | `0` | `D` 중 회전하는 앞쪽 채널 수(partial rotary). 나머지는 그대로 통과합니다. `0`이면 cos 표의 폭을 씁니다. `rope_type=0`에서만 씁니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Sub

두 활성화 텐서의 원소별 차.

in\[0\]에서 in\[1\]을 원소별로 뺍니다.

```text
out[0] = in[0] - in[1]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |
| `in[1]` | in\[0\]과 broadcast 가능 | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], in[1])` | 출력 활성화 텐서. |

### SubConstant

활성화 텐서에서 상수를 빼거나 상수에서 활성화 텐서를 뺍니다.

피연산자 하나를 모델에 저장된 상수로 하여 뺄셈을 합니다. 상수는 scalar, 채널별 벡터, 전체 텐서 중 어느 것이든 될 수 있습니다. `is_const_first`가 `true`이면 `constant - in[0]`, `false`이면 `in[0] - constant`를 계산합니다.

```text
out[0] = constant - in[0]   if is_const_first
         in[0] - constant   otherwise
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `constant` | `Weight` | 필수 | 상수 피연산자. in\[0\]에 맞춰 broadcast합니다. |
| `is_const_first` | `bool` | 필수 | 상수가 피감수(왼쪽 피연산자)이면 `true`, 빼는 값이면 `false`. |
| `shape` | `int32[]` | `[]` | 저장된 `constant`를 (예를 들어 채널별 벡터로) 축약하기 전, 상수 피연산자의 shape. 출력 shape은 broadcast(shape(in\[0\]), shape)입니다. 기본값 `[]`은 텐서의 shape을 따로 적지 않은 경우이며 필수는 아닙니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], shape)` | 출력 활성화 텐서. |

### Swish

self-gated 활성화 텐서 `x * sigmoid(x)`.

```text
out[0] = in[0] * sigmoid(in[0]) = in[0] / (1 + exp(-in[0]))
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Tan

원소별 tangent.

```text
out[0] = tan(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### Tanh

원소별 hyperbolic tangent.

```text
out[0] = tanh(in[0])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

없음.

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | in\[0\]과 같음 | 출력 활성화 텐서. |

### TensorCmp

두 활성화 텐서를 원소별로 비교해 boolean 텐서를 만듭니다.

in\[0\]과 in\[1\]을 broadcast한 뒤 `kind`가 가리키는 관계로 원소별 비교합니다. 출력은 boolean이며 관계가 성립하는 위치가 true입니다.

```text
kind = "eq":   out[0] = (in[0] == in[1])
kind = "neq":  out[0] = (in[0] != in[1])
kind = "lt":   out[0] = (in[0] <  in[1])
kind = "leq":  out[0] = (in[0] <= in[1])
kind = "gt":   out[0] = (in[0] >  in[1])
kind = "geq":  out[0] = (in[0] >= in[1])
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |
| `in[1]` | in\[0\]과 broadcast 가능 | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `kind` | `str` | `"eq"` | 비교 관계. `eq`, `neq`, `lt`, `leq`, `gt`, `geq` 중 하나이며 `in[0] <kind> in[1]`로 읽습니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `broadcast(in[0], in[1])` | 출력 활성화 텐서. |

### Transpose

활성화 텐서의 축 순서를 바꿉니다.

out\[0\]의 i번째 축이 in\[0\]의 `transpose_axes[i]`번째 축이 되도록 축 순서를 바꿉니다.

```text
P = transpose_axes
out[0].shape[i] = in[0].shape[P[i]]
out[0][i_0, ..., i_{r-1}] = in[0][j]   where j[P[k]] = i_k
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, C]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `transpose_axes` | `int64[]` | 필수 | `0..rank-1`의 순열. i번째 항목은 출력의 i번째 축이 될 입력 축 번호입니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[in[0].shape[transpose_axes[i]] for each i]` | 출력 활성화 텐서. |

### TransposeConvolution

zero 삽입과 convolution으로 표현한 transposed 2-D convolution.

in\[0\]의 이웃 픽셀 사이에 0인 행 `h_stride - 1`개와 0인 열 `w_stride - 1`개를 끼워 넣어 upsample하고, 그 텐서를 `*_padding` 속성만큼 zero padding한 뒤 `weight`로 stride 1, 주어진 dilation의 convolution을 하고 `bias`를 더합니다. 따라서 weight는 transposed convolution kernel을 H, W 방향으로 뒤집어 convolution 배치 `[out_channels, in_channels / group_number, h_kernel, w_kernel]`로 저장하며, padding은 출력에서 잘라 내는 양이 아니라 zero 삽입한 텐서에 붙이는 양입니다.

```text
G  = group_number,  Cg = in_channels / G,  Og = out_channels / G   (// : integer division)
z  = zeros([1, (H-1)*h_stride + 1, (W-1)*w_stride + 1, in_channels])
z[n, i*h_stride, j*w_stride, c] = in[0][n, i, j, c]
zp = zero_pad(z, top=north_padding, bottom=south_padding,
                 left=west_padding, right=east_padding)
out[0][n, y, x, o] = bias[o] + sum_{ky, kx, c < Cg}
    weight[o, c, ky, kx]
    * zp[n, y + ky*h_dilation, x + kx*w_dilation, (o // Og)*Cg + c]
```

#### 입력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `in[0]` | `[1, H, W, in_channels]` | 입력 활성화 텐서. |

#### 속성

| 이름 | 타입 | 기본값 | 설명 |
| :--- | :--- | :--- | :--- |
| `in_channels` | `int32` | 필수 | 입력 채널 수. |
| `out_channels` | `int32` | 필수 | 출력 채널 수. |
| `h_kernel` | `int32` | 필수 | kernel 높이. |
| `w_kernel` | `int32` | 필수 | kernel 너비. |
| `h_stride` | `int32` | 필수 | H 방향 upsampling stride. 입력 행 사이에 0인 행 `h_stride - 1`개를 넣습니다. |
| `w_stride` | `int32` | 필수 | W 방향 upsampling stride. 입력 열 사이에 0인 열 `w_stride - 1`개를 넣습니다. |
| `h_dilation` | `int32` | 필수 | H 방향 dilation. |
| `w_dilation` | `int32` | 필수 | W 방향 dilation. |
| `west_padding` | `int32` | 필수 | zero 삽입한 텐서의 W 시작(왼쪽) zero padding. |
| `east_padding` | `int32` | 필수 | zero 삽입한 텐서의 W 끝(오른쪽) zero padding. |
| `north_padding` | `int32` | 필수 | zero 삽입한 텐서의 H 시작(위쪽) zero padding. |
| `south_padding` | `int32` | 필수 | zero 삽입한 텐서의 H 끝(아래쪽) zero padding. |
| `padding_list` | `int32[]` | `[]` | 원래 transposed convolution padding `[top, left, bottom, right]`(출력에서 덜어 내는 양). 참고용이며 계산에는 네 `*_padding` 속성을 씁니다. |
| `og_padding_list` | `int32[]` | `[]` | 원래 transposed convolution padding을 담는 자리. 참고용으로 계산에 쓰지 않으며 보통 비어 있습니다. |
| `og_out_padding_list` | `int32[]` | `[]` | 원래 transposed convolution의 output padding(출력 끝에 더하는 행과 열)을 담는 자리. 참고용으로 계산에 쓰지 않으며 보통 비어 있습니다. |
| `group_number` | `int32` | 필수 | 채널 그룹 수. `in_channels`와 `out_channels`를 모두 나누어떨어지게 합니다. |
| `weight` | `Weight` | 필수 | convolution 배치의 필터 `[out_channels, in_channels / group_number, h_kernel, w_kernel]`. transposed convolution kernel을 H, W 방향으로 뒤집은 값입니다. |
| `bias` | `Weight` | 선택 | bias, `[out_channels]`. 없으면 0. |
| `channel_last` | `bool` | `true` | NPU에서는 NHWC 포맷을 사용하기 때문에 `true`여야 합니다. |

#### 출력

| 이름 | 형상 | 설명 |
| :--- | :--- | :--- |
| `out[0]` | `[1, H_out, W_out, out_channels]` | 출력 활성화 텐서. |

## 그 밖의 Mobilint IR 연산

아래 표는 앞에서 설명하지 않은 연산의 입력·속성 정보를 제공합니다. 표에 있다는 사실만으로 NPU 또는 CPU 오프로딩 지원이 보장되지는 않습니다.

| 연산 | 비고 |
| :--- | :--- |
| Abs | num inputs: 1<br>num outputs: 1 |
| AddPartial | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- is\_input0\_larger: bool |
| Cast | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- dtype: str |
| Ceil | num inputs: 1<br>num outputs: 1 |
| Convolution3d | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- in\_channels: int32<br>\- out\_channels: int32<br>\- h\_kernel: int32<br>\- w\_kernel: int32<br>\- d\_kernel: int32<br>\- h\_stride: int32<br>\- w\_stride: int32<br>\- d\_stride: int32<br>\- h\_dilation: int32<br>\- w\_dilation: int32<br>\- d\_dilation: int32<br>\- west\_padding: int32<br>\- east\_padding: int32<br>\- north\_padding: int32<br>\- south\_padding: int32<br>\- front\_padding: int32<br>\- back\_padding: int32<br>\- padding\_list: int32\[\] (default=\[\])<br>\- group\_number: int32<br>\- weight: Weight<br>\- bias: Weight (optional)<br>\- channel\_last: bool (default=true) |
| Crop | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- w\_offset: int32 (default=0)<br>\- h\_offset: int32 (default=0)<br>\- crop\_width: int32<br>\- crop\_height: int32 |
| DeviceBridge | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- squeeze\_axes: int32\[\]<br>\- unsqueeze\_axes: int32\[\]<br>\- permute\_axes: int64\[\]<br>\- device: str (optional) |
| Expand | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- constant: Weight (optional)<br>\- is\_const\_first: bool |
| GLU | num inputs: 1<br>num outputs: 1 |
| GridSample | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- align\_corners: int32 (default=0)<br>\- mode: str (default="linear")<br>\- padding\_mode: str (default="zeros")<br><br>description:<br>inputs: X, grid<br>X is in channel-last format.<br>X: (n, h, w, c)<br>grid: (n, h\_out, w\_out, num\_spatial\_dims). in this case, num\_spatial\_dims=2. |
| Hardtanh | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- min\_val: float32 (default=-1.0)<br>\- max\_val: float32 (default=1.0) |
| Hardshrink | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- lambd: float32 (default=0.5) |
| Softshrink | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- lambd: float32 (default=0.5) |
| Identity | num inputs: 1<br>num outputs: 1 |
| SumNormalization | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- norm\_axis: int32\[\]<br>\- epsilon: float32 (optional) |
| LSTM | num inputs: variable<br>num outputs: 1<br>attributes:<br>\- W: Weight<br>\- R: Weight<br>\- B: Weight (optional)<br>\- lstm\_group: str<br>\- input\_mask: str<br>\- output\_mask: str<br>\- P: Weight (optional)<br>\- direction: str (default="forward")<br>\- batch\_first: bool (default=false)<br>\- hidden\_size: int32<br><br>description:<br>inputs:\[input, sequence\_lens, initial\_h, initial\_c\]<br>outputs:\[output\] or \[hidden\_out\] or \[cell\_out\]<br>input\_mask: "ishc" or "i", etc,...<br>output\_mask: "o" or "h" or "c" |
| Logit | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- eps: float32 (optional)<br><br>description:<br>Compute y = ln(z / (1 - z)). If eps is given, we clamp input z = clamp(z, min=eps, max=1-eps) |
| RNN | num inputs: variable<br>num outputs: 1<br>attributes:<br>\- W: Weight<br>\- R: Weight<br>\- B: Weight (optional)<br>\- rnn\_group: str<br>\- input\_mask: str<br>\- output\_mask: str<br>\- direction: str (default="forward")<br>\- batch\_first: bool (default=false)<br>\- hidden\_size: int32<br><br>description:<br>inputs:\[input, sequence\_lens, initial\_h\]<br>outputs:\[output\] or \[hidden\_out\]<br>input\_mask: "ish" or "i", etc,...<br>output\_mask: "o" or "h" |
| GRU | num inputs: variable<br>num outputs: 1<br>attributes:<br>\- W: Weight<br>\- R: Weight<br>\- B: Weight (optional)<br>\- gru\_group: str<br>\- input\_mask: str<br>\- output\_mask: str<br>\- direction: str (default="forward")<br>\- batch\_first: bool (default=false)<br>\- linear\_before\_reset: bool (default=false)<br>\- hidden\_size: int32<br><br>description:<br>inputs:\[input, sequence\_lens, initial\_h\]<br>outputs:\[output\] or \[hidden\_out\]<br>input\_mask: "ish" or "i", etc,...<br>output\_mask: "o" or "h" |
| LogSigmoid | num inputs: 1<br>num outputs: 1 |
| MaskSoftmax | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- beta: float32<br>\- axis: int32 |
| NonMaxSuppression | num inputs: 2<br>num outputs: variable<br>attributes:<br>\- max\_output\_size: int64<br>\- iou\_threshold: float32<br>\- score\_threshold: float32<br>\- soft\_nms\_sigma: float32<br>\- pad\_to\_max\_output\_size: bool<br>\- center\_point\_box: int32 (default=0) |
| GlobalAveragePooling | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- channel\_last: bool (default=true) |
| GlobalResponseNormalization | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- scale: Weight<br>\- bias: Weight<br>\- epsilon: float32<br>\- channel\_last: bool (default=true) |
| ReduceL2 | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- keep\_dims: bool<br>\- reduce\_axes: int32\[\]<br>\- noop\_with\_empty\_axes: int32 |
| ReduceProd | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- keep\_dims: bool<br>\- reduce\_axes: int32\[\]<br>\- noop\_with\_empty\_axes: int32 |
| ReduceRMS | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- keep\_dims: bool<br>\- reduce\_axes: int32\[\]<br>\- epsilon: float32 (optional)<br><br>description:<br>reduce rms with epsilon if exists. i.e.,sqrt(mean\*\*2 + eps)<br>we let eps to be optional so that it has more general fusing opportunities. |
| MeanCentering | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- axes: int32\[\]<br><br>description:<br>compute x - mean(x, axes) |
| ReshapeV2 | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- allowzero: int32 (default=0)<br>\- is\_const\_first: bool (default=false)<br><br>description:<br>Reshape with variable shape argument. inputs\[1\] will be used as a shape. |
| RotaryEmbedding | num inputs: 1<br>num outputs: 2<br>attributes:<br>\- inv\_freq: Weight<br>\- attention\_scaling: float32<br><br>description:<br>following the LlamaRotaryEmbedding of the Huggingface Transformer library.<br>inputs =\> (position\_ids,), outputs =\> (cos, sin) |
| Rsqrt | num inputs: 1<br>num outputs: 1 |
| Rstd | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- reduce\_axes: int32\[\]<br>\- epsilon: Weight<br>\- num\_groups: int32 (default=1)<br><br>description:<br>computes 1/std(x). if gruops \> 1, then activation is grouped along channel axis. |
| Gather | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- axis: int32 (default=0) |
| GatherElements | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- axis: int32 (default=0) |
| ScatterND | num inputs: variable<br>num outputs: 1<br>attributes:<br>\- constant\_data: Weight (optional)<br>\- constant\_indices: Weight (optional) |
| Selu | num inputs: 1<br>num outputs: 1 |
| Shape | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- start: int32 (optional)<br>\- end: int32 (optional) |
| LogSoftmax | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- axis: int32 |
| Softsign | num inputs: 1<br>num outputs: 1 |
| Unsqueeze | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- axes: int32\[\] |
| DynamicSliceInputConst | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- mod: int32<br>\- start: int64\[\]<br>\- end: int64\[\]<br>\- axis: int64\[\]<br>\- step: int64\[\] (optional) |
| MeloTTSPiecewiseRationalQuadraticTransform | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- num\_bins: int32<br>\- filter\_channels: int32<br>\- tail\_bound: float32<br>\- reverse: bool<br><br>description:<br>helper function for parsing melotts model. |
| Neg | num inputs: 1<br>num outputs: 1 |
| Einsum | num inputs: variable<br>num outputs: 1<br>attributes:<br>\- equation: str<br>\- constant: Weight (optional)<br>\- is\_const\_first: bool (default=false) |
| Where | num inputs: 3<br>num outputs: 1<br><br><br>description:<br>condition,X,Y, if cond == True: else y |
| Logical | num inputs: variable<br>num outputs: 1<br>attributes:<br>\- kind: str (default="and")<br><br>description:<br>this function represents the logical operation of two inputs.<br>single input if kind is "not" else two inputs<br>kind: and, or, xor, not |
| MaskedFill | num inputs: 2<br>num outputs: 1<br>attributes:<br>\- value: float32<br><br>description:<br>inputs: (x, mask) |
| SubgraphCall | num inputs: variable<br>num outputs: variable<br>attributes:<br>\- subgraph: str<br>\- scope: str<br>\- kind: str |
| MoeDispatcher | num inputs: 2<br>num outputs: 2<br>attributes:<br>\- top\_k: int32<br>\- norm\_top\_k\_prob: bool (default=true)<br><br>description:<br>inputs: (hidden\_states, router\_logits)<br>outputs: (hidden\_states, top\_k\_logits)<br>if norm\_top\_k\_prob is true<br>topk\_vals, topk\_idx = torch.topk(<br>routing\_weights, self.top\_k, dim=-1<br>) \# (18,8), (18,8)<br>weight\_new = torch.zeros\_like(routing\_weights)<br>weight\_new.scatter\_(1, topk\_idx, topk\_vals)<br>routing\_weights = weight\_new<br>routing\_weights /= routing\_weights.sum(dim=1, keepdim=True) |
| MoeAggregator | num inputs: variable<br>num outputs: 1<br><br><br>description:<br>inputs: (router\_weights, experts\_output0, expert\_output1, ...) |
| TopKValues | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- axis: int32<br>\- k: int32 (default=1)<br>\- largest: bool (default=true)<br>\- sorted: bool (default=true) |
| TopKIndices | num inputs: 1<br>num outputs: 1<br>attributes:<br>\- axis: int32<br>\- k: int32 (default=1)<br>\- largest: bool (default=true)<br>\- sorted: bool (default=true) |
