Skip to content

fpem

model.neck.fpem

FPEM_FFM 

FPEM_FFM(backbone_out_channels: Optional[List[int]] = None, **kwargs)

Bases: Module

PANnet :param backbone_out_channels: 基础网络输出的维度

Source code in SaigeToolkit/model/neck/fpem.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def __init__(self, backbone_out_channels: Optional[List[int]] = None, **kwargs):
    """
    PANnet
    :param backbone_out_channels: 基础网络输出的维度
    """
    super().__init__()
    if backbone_out_channels is None:
        backbone_out_channels = [64, 128, 256, 512]

    fpem_repeat = kwargs.get("fpem_repeat", 2)
    conv_out = 64
    # reduce layers
    self.reduce_conv_c2 = nn.Sequential(
        nn.Conv2d(in_channels=backbone_out_channels[0], out_channels=conv_out, kernel_size=1),
        nn.BatchNorm2d(conv_out),
        nn.ReLU(),
    )
    self.reduce_conv_c3 = nn.Sequential(
        nn.Conv2d(in_channels=backbone_out_channels[1], out_channels=conv_out, kernel_size=1),
        nn.BatchNorm2d(conv_out),
        nn.ReLU(),
    )
    self.reduce_conv_c4 = nn.Sequential(
        nn.Conv2d(in_channels=backbone_out_channels[2], out_channels=conv_out, kernel_size=1),
        nn.BatchNorm2d(conv_out),
        nn.ReLU(),
    )
    self.reduce_conv_c5 = nn.Sequential(
        nn.Conv2d(in_channels=backbone_out_channels[3], out_channels=conv_out, kernel_size=1),
        nn.BatchNorm2d(conv_out),
        nn.ReLU(),
    )
    self.fpems = nn.ModuleList()
    for _ in range(fpem_repeat):
        self.fpems.append(FPEM(conv_out))
    self.out_conv = nn.Conv2d(in_channels=conv_out * 4, out_channels=6, kernel_size=1)

reduce_conv_c2 instance-attribute 

reduce_conv_c2 = Sequential(Conv2d(in_channels=(backbone_out_channels[0]), out_channels=conv_out, kernel_size=1), BatchNorm2d(conv_out), ReLU())

reduce_conv_c3 instance-attribute 

reduce_conv_c3 = Sequential(Conv2d(in_channels=(backbone_out_channels[1]), out_channels=conv_out, kernel_size=1), BatchNorm2d(conv_out), ReLU())

reduce_conv_c4 instance-attribute 

reduce_conv_c4 = Sequential(Conv2d(in_channels=(backbone_out_channels[2]), out_channels=conv_out, kernel_size=1), BatchNorm2d(conv_out), ReLU())

reduce_conv_c5 instance-attribute 

reduce_conv_c5 = Sequential(Conv2d(in_channels=(backbone_out_channels[3]), out_channels=conv_out, kernel_size=1), BatchNorm2d(conv_out), ReLU())

fpems instance-attribute 

fpems = ModuleList()

out_conv instance-attribute 

out_conv = Conv2d(in_channels=(conv_out * 4), out_channels=6, kernel_size=1)

forward 

forward(x)
Source code in SaigeToolkit/model/neck/fpem.py 
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
def forward(self, x):
    c2, c3, c4, c5 = x
    # reduce channel
    c2 = self.reduce_conv_c2(c2)
    c3 = self.reduce_conv_c3(c3)
    c4 = self.reduce_conv_c4(c4)
    c5 = self.reduce_conv_c5(c5)

    # FPEM
    for i, fpem in enumerate(self.fpems):
        c2, c3, c4, c5 = fpem(c2, c3, c4, c5)
        if i == 0:
            c2_ffm = c2
            c3_ffm = c3
            c4_ffm = c4
            c5_ffm = c5
        else:
            c2_ffm += c2
            c3_ffm += c3
            c4_ffm += c4
            c5_ffm += c5

    # # FFM
    # c5 = F.interpolate(c5_ffm, c2_ffm.size()[-2:], mode="bilinear")
    # c4 = F.interpolate(c4_ffm, c2_ffm.size()[-2:], mode="bilinear")
    # c3 = F.interpolate(c3_ffm, c2_ffm.size()[-2:], mode="bilinear")
    # Fy = torch.cat([c2_ffm, c3, c4, c5], dim=1)
    # y = self.out_conv(Fy)
    return c2_ffm, c3_ffm, c4_ffm, c5_ffm

FPEM 

FPEM(in_channels=128)

Bases: Module

Source code in SaigeToolkit/model/neck/fpem.py 
77
78
79
80
81
82
83
84
def __init__(self, in_channels=128):
    super().__init__()
    self.up_add1 = SeparableConv2d(in_channels, in_channels, 1)
    self.up_add2 = SeparableConv2d(in_channels, in_channels, 1)
    self.up_add3 = SeparableConv2d(in_channels, in_channels, 1)
    self.down_add1 = SeparableConv2d(in_channels, in_channels, 2)
    self.down_add2 = SeparableConv2d(in_channels, in_channels, 2)
    self.down_add3 = SeparableConv2d(in_channels, in_channels, 2)

up_add1 instance-attribute 

up_add1 = SeparableConv2d(in_channels, in_channels, 1)

up_add2 instance-attribute 

up_add2 = SeparableConv2d(in_channels, in_channels, 1)

up_add3 instance-attribute 

up_add3 = SeparableConv2d(in_channels, in_channels, 1)

down_add1 instance-attribute 

down_add1 = SeparableConv2d(in_channels, in_channels, 2)

down_add2 instance-attribute 

down_add2 = SeparableConv2d(in_channels, in_channels, 2)

down_add3 instance-attribute 

down_add3 = SeparableConv2d(in_channels, in_channels, 2)

forward 

forward(c2, c3, c4, c5)
Source code in SaigeToolkit/model/neck/fpem.py 
86
87
88
89
90
91
92
93
94
95
96
def forward(self, c2, c3, c4, c5):
    # up阶段
    c4 = self.up_add1(self._upsample_add(c5, c4))
    c3 = self.up_add2(self._upsample_add(c4, c3))
    c2 = self.up_add3(self._upsample_add(c3, c2))

    # down 阶段
    c3 = self.down_add1(self._upsample_add(c3, c2))
    c4 = self.down_add2(self._upsample_add(c4, c3))
    c5 = self.down_add3(self._upsample_add(c5, c4))
    return c2, c3, c4, c5

_upsample_add 

_upsample_add(x, y)
Source code in SaigeToolkit/model/neck/fpem.py 
98
99
def _upsample_add(self, x, y):
    return F.interpolate(x, size=y.size()[2:], mode="bilinear") + y

SeparableConv2d 

SeparableConv2d(in_channels, out_channels, stride=1)

Bases: Module

Source code in SaigeToolkit/model/neck/fpem.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
def __init__(self, in_channels, out_channels, stride=1):
    super(SeparableConv2d, self).__init__()

    self.depthwise_conv = nn.Conv2d(
        in_channels=in_channels,
        out_channels=in_channels,
        kernel_size=3,
        padding=1,
        stride=stride,
        groups=in_channels,
    )
    self.pointwise_conv = nn.Conv2d(
        in_channels=in_channels, out_channels=out_channels, kernel_size=1
    )
    self.bn = nn.BatchNorm2d(out_channels)
    self.relu = nn.ReLU()

depthwise_conv instance-attribute 

depthwise_conv = Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=3, padding=1, stride=stride, groups=in_channels)

pointwise_conv instance-attribute 

pointwise_conv = Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1)

bn instance-attribute 

bn = BatchNorm2d(out_channels)

relu instance-attribute 

relu = ReLU()

forward 

forward(x)
Source code in SaigeToolkit/model/neck/fpem.py 
120
121
122
123
124
125
def forward(self, x):
    x = self.depthwise_conv(x)
    x = self.pointwise_conv(x)
    x = self.bn(x)
    x = self.relu(x)
    return x