blocks
最后更新
luxonis_train.nodes.backbones.micronet.blocksMicroNet 主干网络的块。类
ChannelShuffle
groups 个大小相等的组。输出首先获取每个组的第一个通道,然后是每个组的第二个通道,依此类推。混洗后的分组卷积会读取所有组的通道。当 groups 等于 1 或通道数时,顺序不变。示例
Pycon
1>>> import torch
2>>> x = torch.arange(6.0).view(1, 6, 1, 1)
3>>> ChannelShuffle(3)(x).flatten().tolist()
4[0.0, 2.0, 4.0, 1.0, 3.0, 5.0]方法
init
Python
1def __init__(groups: int):groups(int): 组的数量。输入通道数必须是它的倍数。
forward
Python
1def forward(x: Tensor) -> Tensor:x(Tensor): 形状为[B, C, H, W]的输入。C必须是groups的倍数。否则,重塑会引发RuntimeError。
Tensor: 通道顺序已更改的输入,形状相同。
DepthSpatialSepConv
in_channels 组的 k×1 卷积将通道乘以 expand[0] 并沿高度应用步幅。一个每个输入通道一个组的 1×k 卷积将通道乘以 expand[1] 并沿宽度应用步幅。每个卷积后都有一个批归一化。卷积没有偏置,块没有激活。示例
Pycon
1>>> import torch
2>>> conv = DepthSpatialSepConv(4, (2, 3), kernel_size=3, stride=2)
3>>> conv(torch.zeros(1, 4, 9, 9)).shape
4torch.Size([1, 24, 5, 5])方法
init
Python
1def __init__(in_channels: int, expand: tuple[int, int], kernel_size: int, stride: int):in_channels(int): 输入通道数。expand(tuple[int, int]): k×1 和 1×k 卷积的通道乘数。该块有in_channels * expand[0] * expand[1]个输出通道。kernel_size(int): 核大小 k。填充为kernel_size // 2。stride(int): 沿高度和宽度的步幅。
forward
Python
1def forward(x: Tensor) -> Tensor:x(Tensor): 形状为[B, in_channels, H, W]的输入。
Tensor: 形状为[B, in_channels * expand[0] * expand[1], H', W']的输出。对于奇数kernel_size,H'是ceil(H / stride),W'是ceil(W / stride)。
属性
conv
DYShiftMax
g 的通道 c,取组 g + 1 的通道 c + 1。两个索引都环绕。对于 2 个组中的 8 个通道,x̃ 的通道 0 取通道 5,即第二个组的第二个通道。对于两个分支,输出为y = max(a1x + b1x̃, a2x + b2x̃)对于一个分支,输出为 y = a1x + b1x̃。一个挤压网络从输入计算系数。它将每个通道沿高度和宽度平均。两个线性层之间有一个 ReLU,然后是一个硬 sigmoid。该模块将结果从 [0, 1] 映射到 [-2, 2],并添加偏移量 init_a 和 init_b。每个系数对于每个样本都有 out_channels 个值。示例
Pycon
1>>> import torch
2>>> act = DYShiftMax(8, 8, groups=2)
3>>> act(torch.ones(2, 8, 4, 4)).shape
4torch.Size([2, 8, 4, 4])方法
init
Python
1def __init__(in_channels: int, out_channels: int, init_a: tuple[float, float] = (0.0, 0.0), init_b: tuple[float, float] = (0.0, 0.0), use_relu: bool = True, groups: int = 6, reduction: int = 4, expansion: bool = False):in_channels(int): 输入通道数。它必须是组数的倍数。out_channels(int): 每个系数的通道数。forward 需要它等于in_channels或1。当为1时,样本的所有通道共享每个系数。init_a(tuple[float, float]): a1 和 a2 的偏移量。forward 将init_a[0]添加到 a1。它不读取init_a[1],因为它将init_b[1]添加到 a2。init_b(tuple[float, float]): b1 和 b2 的偏移量。init_b[1]也用于 a2。use_relu(bool):True选择两个分支及其最大值,一种动态形式的ReLU。False选择一个没有最大值的分支。groups(int): 用于移位的通道组数。当为1时,移位将通道移动一个位置。reduction(int): 挤压网络隐藏层的in_channels的除数。该模块将in_channels // reduction四舍五入到最接近的4的倍数,最小为4。当四舍五入下降超过 10% 时,它会添加4。expansion(bool): 当True且groups不为1时,组数为in_channels // groups。然后groups是每个组中的通道数。
forward
Python
1def forward(x: Tensor) -> Tensor:x(Tensor): 形状为[B, in_channels, H, W]的输入。
Tensor: 激活后的输入,形状相同。
属性
avg_pool
fc
MicroBlock
in_channels * expand_ratio[0] * expand_ratio[1] 个通道。groups_1 和 groups_2 选择三种布局之一:- lite 块,当
groups_1[0]为0时。一个 DepthSpatialSepConv 扩展通道并应用步幅。一个分组的 1×1 卷积将它们投影到out_channels。 - transition 块,当
groups_2[1]为0且groups_1[0]不为0时。一个分组的 1×1 卷积扩展通道。该块没有深度卷积,也没有投影。其输出保留扩展的通道。 - full 块,在所有其他情况下。一个分组的 1×1 卷积扩展通道。一个没有扩展的 DepthSpatialSepConv 应用步幅。第二个分组的 1×1 卷积将通道投影到
out_channels。
ReLU6 或没有激活跟随每个 1×1 卷积和每个 DepthSpatialSepConv,如 dy_shift 所选。ChannelShuffle 层混合组的通道。当 stride 为 1 且 out_channels 等于 in_channels 时,该块将其输入添加到其输出。示例
Pycon
1>>> import torch
2>>> x = torch.zeros(2, 8, 16, 16)
3>>> lite = MicroBlock(
4... 8, 16, stride=2, groups_1=(0, 8), groups_2=(4, 4)
5... )
6>>> lite(x).shape
7torch.Size([2, 16, 8, 8])out_channels 和 stride:Pycon
1>>> transition = MicroBlock(
2... 8,
3... 16,
4... stride=2,
5... expand_ratio=(1, 6),
6... groups_1=(4, 4),
7... groups_2=(0, 0),
8... )
9>>> transition(x).shape
10torch.Size([2, 48, 16, 16])方法
init
Python
1def __init__(in_channels: int, out_channels: int, kernel_size: int = 3, stride: int = 1, expand_ratio: tuple[int, int] = (2, 2), groups_1: tuple[int, int] = (0, 6), groups_2: tuple[int, int] = (1, 1), dy_shift: tuple[int, int, int] = (2, 0, 1), reduction_factor: int = 1, init_a: tuple[float, float] = (1.0, 1.0), init_b: tuple[float, float] = (0.0, 0.0)):in_channels(int): 输入通道数。out_channels(int): lite 或 full 块的输出通道数。transition 块的层不读取它。残差检查在所有布局中都读取它。kernel_size(int): DepthSpatialSepConv 的核大小 k,它是一个 k×1 和一个 1×k 卷积。transition 块忽略它。stride(int): DepthSpatialSepConv 的步幅。transition 块的层忽略它。expand_ratio(tuple[int, int]): 扩展的两个通道乘数。lite 块在其 DepthSpatialSepConv 的每一半中应用一个乘数。其他布局在扩展 1×1 卷积中应用乘积。groups_1(tuple[int, int]): 第一个值是扩展 1×1 卷积的组数。0选择 lite 块。第二个值设置投影前 DYShiftMax 层的组数,以及第一个激活后 ChannelShuffle 的组数。在 full 块的深度卷积后的 DYShiftMax 中,当值不为1时,组数是扩展通道数除以该值。在 transition 块中,该值设置其唯一的 DYShiftMax 的组数。groups_2(tuple[int, int]): 第一个值是投影 1×1 卷积的组数。第二个值设置最后一个 DYShiftMax 和其后 ChannelShuffle 的组数。当groups_1[0]不为0时,0选择 transition 块。dy_shift(tuple[int, int, int]): 扩展卷积后、深度卷积后和投影后的激活。在前两个位置,正值选择 DYShiftMax,其他值选择ReLU6。2选择两个分支,其他正值选择一个分支。在最后一个位置,正值选择一个单分支 DYShiftMax,其他值选择无激活。lite 块忽略第一个值。transition 块只读取最后一个值,用于其扩展后的激活。在 lite 或 full 块中,非0值也会在激活后添加一个 ChannelShuffle。在 lite 块中,第二个值添加一个C // 2组,其中C是扩展通道数。在 full 块中,前两个值在深度激活后共享一个。当两个值都不为0时,它有C // 4组;当只有一个不为0时,它有C // 2组。最后一个值添加一个out_channels // 2组。在 lite 块中,只有当out_channels为偶数时才这样做。reduction_factor(int): DYShiftMax 的挤压网络的缩减。激活使用8 * reduction_factor的reduction。lite 块的最后一个激活使用4 * reduction_factor。当out_channels小于扩展通道数时,full 块的最后一个激活也使用。init_a(tuple[float, float]): DYShiftMax 中输入权重的偏移量。扩展后和深度卷积后的激活使用它们。最后一个激活和 transition 块的激活使用(1.0, 0.0)。init_b(tuple[float, float]): DYShiftMax 中移位输入权重的偏移量。与init_a相同的激活使用它们。其他使用(0.0, 0.0)。
forward
Python
1def forward(inputs: Tensor) -> Tensor:inputs(Tensor): 形状为[B, in_channels, H, W]的输入。
Tensor: 形状为[B, C, H', W']的输出。C对于 lite 或 full 块是out_channels,对于 transition 块是扩展的通道数。对于奇数kernel_size,H'是ceil(H / stride),W'是ceil(W / stride)。transition 块保留H和W。通过残差连接,输出是层输出和inputs的和。对于 transition 块,除非扩展通道数等于in_channels,否则此和会引发RuntimeError。
属性
layers
SpatialSepConvSF
outs[0] 个通道,并沿高度应用步幅。一个 outs[0] 组的 1×k 卷积将通道乘以 outs[1],并沿宽度应用步幅。每个卷积后都有一个批归一化。一个 outs[0] 组的 ChannelShuffle 结束该块。卷积没有偏置,块没有激活。示例
Pycon
1>>> import torch
2>>> conv = SpatialSepConvSF(3, (4, 2), kernel_size=3, stride=2)
3>>> conv(torch.zeros(1, 3, 32, 32)).shape
4torch.Size([1, 8, 16, 16])方法
init
Python
1def __init__(in_channels: int, outs: tuple[int, int], kernel_size: int, stride: int):in_channels(int): 输入通道数。outs(tuple[int, int]): 通道布局。第一个值是 k×1 卷积的输出通道数。它也是 1×k 卷积和混洗的组数。第二个值是 1×k 卷积的通道乘数。kernel_size(int): 核大小 k。填充为kernel_size // 2。stride(int): 沿高度和宽度的步幅。
forward
Python
1def forward(x: Tensor) -> Tensor:x(Tensor): 形状为[B, in_channels, H, W]的输入。
Tensor: 形状为[B, outs[0] * outs[1], H', W']的输出。对于奇数kernel_size,H'是ceil(H / stride),W'是ceil(W / stride)。
属性
conv
Stem
3 的 SpatialSepConvSF,后跟一个原地 ReLU6。示例
Pycon
1>>> import torch
2>>> stem = Stem(3, stride=2, outs=(3, 2))
3>>> stem(torch.zeros(1, 3, 32, 32)).shape
4torch.Size([1, 6, 16, 16])方法
init
Python
1def __init__(in_channels: int, stride: int, outs: tuple[int, int] = (4, 4)):in_channels(int): 输入通道数。stride(int): 沿高度和宽度的步幅。outs(tuple[int, int]): SpatialSepConvSF 的通道布局。第一个值是 3×1 卷积的输出通道数及其后的组数。第二个值是通道乘数。Stem 有outs[0] * outs[1]个输出通道。
forward
Python
1def forward(x: Tensor) -> Tensor:ReLU6。参数x(Tensor): 形状为[B, in_channels, H, W]的输入。
Tensor: 形状为[B, outs[0] * outs[1], ceil(H / stride), ceil(W / stride)]的输出,值为[0, 6]。