Una guida completa sull’atrous convolution nelle CNN

Un viaggio completo nell'articolata convoluzione nelle CNN

Introduzione

Nel campo della visione artificiale, le Reti Neurali Convoluzionali (CNN) hanno ridefinito il panorama dell’analisi e comprensione delle immagini. Queste potenti reti hanno consentito progressi in compiti come la classificazione delle immagini, il rilevamento degli oggetti e la segmentazione semantica. Hanno posto le basi per una vasta gamma di applicazioni nei settori della salute, dei veicoli autonomi e altro ancora.

Tuttavia, poiché la richiesta di modelli più consapevoli del contesto e robusti continua a crescere, i tradizionali strati convoluzionali all’interno delle CNN hanno incontrato limitazioni nel catturare informazioni contestuali estese. Ciò ha reso necessarie tecniche innovative capaci di migliorare la capacità della rete di comprendere contesti più ampi senza aumentare significativamente la complessità computazionale.

Ecco l’ Elaborazione Atrous, un approccio innovativo che ha sconvolto le norme convenzionali degli strati convoluzionali all’interno delle CNN. L’elaborazione Atrous, nota anche come convoluzione dilatata, introduce una nuova dimensione nel mondo dell’apprendimento profondo, consentendo alle reti di catturare contesti più ampi senza aumentare significativamente il costo computazionale o i parametri.

Obiettivi di apprendimento

• Conoscere i fondamenti delle Reti Neurali Convoluzionali e come elaborano i dati visivi per comprendere le immagini.
• Capire come l’Elaborazione Atrous migliora i metodi di convoluzione tradizionali catturando un contesto maggiore nelle immagini.
• Esplorare le famose architetture CNN che utilizzano l’Elaborazione Atrous, come DeepLab e WaveNet, per vedere come migliora le loro prestazioni.
• Acquisire una comprensione pratica delle applicazioni dell’Elaborazione Atrous nelle CNN attraverso esempi pratici e frammenti di codice.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

• Apprendimento adattivo attraverso la diffusione un paradigma all’avanguardia
• Deccodificare il Regolamento sull’Intelligenza Artificiale
• L’azienda indiana Startup rilascia OpenHathi il primo LLM in hindi di sempre

Comprensione delle CNN: Come funziona

Le Reti Neurali Convoluzionali (CNN) sono una classe di reti neurali profonde principalmente progettate per analizzare dati visivi come immagini e video. Sono ispirate al sistema visivo umano ed sono eccezionalmente efficaci in compiti che coinvolgono il riconoscimento di pattern all’interno dei dati visivi. Ecco come funzionano:

1. Strati convoluzionali: Le CNN sono composte da più strati, con gli strati convoluzionali che costituiscono il nucleo. Questi strati utilizzano operazioni di convoluzione che applicano filtri apprendibili ai dati di input, estraendo varie caratteristiche dalle immagini.
2. Strati di pooling: Dopo la convoluzione, spesso si utilizzano strati di pooling per ridurre le dimensioni spaziali, comprimendo le informazioni apprese dagli strati convoluzionali. Le operazioni di pooling comuni includono il pooling massimo o il pooling medio, che riducono le dimensioni della rappresentazione mantenendo informazioni essenziali.
3. Funzioni di attivazione: Dopo gli strati convoluzionali e di pooling, si utilizzano funzioni di attivazione non lineari (come ReLU – Rectified Linear Unit) per introdurre non linearità nella rete, consentendole di apprendere pattern e relazioni complesse all’interno dei dati.
4. Strati completamente connessi: Verso la fine della CNN, spesso si utilizzano strati completamente connessi. Questi strati consolidano le caratteristiche estratte dagli strati precedenti e svolgono compiti di classificazione o regressione.
5. Convoluzione punto per punto: La convoluzione punto per punto, nota anche come convoluzione 1×1, è una tecnica utilizzata nelle CNN per riduzione della dimensionalità e combinazione delle caratteristiche. Coinvolge l’applicazione di un filtro 1×1 ai dati di input, riducendo efficacemente il numero di canali di input e consentendo la combinazione di caratteristiche tra i canali. La convoluzione punto per punto viene spesso utilizzata in combinazione con altre operazioni convoluzionali per migliorare la capacità della rete di catturare pattern e relazioni complessi all’interno dei dati.
6. Parametri apprendibili: Le CNN si basano su parametri apprendibili (pesi e bias) che vengono aggiornati durante il processo di addestramento. Questo addestramento comprende la propagazione in avanti, in cui i dati di input vengono passati attraverso la rete, e la retropropagazione, che regola i parametri in base alle prestazioni della rete.

Iniziare con la convoluzione dilatata

La convoluzione dilatata, nota anche come convoluzione dilatata, è un tipo di operazione convoluzionale che introduce un parametro chiamato tasso di dilatazione. A differenza della convoluzione regolare, che applica filtri ai pixel adiacenti, la convoluzione dilatata introduce spazi tra i parametri del filtro, controllati dal tasso di dilatazione. Questo processo ingrandisce il campo recettivo dei filtri senza aumentare il numero di parametri. In termini più semplici, consente alla rete di catturare un contesto più ampio dai dati di input senza aggiungere complessità.

Il tasso di dilatazione determina quanti pixel vengono saltati tra ogni passaggio della convoluzione. Un tasso di 1 rappresenta una convoluzione regolare, mentre tassi più elevati saltano più pixel. Questo campo recettivo ingrandito consente di catturare informazioni contestuali più ampie senza aumentare il costo computazionale, consentendo alla rete di catturare sia dettagli locali che contesto globale in modo efficiente.

In sostanza, la convoluzione dilatata facilita l’integrazione di informazioni contestuali più ampie nelle reti neurali convoluzionali, consentendo una migliore modellazione di modelli su larga scala all’interno dei dati. È comunemente utilizzata in applicazioni in cui il contesto a scale variabili è cruciale, come la segmentazione semantica nella visione artificiale o nella gestione di sequenze nelle attività di elaborazione del linguaggio naturale.

Convoluzioni dilatate per l’apprendimento multi-scala delle caratteristiche

Le convoluzioni dilatate, note anche come convoluzioni dilatate, hanno svolto un ruolo fondamentale nell’apprendimento delle caratteristiche multi-scala all’interno delle reti neurali. Ecco alcuni punti chiave sul loro ruolo nell’abilitazione dell’apprendimento multi-scala delle caratteristiche:

1. Espansione contestuale: le convoluzioni dilatate consentono alla rete di catturare informazioni da un contesto più ampio senza aumentare significativamente il numero di parametri. Introducendo spazi nei filtri, il campo recettivo si espande senza appesantire il carico computazionale.
2. Campi recettivi variabili: con tassi di dilatazione superiori a 1, queste convoluzioni creano un effetto “multi-scala”. Consentono alla rete di elaborare contemporaneamente input a diverse scale o granularità, catturando dettagli fini e grossolani nella stessa strato.
3. Estrazione delle caratteristiche gerarchica: i tassi di dilatazione possono essere modulati tra i livelli di rete per creare un meccanismo di estrazione delle caratteristiche gerarchiche. I livelli inferiori con tassi di dilatazione più piccoli si concentrano su dettagli fini, mentre i livelli superiori con tassi di dilatazione più grandi catturano un contesto più ampio.
4. Fusione efficiente delle informazioni: le convoluzioni dilatate facilitano la fusione di informazioni da diverse scale in modo efficiente. Forniscono un meccanismo per combinare le caratteristiche di vari campi recettivi, migliorando la comprensione della rete dei modelli complessi nei dati.
5. Applicazioni in segmentazione e riconoscimento: in compiti come la segmentazione delle immagini o il riconoscimento del parlato, le convoluzioni dilatate sono state utilizzate per migliorare le prestazioni, consentendo alle reti di apprendere rappresentazioni multi-scala, portando a predizioni più accurate.

Struttura delle convoluzioni dilatate e regolari

Immagine di input (Rettangolo)    |    |Convoluzione regolare (Quadrato)    - Dimensione del kernel: Kernel fisso    - Strategia di scorrimento: Su mappe di input    - Passo: Di solito 1    - Mappa delle caratteristiche di output: Dimensione ridotta    Convoluzione dilatata (Quadrato)    - Dimensione del kernel: Kernel fisso con spazi (controllato dalla dilatazione)    - Strategia di scorrimento: Elementi spaziati, campo recettivo aumentato    - Passo: Controllato dal tasso di dilatazione    - Mappa delle caratteristiche di output: Preserva la dimensione dell'input, campo recettivo espanso

Confronto tra convoluzione regolare e convoluzione dilatata

Aspetto	Convoluzione regolare	Convoluzione dilatata
Applicazione del filtro	Applica filtri a regioni contigue dei dati di input	Introduce spazi tra gli elementi del filtro (buchi)
Dimensione del kernel	Dimensione del kernel fissa	Dimensione del kernel fissa, ma con spazi (controllati dalla dilatazione)
Strategia di scorrimento	Scorre su mappe di input	Gli elementi spaziati consentono un campo recettivo ingrandito
Passo	Di solito, un passo di 1	Aumento del passo effettivo, controllato dal tasso di dilatazione
Dimensione della mappa delle caratteristiche di output	Riduzione della dimensione a causa della convoluzione	Preserva la dimensione dell’input aumentando il campo recettivo
Campo recettivo	Campo recettivo effettivo limitato	Campo recettivo effettivo aumentato
Cattura delle informazioni di contesto	Cattura del contesto limitata	Capacità migliorata di catturare un contesto più ampio

Applicazioni della convoluzione atriale

• Le convoluzioni atriali migliorano la velocità espandendo il campo recettivo senza aggiungere parametri.
• Consentono di focalizzare selettivamente regioni specifiche di input, migliorando l’efficienza dell’estrazione delle caratteristiche.
• La complessità computazionale è ridotta rispetto alle convoluzioni tradizionali con kernel più grandi.
• Ideale per l’elaborazione video in tempo reale e la gestione di set di immagini su larga scala.

Esplorazione delle architetture famose

DeepLab [REF 1]

DeepLab è una serie di architetture di reti neurali convoluzionali create per la segmentazione semantica delle immagini. È riconosciuto per l’utilizzo di convoluzioni atriali (anche note come convoluzioni dilatate) e pooling piramidale atriale spaziale (ASPP) per catturare informazioni contestuali multi-scala nelle immagini, consentendo una segmentazione preciso a livello di pixel.

Ecco una panoramica di DeepLab:

• DeepLab si focalizza sulla segmentazione delle immagini in regioni significative assegnando un’etichetta ad ogni pixel, contribuendo a comprendere il contesto dettagliato all’interno di un’immagine.
• Le Convoluzioni atriali, utilizzate da DeepLab, sono convoluzioni dilatate che espandono il campo recettivo della rete senza sacrificare la risoluzione. Ciò consente a DeepLab di catturare contesto a diverse scale, consentendo una raccolta completa delle informazioni senza un aumento significativo del costo computazionale.
• Il pooling piramidale atriale spaziale (ASPP) è una funzionalità utilizzata in DeepLab per raccogliere efficientemente informazioni multi-scala. Utilizza convoluzioni atriali parallele con diversi tassi di dilatazione per catturare il contesto a diverse scale ed effettivamente fondere le informazioni.
• L’architettura di DeepLab, con la sua enfasi sul contesto multi-scala e la segmentazione precisa, ha raggiunto un alto livello di performance in varie sfide di segmentazione semantica, mostrando un’elevata precisione nelle attività di segmentazione.

Codice:

import tensorflow as tffrom tensorflow.keras import Sequentialfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Conv2DTransposedef crea_modello_DeepLab(shape_input, num_classi):    modello = Sequential([        Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=shape_input),        Conv2D(64, (3, 3), activation='relu', padding='same'),        MaxPooling2D(pool_size=(2, 2)),                Conv2D(128, (3, 3), activation='relu', padding='same'),        Conv2D(128, (3, 3), activation='relu', padding='same'),        MaxPooling2D(pool_size=(2, 2)),                # Aggiungi ulteriori strati convoluzionali se necessario                Conv2DTranspose(64, (3, 3), strides=(2, 2), padding='same', activation='relu'),        Conv2D(num_classi, (1, 1), activation='softmax', padding='valid')    ])    return modello# Definisci la forma dell'input e il numero di classiforma_input = (256, 256, 3)  # Esempio di forma dell'inputnum_classi = 21  # Esempio di numero di classi# Crea il modello DeepLabdeep_lab_model = crea_modello_DeepLab(forma_input, num_classi)# Compila il modello (potresti voler modificare l'ottimizzatore e la funzione di perdita in base al tuo compito)deep_lab_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])# Stampa il sommario del modellodeep_lab_model.summary()

Reti completamente convoluzionali (FCNS) [REF 2]

• Reti interamente convoluzionali (FCNs) e preservazione spaziale: le FCNs sostituiscono i livelli completamente connessi con convoluzioni 1×1, fondamentali per mantenere informazioni spaziali, specialmente in compiti come la segmentazione.
• Struttura dell’encoder: l’encoder, spesso basato su VGG, subisce una trasformazione in cui i livelli completamente connessi vengono convertiti in strati convoluzionali. Ciò mantiene i dettagli spaziali e la connettività con l’immagine.
• Integrazione delle convoluzioni atriali: le convoluzioni atriali sono fondamentali nelle FCNs. Consentono alla rete di catturare informazioni multi-scala senza aumentare significativamente i parametri o perdere la risoluzione spaziale.
• Segmentazione semantica: le convoluzioni atriali aiutano a catturare informazioni contestuali più ampie a diverse scale, consentendo alla rete di comprendere oggetti di varie dimensioni e scale all’interno della stessa immagine.
• Ruolo del decoder: la rete del decoder aumenta le mappe delle caratteristiche alla dimensione originale dell’immagine utilizzando strati convoluzionali inversi. Le convoluzioni atriali garantiscono che il processo di aumento delle dimensioni conservi dettagli spaziali cruciali dall’encoder.
• Aumento della precisione: attraverso l’integrazione delle convoluzioni atriali, le FCNs ottengono un’accuratezza migliorata nei compiti di segmentazione semantica catturando in modo efficiente contesto e informazioni spaziali a diverse scale.

Codice:

import tensorflow as tf# Definisci la funzione di layer di convoluzione atrousdef atrous_conv_layer(inputs, filters, kernel_size, rate):    return tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size,     dilation_rate=rate, padding='same', activation='relu')(inputs)# Architettura di esempio FCN con convoluzioni atrousdef FCN_with_AtrousConv(input_shape, num_classes):    inputs = tf.keras.layers.Input(shape=input_shape)    # Encoder (stile VGG)    conv1 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(inputs)    conv2 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv1)    # Layer di convoluzione atrous    atrous_conv1 = atrous_conv_layer(conv2, 128, (3, 3), rate=2)    atrous_conv2 = atrous_conv_layer(atrous_conv1, 128, (3, 3), rate=4)    # Aggiungi altre convoluzioni atrous se necessario...    # Decoder (convoluzione trasposta)    upsample = tf.keras.layers.Conv2DTranspose(64, (3, 3), strides=(2, 2), padding='same')    (atrous_conv2)    output = tf.keras.layers.Conv2D(num_classes, (1, 1), activation='softmax')(upsample)    model = tf.keras.models.Model(inputs=inputs, outputs=output)    return model# Definisci la forma dell'input e il numero di classiinput_shape = (256, 256, 3)  # Esempio di forma dell'inputnum_classes = 10  # Esempio di numero di classi# Crea un'istanza del modello FCN with AtrousConvmodel = FCN_with_AtrousConv(input_shape, num_classes)# Compila il modellomodel.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])# Visualizza il riepilogo del modellomodel.summary()

LinkNet [REF 3]

LinkNet è un’architettura avanzata di segmentazione delle immagini che combina l’efficienza della sua progettazione con la potenza delle convoluzioni atrous, anche note come convoluzioni dilatate. Sfrutta le connessioni skip per migliorare il flusso delle informazioni e segmentare in modo accurato le immagini.

• Segmentazione efficiente delle immagini: LinkNet segmenta efficientemente le immagini utilizzando convoluzioni atrous, una tecnica che espande il campo di ricezione senza aumentare eccessivamente i parametri.
• Integrazione delle convoluzioni atrous: Utilizzando convoluzioni atrous o convoluzioni dilatate, LinkNet cattura efficacemente le informazioni contestuali mantenendo requisiti computazionali gestibili.
• Connessioni skip per un flusso migliorato: Le connessioni skip di LinkNet aiutano a migliorare il flusso delle informazioni attraverso la rete. Ciò facilita una segmentazione più precisa integrando caratteristiche di diverse profondità di rete.
• Design ottimizzato: L’architettura è ottimizzata per trovare un equilibrio tra efficienza computazionale e segmentazione precisa delle immagini. Ciò la rende adatta a vari compiti di segmentazione.
• Architettura scalabile: Il design di LinkNet consente la scalabilità, permettendo di gestire compiti di segmentazione di varie complessità con efficienza e accuratezza.

Codice:

import torchimport torch.nn as nnimport torch.nn.functional as Fclass ConvBlock(nn.Module):    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):        super(ConvBlock, self).__init__()        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size,         stride=stride, padding=padding)        self.bn = nn.BatchNorm2d(out_channels)        self.relu = nn.ReLU(inplace=True)    def forward(self, x):        x = self.conv(x)        x = self.bn(x)        x = self.relu(x)        return xclass DecoderBlock(nn.Module):    def __init__(self, in_channels, out_channels):        super(DecoderBlock, self).__init__()        self.conv1 = ConvBlock(in_channels, in_channels // 4, kernel_size=1, stride=1, padding=0)        self.deconv = nn.ConvTranspose2d(in_channels // 4, out_channels, kernel_size=4,         stride=2, padding=1)        self.conv2 = ConvBlock(out_channels, out_channels)    def forward(self, x, skip):        x = F.interpolate(x, scale_factor=2, mode='nearest')        x = self.conv1(x)        x = self.deconv(x)        x = self.conv2(x)        if skip is not None:            x += skip        return xclass LinkNet(nn.Module):    def __init__(self, num_classes=21):        super(LinkNet, self).__init__()        # Encoder        self.encoder = nn.Sequential(            ConvBlock(3, 64),            nn.MaxPool2d(2),            ConvBlock(64, 128),            nn.MaxPool2d(2),            ConvBlock(128, 256),            nn.MaxPool2d(2),            ConvBlock(256, 512),            nn.MaxPool2d(2)        )        # Decoder        self.decoder = nn.Sequential(            DecoderBlock(512, 256),            DecoderBlock(256, 128),            DecoderBlock(128, 64),            DecoderBlock(64, 32)        )        # Predizione finale        self.final_conv = nn.Conv2d(32, num_classes, kernel_size=1)    def forward(self, x):        skips = []        for module in self.encoder:            x = module(x)            skips.append(x.clone())        skips = skips[::-1]  # Inverti per il decoder        for i, module in enumerate(self.decoder):            x = module(x, skips[i])        x = self.final_conv(x)        return x# Esempio di utilizzo:input_tensor = torch.randn(1, 3, 224, 224)  # Esempio di forma del tensore di inputmodel = LinkNet(num_classes=10)  # Esempio di numero di classioutput = model(input_tensor)print(output.shape)  # Esempio di forma del output

InstanceFCN [REF 4]

Questo metodo adatta le Fully Convolutional Networks (FCN), che sono molto efficaci per la segmentazione semantica, alla segmentazione semantica consapevole dell’istanza. A differenza della FCN originale, in cui ogni pixel di output è un classificatore di una categoria di oggetti, in InstanceFCN ogni pixel di output è un classificatore delle posizioni relative delle istanze. Ad esempio, nella mappa dei punteggi, ogni pixel è un classificatore se appartiene o meno al “lato destro” di un’istanza.

Come funziona InstanceFCN

Una FCN viene applicata all’immagine di input per generare k² mappe di punteggio, ognuna corrispondente a una particolare posizione relativa. Queste vengono chiamate mappe di punteggi sensibili all’istanza. Per produrre istanze di oggetti da queste mappe di punteggio, viene utilizzata una finestra scorrevole di dimensioni m×m. La finestra m×m viene divisa in finestre dimensionali k², m ⁄ k × m ⁄ k corrispondenti a ciascuna delle posizioni relative k². Ciascuna sottofinestra m ⁄ k × m ⁄ k di output copia direttamente i valori dalla stessa sottofinestra nella mappa di punteggio corrispondente. Le k² sottofinestre vengono unite in base alle loro posizioni relative per assemblare un output di segmentazione m×m. Ad esempio, la sottofinestra #1 dell’output nell’immagine sopra viene presa direttamente dalla sottofinestra in alto a sinistra m ⁄ k × m ⁄ k della finestra m×m nella mappa di punteggi sensibili all’istanza #1. Questo si chiama modulo di assemblaggio delle istanze.

Architettura InstanceFCN

L’architettura consiste nell’applicare VGG-16 completamente convoluzionale all’immagine di input. Sulla mappa delle caratteristiche di output, sono presenti due branch completamente convoluzionali. Uno di essi serve per stimare le istanze di segmento (come descritto in precedenza) e l’altro per valutare le istanze.

Sono utilizzate convoluzioni atrous, che introducono lacune nel filtro, in alcune parti di questa architettura per espandere il campo visivo della rete e catturare più informazioni contestuali.

Per il primo branch, viene utilizzato un livello convoluzionale 1×1 512-d seguito da un livello convoluzionale 3×3 per generare il set di k² mappe di punteggio sensibili all’istanza. Il modulo di assemblaggio (come descritto in precedenza) viene utilizzato per prevedere la maschera di segmentazione m×m (= 21). Il secondo branch consiste in un livello convoluzionale 3×3 512-d seguito da un livello convoluzionale 1×1. Questo livello convoluzionale 1×1 è una regressione logistica per pixel per classificare istanza/non un’istanza della finestra scorrevole m×m centrata su questo pixel. Pertanto, l’output del branch è una mappa di punteggio di oggettività in cui un punteggio corrisponde a una finestra scorrevole che genera un’istanza. Pertanto, questo metodo è indifferente alle diverse categorie di oggetti.

Codice:

from tensorflow.keras.models import Modelfrom tensorflow.keras.layers import Input, Conv2D, concatenate# Definisci il tuo livello di convoluzione atrousdef atrous_conv_layer(input_layer, filters, kernel_size, dilation_rate):    return Conv2D(filters=filters, kernel_size=kernel_size,     dilation_rate=dilation_rate, padding='same', activation='relu')(input_layer)# Definisci il tuo modello InstanceFCNdef InstanceFCN(input_shape):    inputs = Input(shape=input_shape)        # Le tue VGG-16 come livelli completamente convoluzionali qui    conv1 = Conv2D(64, (3, 3), activation='relu', padding='same')(inputs)    conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv1)        # Livello di convoluzione atrous    atrous_conv = atrous_conv_layer(conv2, filters=128, kernel_size=(3, 3),     dilation_rate=(2, 2))    # Altri livelli convoluzionali e branch per il punteggio e la stima dell'istanza    # Livelli di output per il punteggio e la stima dell'istanza    score_output = Conv2D(num_classes, (1, 1), activation='softmax')(... )      # Il tuo output di punteggio    instance_output = Conv2D(num_instances, (1, 1), activation='sigmoid')(... )      # Il tuo output di istanza    return Model(inputs=inputs, outputs=[score_output, instance_output])# Uso:model = InstanceFCN(input_shape=(256, 256, 3))  # Esempio di forma di inputmodel.summary()  # Visualizza il riepilogo del modello

Segmentazione Semantica Completamente Convolutiva con Consapevolezza delle Istanze (FCIS)

La segmentazione semantica completamente convolutiva con consapevolezza delle istanze (FCIS) è costituita dal metodo IntanceFCN. IntanceFCN è in grado solo di prevedere una maschera di dimensioni fisse m×m e non può classificare l’oggetto in diverse categorie. FCIS risolve tutto ciò prevedendo maschere di diverse dimensioni e prevedendo anche le diverse categorie degli oggetti.

Predizione Congiunta della Maschera e Classificazione

Dato un RoI, le mappe dei punteggi a livello di pixel sono prodotte dall’operazione di assemblaggio come descritto sopra in InstanceFCN. Per ogni pixel in RoI, ci sono due compiti (pertanto, vengono prodotte due mappe dei punteggi):

1. Rilevamento: se appartiene a un box di delimitazione di un oggetto in una posizione relativa
2. Segmentazione: se si trova all’interno del confine di un’istanza di oggetto

In base a questo, si presentano tre casi:

1. Punteggio interno alto e punteggio esterno basso: rilevamento+, segmentazione+
2. Punteggio interno basso e punteggio esterno alto: rilevamento+, segmentazione-
3. Entrambi i punteggi sono bassi: rilevamento-, segmentazione-

Per il rilevamento, viene utilizzata l’operazione di max per differenziare i casi 1 e 2 (rilevamento+) dal caso 3 (rilevamento-). Il punteggio di rilevamento dell’intero RoI viene ottenuto tramite media pooling su tutte le probabilità dei pixel, seguito dall’operatore softmax su tutte le categorie. Per la segmentazione, softmax viene utilizzato per differenziare il caso 1 (segmentazione+) dal resto (segmentazione-). La maschera di primo piano del RoI è l’unione dei punteggi di segmentazione per pixel per ogni categoria.

ResNet viene utilizzato per estrarre le features dall’immagine di input in modo completamente convolutivo. Viene aggiunto un RPN sopra il layer conv4 per generare i RoI. Dalla mappa delle features conv5, vengono prodotte k² × C+1 mappe dei punteggi (C categorie di oggetti, una categoria di sfondo, due set di k² mappe dei punteggi per categoria) utilizzando un layer conv. 1 × 1. I RoI (dopo la soppressione dei non massimi) vengono classificati come le categorie con i punteggi di classificazione più alti. Per ottenere la maschera di primo piano, vengono considerati tutti i RoI con punteggi di intersezione su unione superiori a 0,5 rispetto al RoI preso in considerazione. La maschera della categoria viene mediata su base per pixel, ponderata per i punteggi di classificazione. La maschera mediata viene quindi binarizzata.

Conclusioni

Le Convoluzioni Atrous hanno trasformato la segmentazione semantica affrontando la sfida di catturare informazioni contestuali senza sacrificare l’efficienza computazionale. Queste convoluzioni dilatate sono progettate per espandere i campi ricettivi pur mantenendo la risoluzione spaziale. Sono diventate componenti essenziali di architetture moderne come DeepLab, LinkNet e altre.

La capacità delle Convoluzioni Atrous di catturare caratteristiche multiscala e migliorare la comprensione contestuale ha portato alla loro adozione diffusa in modelli di segmentazione all’avanguardia. Man mano che la ricerca progredisce, l’integrazione delle Convoluzioni Atrous con altre tecniche promette ulteriori progressi nel raggiungimento di una segmentazione semantica precisa, efficiente e ricca di contesto in diverse aree.

Lezioni Chiave

• Le Convoluzioni Atrous nelle CNN ci aiutano a comprendere immagini complesse osservando diverse scale senza perdere dettagli.
• Mantengono l’immagine chiara e dettagliata, semplificando l’identificazione di ogni parte dell’immagine.
• Sono integrati senza soluzione di continuità in architetture come DeepLab, LinkNet e altri, potenziando l’efficacia nella segmentazione accurata di oggetti in diverse aree.

Domande Frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.