Анализ статьи PANet: Когда функции пирамид увеличиваются вверх.
Понимание того, как низкий уровень проникновения PANet между уровневыми и высокоуровневыми механизмами.
Делиться
В моей предыдущей статье я писал об архитектуре FPN (Feature Pyramid Network) [1], которая является одним из наиболее влиятельных элементов, которые мы можем применить для определения моделей. FPN была впервые представлена для повышения способности модели обнаруживать мелкие объекты. Однако Лю и др. В 2018 году было обнаружено, что поток информации в ФПН требует улучшения. Поэтому немного они решили устранить этот пробел, предложив PANet в своей исследовательской работе под названием «Сеть способов агрегации для сегментации экземпляров» [2], которую мы собираемся обсудить в этой статье.PANet построена на основе конструкции FPN, поэтому, думаю, было бы неплохо заранее рассказать о том, как работает FPN. В моделях на основе CNN более глубокие вещества имеют другие характеристики, чем более мелкие. Карты признаков из более защитных слоев, как правило, содержат много семантической информации, но не так много пространственной информации. И наоборот, признаки карт из более мелких слоев содержат больше пространственной информации, но меньше семантической. Эти факты, по сути, говорят нам о том, что для прогнозирования крупных объектов следует использовать более глубокие признаки карт, а для прогнозирования мелких объектов — более мелкие.
Однако авторы PANet обнаружили, что прямое извлечение информации с помощью более мелких картографических признаков для обнаружения мелких объектов не совсем подходит. Это связано с тем, что данные карты содержат минимальное количество семантической информации, что, по сути, означает, что они не дают хорошего представления о содержании изображения. ФПН решает эту проблему, объединяя признаки карт из более древних и более глубоких слоев. Таким образом, мы можем, по сути, внедрить семантическую информацию в более мелкие признаки карты, которых в них раньше не было. Поток вверх слева — это основная базовая модель, поток вниз вправо (так называется нисходящий путь) — это FPN. Горизонтальные направления, направляющиеся непосредственно к части FPN (называемой боковыми соединениями), — это тензоры, которые будут соединяться с тензорами из более нейтральных слоев. На этой иллюстрации ФПН представляет три доказательства, на основе детектора, который будет делать предсказания ограничивающих рамок.
Синие границы на иллюстрации выше показывают количество семантической информации, которая отображается в соответствии с картой признаков. В исходной ситуации сети видно, что границы становятся все толще по мере углубления в сеть, что означает, что признаки карты с наибольшим уровнем проявления семантической информации создают самый глубокий слой. используется механизм сочетания карт признаков, предложенный FPN, мы видим, что более мелкие карты теперь содержат богатую семантическую информацию, что делает их пригодными для точного обнаружения мелких объектов.На данном этапе мы можем предположить, что FPN вполне подходит, поскольку позволяет моделям лучше находить мелкие объекты по сравнению с обычной моделью координат. На самом деле, авторы PANet всё поддерживают, пока не решены с помощью FPN, и которые, как я уже упоминал, обеспокоены проблемой потока информации. Теперь давайте посмотрим на рисунок 2 ниже.
В этом примере компонент, обозначенный как (а), представляет собой базовую модель, оснащенную FPN, которая, по сути, имеет ту же самую структуру, что и на рисунке 1. В картах FPN признаки P₅, P₄, P₃ и P₂ создают данные для обнаружения, выполняющего предсказание, при этом P₂ обеспечивает высокую семантическую информацию благодаря потоку в любом направлении. И вот эту проблему FPN не решает: хотя FPN эффективно обогащает методы анализа в более мелких слоях, более глубокие методы анализа по-прежнему испытывают недостаток пространственной информации. В начале этой статьи я отмечал, что более глубокие и более мелкие признаки карт в концептуальных моделях имеют свои преимущества и недостатки, а FPN определяет только недостаток более мелких признаков карт, о сохранении этой проблемы при рассмотрении более обоснованных признаков карточек говорилось без внимания. Исходя из этой идеи, авторы PANet предположили, что мы можем улучшить возможности обнаружения моделей объектов для выявления крупных объектов, включая пространственную информацию в более глубокие карты, что также позволяет еще больше повысить точность определения моделей. Однако это происходит не только из-за самого понижения разрешения. Длинные пути передачи информации в стеке сверточных слоев также приводят к ухудшению пространственной информации. Поэтому, если мы не можем осуществить экстренную операцию понижения разрешения в сети, мы все равно можем минимизировать это представление пространственной информации, создав путь — такие пропускные соединения в ResNet.Авторы PANet предложили остроумную идею: они добавили несколько сверточных слоев поверхности боковой FPN, а также боковые соединения (часть, обозначенная как (b) на рисунке 2). На первый взгляд это может показаться нелогичным — поскольку добавление большего количества слоев может привести к более коротким путям? На самом деле этот подход оправдан, поскольку он обеспечивает более поверхностным картам элементы более плавно распределяет пространственную информацию более глубокими слоями.
Теперь обратите внимание на рисунку 2 и обратите внимание на точечные направления. Обе стороны, по сути, обозначают тензор потока C₂ (основной признак с тем же пространственным развитием, что и P₂ и N₂) к самому глубокому слою. Красная стрелка обозначает случай, когда мы используем только нисходящий путь FPN, а зеленая — случай, когда мы также используем восходящий путь расширения PANet.
Если мы не используем PANet, единственный способ для тензора C₂ перейти на последний уровень P₅ — это проход через всю базовую сеть по одному слою, который может состоять из более 100 слоев. И, как мы обсуждали ранее, это приводит к ухудшению пространственной информации. Если сравнивать это с потоком информации при использовании PANet, то, по сути, это позволяет нам использовать путь, обозначенный зеленой стрелкой. Следует иметь в виду, что количество слоев в нижних и нижних направлениях значительно меньше, чем в конечной сети, что увеличивает расстояние со 100+ слоев до примерно 10 слоев для достижения N₅ (который находится на том же уровне, что и P₅). Таким образом, мы можем сохранить гораздо больше пространственной информации. И поэтому, объединяя FPN и PANet, мы получаем двунаправленный поток информации, который обогащает более базовую семантическую информацию, более глубокую — пространственную информацию. Полная версия статей о PANet фактически также включает в себя механизм адаптивного пулинга (c), предсказание ограничительных рамок для обнаружения объектов (d) и полносвязное слияние признаков для сегментации (e), которые отражаются в рамках нашей работы. class=»wp-block-paragraph»>В FPN тензоры P₅, P₄, P₃ и P₂ напрямую передаются в детектор, тогда как в PANet эти четыре тензора передаются в алгоритме увеличения пути постепенно вверх, который затем формирует тензоры N₅, N₄, N₃ и N₂. Эти N тензоров использовались детектором в качестве основы для прогнозирования обнаруженного объекта.
В целом способ объединения признаков в PANet аналогичен методу FPN, но результаты в обратном порядке. Подробное описание процесса представлено на рисунке 3 ниже.
В описанном выше блоке мы сначала обрабатываем тензор Nᵢ с помощью свертки 3×3. Шаг этого сверточного слоя установлен как условие 2, так как мы хотим уменьшить размер пространства вдвое. Затем мы объединяем тензор Pᵢ₊₁ и уменьшенный тензор Nᵢ с помощью поэлементного суммирования. Этот объединенный тензор затем обрабатывается еще одним сверточным слоем 3×3. На этот раз мы не хотим, чтобы этот слой еще меньше уменьшал объемную размерность, поэтому нам нужно установить условие шага 1. Наконец, завершая все вышеописанные послепроцессы, мы получаем тензор Nᵢ₊₁, который готов к обработке с той же самой процедурой, пока мы в конечном итоге не повторим все тензоры N₅, N₄, N₃ и N₂.
Здесь нужно учитывать несколько моментов. Во-первых, поскольку N₂ — это самый первый тензор в восходящем пути расширения, то для его получения ничего не нужно комбинировать. Таким образом, мы просто рассматривали P₂ как сам тензор N₂. Во-вторых, здесь необходимо добавить функцию активации ReLU после каждого сверточного слоя. Это отличается от FPN, который полностью опускает функцию активации. Поэтому в более поздних стадиях реализации наш следующий путь вообще не будет использовать какие-либо функции активации, но при этом все сверхточные этапы в обратном пути будут обеспечивать алгоритм ReLU. В-третьих, все тензоры во всем обратном пути увеличения имеют ровно 256 вариантов, что означает, что сверточные слои здесь вообще не меняют количество вариантов.
Это, в общем-то, всё, что касается детального описания структуры PANet. В следующем разделе я продемонстрировал, как реализовать ее с нуля.
PANet с нуля
Идея реализации заключается в том, что мы создадим фиктивную базовую сеть на основе FPN и составим слой ее слоя PANet. Как обычно, первым делом в коде необходимо импортировать необходимые модули. См. блок кода 1 ниже.
# Codeblock 1 import torch import torch.nn as nn
Реализация CNN
Под «фиктивной сетью» я подразумеваю очень простую модель CNN. На самом деле, класс CNNв блоке кода 2 ниже точно такой же, как в моей статье о FPN [1]. Просто имейте в виду, что в статье используется базовая сеть ResNet, но поскольку в этой статье речь идет о PANet, я буду использовать ее вместо стандартной CNN. (Кстати, у меня есть отдельная статья о ResNet. показана с ней по ссылке в [4], если вам интересно реализовать FPN на ResNet с нуля.)
# Кодовый блок 2 class CNN(nn.Module): def __init__(self): super().__init__() self.relu = nn.ReLU() self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1) self.conv2 = nn.Conv2d(in_channels=64, out_channels=256, kernel_size=3, дополнение=1) self.conv3 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, дополнение=1) self.conv4 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, дополнение = 1) self.conv5 = nn.Conv2d(in_channels=1024, out_channels=2048, kernel_size=3, дополнение=1) def вперед(self, x): print(f'originalt: {x.size()}n') x = self.relu(self.conv1(x)) print(f'after conv1t: {x.size()}') x = self.maxpool(x) print(f'after пулt: {x.size()}n') x = self.relu(self.conv2(x)) print(f'after conv2t: {x.size()}') x = self.maxpool(x) print(f'after пул (c2)t: {x.size()}n') c2 = x.clone() x = self.relu(self.conv3(x)) print(f'after conv3t: {x.size()}') x = self.maxpool(x) print(f'after пул (c3)t: {x.size()}n') c3 = x.clone() x = self.relu(self.conv4(x)) print(f'after conv4t: {x.size()}') x = self.maxpool(x) print(f'after пул (c4)t: {x.size()}n') c4 = x.clone() x = self.relu(self.conv5(x)) print(f'after conv5t: {x.size()}') c5 = self.maxpool(x) print(f'after пул (c5)t: {c5.size()}n') return c2, c3, c4, c5
Класс CNN описанный выше, извлекает несколько выходных результатов: c2 , c3 , c4 и c5 , где c5 — это тензор из самого глубокого слоя. Чтобы проверить корректность работы этого класса, мы протестируем его, пропустив через него тензор. Вспомогательный тензор, сложенный в блоке кода 3 ниже, имеет размерность 3×224×224, что соответствует форме входных данных модели ResNet.
# Codeblock 3 cnn = CNN() x = torch.randn(1, 3, 224, 224) out_cnn = cnn(x) c2, c3, c4, c5 = out_cnn
Ниже вы можете увидеть, как базовая модель преобразует наш входной тензор в пределах всей сети. В качестве входных данных для нашего FPN будут использоваться все тензоры C.
# Исходный код Codeblock 3: torch.Size([1, 3, 224, 224]) после conv1: torch.Size([1, 64, 224, 224]) после пула: torch.Size([1, 64, 112, 112]) после conv2: torch.Size([1, 256, 112, 112]) после пула (c2): torch.Size([1, 256, 56, 56]) после conv3: torch.Size([1, 512, 56, 56]) после пула (c3): torch.Size([1, 512, 28, 28]) после conv4: torch.Size([1, 1024, 28, 28]) после пула (c4): torch.Size([1, 1024, 14, 14]) после conv5 : torch.Size([1, 2048, 14, 14]) после пула (c5) : torch.Size([1, 2048, 7, 7])
Реализация FPN
А вот как выглядит класс FPN. Я не буду вентилировать описание работы этой сети, поскольку я подробно описал это в предыдущей статье [1].
# Кодовый блок 4 класса FPN(nn.Module): def __init__(self): super().__init__() self.upsample = nn.Upsample(scale_factor=2, mode='nearest') #(1) self. Lateral_c5 = nn.Conv2d(in_channels=2048, out_channels=256, kernel_size=1) self. Lateral_c4 = nn.Conv2d(in_channels=1024, out_channels=256, kernel_size=1) self. Lateral_c3 = nn.Conv2d(in_channels=512, out_channels=256, kernel_size=1) self. Lateral_c2 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=1) self.smooth_m4 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, дополнение=1) self.smooth_m3 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, дополнение=1) self.smooth_m2 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, отступ=1) def вперед(self, c2, c3, c4, c5): m5 = self. Lateral_c5(c5) p5 = m5 m4 = self.upsample(m5) + self. Lateral_c4(c4) p4 = self.smooth_m4(m4) m3 = self.upsample(m4) + self. Lateral_c3(c3) p3 = self.smooth_m3(m3) m2 = self.upsample(m3) + self. Lateral_c2(c2) p2 = self.smooth_m2(m2) return p2, p3, p4, p5
Теперь давайте сосредоточимся на возвращаемых P-тензорах, которые будем мы использовать в качестве входных данных для нашей PANet. Как видно из приведенного ниже кода, все P-тензоры имеют 256 каналов, и я изначально, именно поэтому авторы в итоге изменили такое количество каналов для всей структуры PANet.
# Кодовый блок 5 fpn = FPN() out_fpn = fpn(c2, c3, c4, c5) p2, p3, p4, p5 = out_fpn print(f'p2: {p2.size()}') print(f'p3: {p3.size()}') print(f'p4: {p4.size()}') print(f'p5: {p5.size()}')
# Кодовый блок 5 Выход p2: torch.Size([1, 256, 56, 56]) p3: torch.Size([1, 256, 28, 28]) p4: torch.Size([1, 256, 14, 14]) p5: torch.Size([1, 256, 7, 7])
Внедрение PANet
И наконец, пришло время реализовать саму PANet. В приведенном ниже блоке кода мы сначала разделяем фрагменты downsample_n{2,3,4} . Как следует из названия, эти изменения расположены для пространственного уменьшения разрешения, поэтому мы вставляем параметр <код>шагкод>для этих слоев равным 2. Затем мы создаём conv_{n2down_p3, n3down_p4, n4down_p5} . Эти три сверточных слоя используются для обработки объединенных тензоров. Например, слой с суффиксом n2down_p3 будет приниматься на вход объединенных пониженных тензоров N₂ и P₃. Не забудьте придумать функцию активации ReLU, поскольку мы будем использовать ее после каждого сверточного слоя.
# Кодовый блок 6 класса PANet(nn.Module): def __init__(self): super().__init__() self.downsample_n2 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, шаг=2, дополнение=1) self.downsample_n3 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, шаг=2, заполнение=1) self.downsample_n4 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, шаг=2, заполнение=1) self.conv_n2down_p3 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, заполнение=1) self.conv_n3down_p4 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, дополнение=1) self.conv_n4down_p5 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, дополнение=1) self.relu = nn.ReLU() def вперед(self, p2, p3, p4, p5): n2 = p2 #(1) print(f'n2tt: {n2.size()}n') ####################################################################################################n2down = self.relu(self.downsample_n2(n2)) #(2) print(f'n2 пониженная дискретизацияt: {n2down.size()}') n2down_p3 = n2down + p3 #(3) print(f'after sumt: {n2down_p3.size()}') n3 = self.relu(self.conv_n2down_p3(n2down_p3)) #(4) print(f'n3tt: {n3.size()}n') #####################################################################################################n3down = self.relu(self.downsample_n3(n3)) print(f'n3 downsampledt: {n3down.size()}') n3down_p4 = n3down + p4 print(f'after sumt: {n3down_p4.size()}') n4 = self.relu(self.conv_n3down_p4(n3down_p4)) print(f'n4tt: {n4.size()}n') #################################### n4down = self.relu(self.downsample_n4(n4)) print(f'n4 пониженная дискретизацияt: {n4down.size()}') n4down_p5 = n4down + p5 print(f'after sumt: {n4down_p5.size()}') n5 = self.relu(self.conv_n4down_p5(n4down_p5)) print(f'n5tt: {n5.size()}') return n2, n3, n4, n5
Теперь перейдём к методу forward(). Здесь вы видите, что мы принимаем все P-тензоры из FPN в качестве входных данных. Как я уже упоминал ранее, нам не нужно ничего делать с тензором P₂, поскольку соответствующий ему N-тензор является первым в ходе пути расширения ( #(1) ). Далее, в строке, отмеченной #(2) мы уменьшаем размерность тензора n2 таким образом, чтобы его пространственная размерность уменьшалась вдвое. Этот процесс важен для размерности, поскольку мы хотим, чтобы тензор n2 имел точно такую же размерность, как p3 , чтобы можно было выполнить поэлементное суммирование ( #(3) ). После этого этот объединённый тензор дополнительно обрабатывается ещё одним свёрточным слоем ( #(4) ). Эти шаги повторяются несколько раз, пока мы в конечном итоге не достигли n5 .
Теперь давайте протестируем наш, созданный экземпляр PANet и пропустив через сеть код P тензоров, результат результатов результатов. n3, n4, n5 = out_panet
А вот как выглядит результат. Похоже, наша сеть PANet работает правильно, поскольку входной тензор успешно продвигается до конца сети. Также видно, что при уменьшении пространственной размерности количество карточек признаков на каждом шаге остается неизменным, именно то, чего мы хотим.
# Кодовый блок 7 Выход n2 : torch.Size([1, 256, 56, 56]) n2 пониженная дискретизация: torch.Size([1, 256, 28, 28]) после sum : torch.Size([1, 256, 28, 28]) n3 : torch.Size([1, 256, 28, 28]) n3 пониженная дискретизация: torch.Size([1, 256, 14, 14]) после суммы: torch.Size([1, 256, 14, 14]) n4 : torch.Size([1, 256, 14, 14]) n4 пониженная дискретизация: torch.Size([1, 256, 7, 7]) после sum : torch.Size([1, 256, 7, 7]) n5 : torch.Size([1, 256, 7, 7])
Всё за один проход
Наконец, давайте попробуем знания все в одном классе, которые я называю BackboneNeck . Сделать это очень просто: в методе __init__() нам нужно всего лишь лишь идейизировать созданные ранее вымышленные CNN, FPN и PANet. Затем в методе forward() мы можем постоянно передавать тензоры. Здесь я также вывожу форму тензоров на промежуточных элементах, чтобы вы могли видеть, как тензоры преобразуются после каждой части сети. Выходами этого BackboneNeckявляются N тензоров, готовых к устройству обнаружения.
# Codeblock 8 class BackboneNeck(nn.Module): def __init__(self): super().__init__() self.cnn = CNN() self.fpn = FPN() self.panet = PANet() def вперед(self, x): c2, c3, c4, c5 = self.cnn(x) print(f'c2: {c2.size()}') print(f'c3: {c3.size()}') print(f'c4: {c4.size()}') print(f'c5: {c5.size()}n') p2, p3, p4, p5 = self.fpn(c2, c3, c4, c5) print(f'p2: {p2.size()}') print(f'p3: {p3.size()}') print(f'p4: {p4.size()}') print(f'p5: {p5.size()}n') n2, n3, n4, n5 = self.panet(p2, p3, p4, p5) print(f'n2: {n2.size()}') print(f'n3: {n3.size()}') print(f'n4: {n4.size()}') print(f'n5: {n5.size()}') return n2, n3, n4, n5
Теперь давайте протестируем наш класс BackboneNeck , используя следующий пример code.
# Codeblock 9 backbone_neck = BackboneNeck() x = torch.randn(1, 3, 224, 224) n2, n3, n4, n5 = backbone_neck(x)
Здесь мы видим, что наше фиктивное RGB-изображение размером 224×224 успешно проходит через всю сеть. Зоры C, созданные сетью, изначально имеют различное количество каналов ( #(1–4) ). Затем наша FPN нормализует их до 256 равномерных каналов, обогащая при этом более минимальную часть семантической информации ( #(5–8)). Далее мы обрабатываем полученные тензоры P с помощью PANet, чтобы внедрить пространственную информацию в более глубокий слой, в результате чего получаются тензоры N, сохраняя при этом те же пространственные размеры, что и соответствуют им тензоры P ( #(9–12) ).
# Кодовый блок 9 Исходный результат: torch.Size([1, 3, 224, 224]) после conv1 : torch.Size([1, 64, 224, 224]) после пула : torch.Size([1, 64, 112, 112]) после conv2 : torch.Size([1, 256, 112, 112]) после пула (c2): torch.Size([1, 256, 56, 56]) после conv3 : torch.Size([1, 512, 56, 56]) после пула (c3): torch.Size([1, 512, 28, 28]) после conv4: torch.Size([1, 1024, 28, 28]) после пула (c4): torch.Size([1, 1024, 14, 14]) после conv5: torch.Size([1, 2048, 14, 14]) после пула (c5): torch.Size([1, 2048, 7, 7]) c2: torch.Size([1, 256, 56, 56]) #(1) c3: torch.Size([1, 512, 28, 28]) #(2) c4: torch.Size([1, 1024, 14, 14]) #(3) c5: torch.Size([1, 2048, 7, 7]) #(4) p2: torch.Size([1, 256, 56, 56]) #(5) p3: torch.Size([1, 256, 28, 28]) #(6) p4: torch.Size([1, 256, 14, 14]) #(7) p5: torch.Size([1, 256, 7, 7]) #(8) n2: torch.Size([1, 256, 56, 56]) #(9) n3: torch.Size([1, 256, 28, 28]) #(10) n4: torch.Size([1, 256, 14, 14]) #(11) n5: torch.Size([1, 256, 7, 7]) #(12)Завершение
Вот и всё о том, работает как PANet, особенно в отношении того, как он обогащает пространственную информацию в более традиционных слоях. На самом деле есть несколько других компонентов PANet, которые я не добавляю в эту статью, а именно компоненты (c), (d) и (e) на рисунке 2, о которых я, думаю, расскажу в следующих статьях.
Большое спасибо за прочтение. Вы также можете найти код, использованный в этой статье, в моих репозиториях GitHub [5]. Пожалуйста, сообщите мне, если в коде или в моих запросах есть ошибка. До встречи в моей этой статье!
Ссылки
[1] Мухаммад Арди. Обзор статьи FPN: Использование внутренней пирамиды. https://towardsdatascience.com/fpn-paper-walkthrough-leveraging-the-internal-pyramid/[Дата обращения: 3 июля 2026 г.].
[2] Шу Лю и др. Сеть способы агрегации для сегментации экземпляров. Арксив. https://arxiv.org/abs/1803.01534 [Доступно 8 октября 2025 г.].
[3] Цун-И Лин и др. Пирамидальные сетевые критерии для обнаружения объектов. Арксив. https://arxiv.org/abs/1612.03144 [Доступно 8 октября 2025 г.].
[4] Мухаммад Арди. Обзор статьи: Остаточная сеть (ResNet). Python на простом английском языке. https://medium.com/python-in-plain-english/paper-walkthrough-residual-network-resnet-62af58d1c521 [Дата обращения: 8 октября 2025 г.].
[5] МухаммадАрдиПутра. ПАНет. Гитхаб. https://github.com/MuhammadArdiPutra/medium_articles/blob/main/Deep%20Learning%20From%20Scratch/PANet.ipynb [Дата обращения: 8 октября 2025 г.].
Мухаммад Арди. Все материалы от Мухаммада Арди.
Источник: towardsdatascience.com
Оцените материал:
