# blocks

Python API: `luxonis_train.nodes.backbones.pplcnet_v3.blocks`

PPLCNetV3 主干网络的块。

## 类

### AffineActivation

`Hardswish` 后跟一个可学习的仿射映射。

输出是 `scale * hardswish(x) + bias`。一个
[AffineBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)
包含 `scale` 和 `bias`。它们从 `1.0` 和 `0.0` 开始，因此该模块最初是一个普通的 `torch.nn.Hardswish`。

> **示例**
> ```pycon
>>> import torch
>>> act = AffineActivation()
>>> act(torch.tensor([-4.0, 0.0, 4.0])).tolist()
[0.0, 0.0, 4.0]
```

#### 方法

##### init

```python
def __init__(self):
```

##### forward

```python
def forward(x: Tensor) -> Tensor:
```

应用 `Hardswish`，然后是仿射映射。

参数

 * `x` (`Tensor`): 任意形状的张量。

返回

 * `Tensor`: `scale * hardswish(x) + bias`，与 `x` 形状相同。

#### 属性

##### activation

##### affine

### AffineBlock

可学习的仿射映射 `scale * x + bias`，带标量参数。

`scale` 和 `bias` 是形状为 `[1]` 的 `torch.nn.Parameter` 对象。相同的两个值适用于输入的所有元素。

> **示例**
> ```pycon
>>> import torch
>>> block = AffineBlock(scale_value=2.0, bias_value=1.0)
>>> block(torch.tensor([1.0, 2.0])).tolist()
[3.0, 5.0]
```

#### 方法

##### init

```python
def __init__(scale_value: float = 1.0, bias_value: float = 0.0):
```

初始化比例和偏差参数。

参数

 * `scale_value` (`float`): `scale` 的初始值。提供 `float` 类型。`int` 类型可以通过类型检查，但它会生成一个整数张量。然后构造函数会引发 `RuntimeError`。
 * `bias_value` (`float`): `bias` 的初始值。规则相同。

##### forward

```python
def forward(x: Tensor) -> Tensor:
```

应用仿射映射。

参数

 * `x` (`Tensor`): 任意形状的张量。

返回

 * `Tensor`: `scale * x + bias`，与 `x` 形状相同。

#### 属性

##### bias

##### scale

### LCNetV3Block

PPLCNetV3 的深度可分离块。

该块按顺序运行以下层：

 * 一个 k×k 深度可分离
   [GeneralReparameterizableBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/blocks/blocks.md)。它有
   `n_branches` 个密集分支，一个 1×1 比例分支，当 `stride` 为 `1` 时还有一个恒等分支。
 * 一个可选的
   [SqueezeExciteBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/blocks/blocks.md)，带有
   `in_channels // 4` 个隐藏通道，一个 `ReLU` 和一个硬 sigmoid 门。
 * 一个 1×1 点式
   [GeneralReparameterizableBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/blocks/blocks.md)。它有
   `n_branches` 个密集分支，没有比例分支，当 `in_channels` 等于 `out_channels` 时还有一个恒等分支。

这两个卷积中的每一个都将一个
[AffineBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)
应用于其分支的总和，然后是一个
[AffineActivation](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)。当
`stride` 为 `2` 时，深度卷积没有激活。

> **示例**
> ```pycon
>>> import torch
>>> block = LCNetV3Block(8, 16, kernel_size=3, stride=2, use_se=True)
>>> block(torch.zeros(1, 8, 32, 32)).shape
torch.Size([1, 16, 16, 16])
```

#### 方法

##### init

```python
def __init__(in_channels: int, out_channels: int, kernel_size: int, stride: int, use_se: bool = False, n_branches: int = 4):
```

初始化两个卷积和可选的注意力。

参数

 * `in_channels` (`int`): 输入通道数。深度卷积保持此数量。
 * `out_channels` (`int`): 点式卷积的输出通道数。
 * `kernel_size` (`int`): 深度卷积的核大小。填充为 `(kernel_size - 1) // 2`。使用奇数值。
 * `stride` (`int`): 深度卷积的步幅。`2` 还会移除其后的激活。
 * `use_se` (`bool`): 是否在两个卷积之间添加 [SqueezeExciteBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/blocks/blocks.md)。
 * `n_branches` (`int`): 每个卷积的密集分支数。

##### forward

```python
def forward(x: Tensor) -> Tensor:
```

应用两个卷积和可选的注意力。

参数

 * `x` (`Tensor`): 形状为 `[B, in_channels, H, W]` 的输入。

返回

 * `Tensor`: 形状为 `[B, out_channels, ceil(H / stride), ceil(W / stride)]` 的输出，对于奇数 `kernel_size`。

#### 属性

##### dw_conv

##### pw_conv

##### se

### LCNetV3Layer

[LCNetV3Block](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md) 块序列，构成一个 PPLCNetV3 层。

该层为四个列表的每个位置构建一个块。[scale_up](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md) 将 `out_channels` 的每个值按 `scale` 进行缩放。每个块都接收其前一个块的输出通道。`torch.nn.Sequential` 的 `forward` 按顺序运行这些块。

> **示例**
> ```pycon
>>> import torch
>>> layer = LCNetV3Layer(
...     16, [64, 64], [3, 3], [2, 1], [False, False], scale=0.95
... )
>>> layer.out_channels, len(layer)
(64, 2)
>>> layer(torch.zeros(1, 16, 8, 8)).shape
torch.Size([1, 64, 4, 4])
```

#### 方法

##### init

```python
def __init__(in_channels: int, out_channels: list[int], kernel_sizes: list[int], strides: list[int], use_se: list[bool], n_branches: int = 4, scale: float = 1.0):
```

为列表的每个位置构建一个
[LCNetV3Block](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)。

参数

 * `in_channels` (`int`): 第一个块的输入通道数。
 * `out_channels` (`list[int]`): 每个块的输出通道数，在
   [scale_up](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)
   缩放它们之前。
 * `kernel_sizes` (`list[int]`): 每个块的深度核大小。
 * `strides` (`list[int]`): 每个块的深度步幅。
 * `use_se` (`list[bool]`): 每个块是否具有
   [SqueezeExciteBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/blocks/blocks.md)。
 * `n_branches` (`int`): 每个块的每个卷积的密集分支数。
 * `scale` (`float`):
   [scale_up](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)
   应用于 `out_channels` 的宽度乘数。

引发

 * `ValueError`: 当四个列表长度不一致时。

#### 属性

##### out_channels

层的输出通道数，`scale_up(out_channels[-1], scale)`。

### QuantizedAffineBlock

[AffineBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)
的量化形式，用于 AIMET。

该类仅在安装 `aimet_torch` 时存在。装饰器 `QuantizationMixin.implements` 为
[AffineBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)
注册它。该块有一个输入量化器和一个输出量化器。

#### 方法

##### forward

```python
def forward(x: Tensor) -> Tensor:
```

使用量化输入和参数运行
[AffineBlock](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)。

该方法使用输入量化器量化 `x`。它使用量化参数运行
[AffineBlock.forward](/software-v3/ai-inference/model-source/training/luxonis-train/luxonis-train-api-reference/nodes/backbones/pplcnet_v3/blocks.md)。然后它使用输出量化器量化结果。它会跳过为
`None` 的量化器。

参数

 * `x` (`Tensor`): 任意形状的张量。

返回

 * `Tensor`: `scale * x + bias`，与 `x` 形状相同。

#### 属性

##### input_quantizers

##### output_quantizers

## 函数

### scale_up

```python
def scale_up(v: float, scale: float, divisor: int = 16, min_value: int | None = None) -> int:
```

缩放通道计数并将其四舍五入为 `divisor` 的倍数。

该函数将 `v` 乘以 `scale`。它将乘积四舍五入到最接近 `divisor` 的倍数，介于两个倍数之间的乘积向上取整。结果至少为 `min_value`。当结果低于乘积的 90% 时，函数会添加一个 `divisor`。

> **示例**
> ```pycon
>>> scale_up(512, 0.95)
480
```

`10` 四舍五入为 `8`，低于 `10` 的 90%。因此函数添加 `8`：

```pycon
>>> scale_up(10, 1.0, divisor=8)
16
```

参数

 * `v` (`float`): 要缩放的通道计数。
 * `scale` (`float`): 乘数。
 * `divisor` (`int`): 要四舍五入到的倍数。
 * `min_value` (`int | None`): 最小结果。`None` 选择 `divisor`。

返回

 * `int`: 缩放并四舍五入后的通道计数。
