TecNoticias, tu portal de información

Con implementación de Python

https://unsplash.com/@wansan_99

Introducción

En este tutorial vamos a reproducir en Python y explicar la función RoIAlign de torchvision.ops.roi_align. No pude encontrar ningún código en línea que reprodujera exactamente los resultados de la biblioteca de torchvision, por lo que tuve que revisar y traducir a Python la implementación de C++ en torchvision que puede encontrar aquí.

Antecedentes

La región de interés (RoI) en visión por computadora se puede definir como una región en una imagen donde un objeto potencial podría estar ubicado en un tarea de detección de objetos. Un ejemplo de propuestas de RoI se muestra en la Figura 1 a continuación.https://web.eecs.umich.edu/~justincj/slides/eecs498/WI2022 — Figura 1Uno de los modelos de detección de objetos en los que interviene el retorno de la inversión es Faster R-CNN. R-CNN más rápido se puede describir en dos fases: Red de Propuestas Regionales (RPN) que propone RoI y si el RoI contiene un objeto o fondo y un red de clasificación que predice la clase de objeto contenida en el RoI y las compensaciones, es decir, transformaciones de RoI para mover y cambiar el tamaño y, por lo tanto, transformarlas en propuestas finales utilizando estas compensaciones para encerrar mejor el objeto en el cuadro delimitador. La red de clasificación también rechaza las propuestas negativas que no contienen objetos; estas propuestas negativas se clasifican como antecedentes.
Es importante saber que los RoI no se predicen en el espacio de la imagen original, sino en espacio de características que se extrae de un modelo de visión. La siguiente imagen ilustra esta idea:https://web.eecs.umich.edu/~justincj/slides/eecs498/WI2022 — Figura 2Pasamos la imagen original en un modelo de visión previamente entrenado y luego extraemos un tensor 3D de características, cada una en el caso anterior de tamaño 20×15. Sin embargo, puede ser diferente según la capa de la que extraigamos las características y el modelo de visión que utilicemos. Como podemos ver, podemos encontrar la correspondencia exacta de la caja en las coordenadas de la imagen original en las coordenadas de las características de la imagen. Ahora, por qué ¿realmente necesitamos la puesta en común del retorno de la inversión?
El problema con los RoI es que todos son de diferentes tamaños, mientras que la red de clasificación requiere características de tamaño fijo.https://web.eecs.umich.edu/~justincj/slides/eecs498/WI2022 — Figura 3 Por lo tanto, la agrupación de RoI nos permite mapear en el mismo tamaño todos los RoI, por ejemplo, en características de tamaño fijo de 3×3, y predecir las clases que contiene y las compensaciones. Hay varias variaciones de la agrupación de retorno de la inversión: en este artículo nos centraremos en RoIAlinear. ¡Veamos finalmente cómo se implementa esto!

Configurar

Primero definamos un ejemplo de un mapa de características para trabajar. Por lo tanto, suponemos que estamos en una etapa en la que extrajimos características dimensionales de 7×7 de una imagen de interés.Imagen del autor — Figura 3Ahora, supongamos que extrajimos un RoI con las siguientes coordenadas en rojo en la Figura 4 (omitimos los valores de las características en los cuadros):Imagen por autor — Figura 4 En la Figura 4 también dividimos nuestro RoI en 4 regiones porque estamos agrupando en una característica dimensional 2×2. Con RoIAlign solemos hacer agrupación promedio.Imagen por autor — Figura 5 Ahora la pregunta es, ¿cómo agrupamos en promedio estas subregiones? Podemos ver que están desalineados con la cuadrícula, por lo que no podemos simplemente promediar las celdas dentro de cada subregión. La solución es muestrear puntos espaciados regularmente en cada subregión con interpolación bilineal.

Interpolación y agrupación bilineal

Primero tenemos que pensar en los puntos que interpolamos en cada subregión en el RoI. A continuación, elegimos agrupar en una región de 2×2 y generamos los puntos para los que queremos interpolar valores. # Características de imagen de 7×7
img_feats = np.array([[0.5663671 , 0.2577112 , 0.20066682, 0.0127351 , 0.07388048,
0.38410962, 0.2822853 ],
[0.3358975 , 0. , 0. , 0. , 0. ,
0. , 0.07561569],
[0.23596162, 0. , 0. , 0. , 0. ,
0. , 0.04612046],
[0. , 0. , 0. , 0. , 0. ,
0. , 0. ],
[0. , 0. , 0. , 0. , 0. ,
0. , 0. ],
[0. , 0. , 0. , 0. , 0. ,
0.18630868, 0. ],
[0. , 0. , 0. , 0. , 0. ,
0.00289604, 0. ]], dtype=np.float32)# propuesta de retorno de la inversión
roi_propuesta = [2.2821481227874756, 0.3001725673675537, 4.599632263183594, 5.58889102935791]
roi_start_w, roi_start_h, roi_end_w, roi_end_h = roi_proposal# tamaño de las regiones de agrupación
altura_agrupada = 2
pooled_width = 2# RoI ancho y alto
roi_width = roi_end_w – roi_start_w
roi_height = roi_end_h – roi_start_h
# roi_height= 5.288, roi_width = 2.317# dividimos cada subregión de RoI en áreas roi_bin_grid_h x roi_bin_grid_w.
# Estos definirán el número de puntos de muestreo en cada subregión
roi_bin_grid_h = np.ceil(roi_height / pooled_height)
roi_bin_grid_w = np.ceil(roi_width / pooled_width)
# roi_bin_grid_h = 3, roi_bin_grid_w = 2
# Por lo tanto, en general, tenemos 6 puntos de muestreo en cada subregión # Altura y peso sin procesar de cada subregión de RoI
bin_size_h = roi_height / pooled_height
bin_size_w = roi_width / pooled_width
# bin_size_h = 2.644, bin_size_w = 1.158# variable que se usará para calcular el valor combinado en cada subregión
output_val = 0# ph y pw definen cada cuadrado (subregión) en el que se divide el RoI.
ph = 0
pw = 0
# iy y ix representan puntos muestreados dentro de cada subregión en RoI.
# En este ejemplo roi_bin_grid_h = 3 y roi_bin_grid_w = 2, entonces
# tener un total de 6 puntos para los cuales interpolamos los valores y luego promediamos
# para que presenten un valor para cada una de las 4 áreas en el ROI combinado
# subregiones
para iy en el rango (int (roi_bin_grid_h)):
# ph * bin_size_h – qué cuadrado en RoI elegir verticalmente (en el eje y)
# (iy + 0.5) * bin_size_h / roi_bin_grid_h – cuál de los roi_bin_grid_h
# puntos verticales para seleccionar dentro del cuadrado
yy = roi_start_h + ph * bin_size_h + (iy + 0.5) * bin_size_h / roi_bin_grid_h
para ix en el rango (int (roi_bin_grid_w)):
# pw * bin_size_w – qué cuadrado en RoI elegir horizontalmente (en el eje x)
# (ix + 0.5) * bin_size_w / roi_bin_grid_w – cuál de los roi_bin_grid_w
# puntos verticales para seleccionar dentro del cuadrado
xx = roi_start_w + pw * bin_size_w + (ix + 0.5) * bin_size_w / roi_bin_grid_w
imprimir (xx, yy) # valores xx e yy:
# 2.57 0.74
# 3.15 0.74
# 2.57 1.62
# 3.15 1.62
# 2.57 2.50
# 3.15 2.50 En la Figura 6 podemos ver los 6 puntos muestrales correspondientes a la subregión 1.Imagen del Autor — Figura 6 Para hacer la interpolación bilineal del valor correspondiente al primer punto de coordenadas (2.57, 0.74), encontramos el recuadro donde se posiciona este punto. Así que tomamos el piso de estos valores: (2, 0) que corresponde al punto superior izquierdo de la caja (x_low, y_low) y luego, sumando 1 a estas coordenadas, encontramos el punto inferior derecho (x_high, y_high) de la caja — (3, 1). Esto se representa en la siguiente figura:Imagen por Autor — Figura 6Según la Figura 3, el punto (0, 2) corresponde a 0.2, el punto (0,3) a 0.012 y así sucesivamente. Siguiendo el código anterior, dentro del último bucle encontramos el valor interpolado para el punto rojo dentro de la subregión: x = xx; y = aa
si y si x y_bajo = int(y); x_bajo = int(x)
si (y_bajo >= altura – 1):
y_alto = y_bajo = altura – 1
y = y_bajo
más:
y_alto = y_bajo + 1si (x_bajo >= ancho-1):
x_alto = x_bajo = ancho-1
x = x_bajo
más:
x_high = x_low + 1# calcular pesos e interpolación bilineal
ly = y – y_bajo; lx = x – x_bajo;
hy = 1. – ly; hx = 1. – lx;
w1 = hy * hx; w2 = hy * lx; w3 = ly * hx; w4 = ly * lx; salida_val += w1 * img_feats[y_low, x_low] + w2 * img_feats[y_low, x_high] + \
w3 * img_feats[y_high, x_low] + w4 * img_feats[y_high, x_high] Entonces tenemos para el punto rojo el siguiente resultado:Imagen por autor — Figura 7 Si luego lo hacemos para los 6 puntos en la subregión, obtenemos los siguientes resultados: # valores interpolados para cada punto en la subregión
[0.0241, 0.0057, 0., 0., 0., 0.]# si luego tomamos el promedio, obtenemos el valor promedio combinado para
# la primera región:
0.004973Al final obtenemos los siguientes resultados combinados promedio:Imagen por autor — Figura 8 El código completo:

Comentarios adicionales al código

El código anterior contiene algunas características adicionales que no discutimos y que explicaré brevemente aquí: puede cambiar la variable de alineación para que sea Verdadero o Falso. Si es Verdadero, el píxel cambia las coordenadas del cuadro en -0.5 para una mejor alineación con los dos índices de píxeles vecinos. Esta versión se usa en Detectron2.sampling_ratio define el número de puntos de muestreo en cada subregión de un RoI como se ilustra en la Figura 6, donde se usaron 6 puntos de muestreo. Si sampling_ratio = -1 , entonces se calcula automáticamente como vimos en el primer fragmento de código: roi_bin_grid_h = np.ceil(roi_height / pooled_height)
roi_bin_grid_w = np.ceil(roi_width / pooled_width)

Conclusiones

En este artículo hemos visto cómo funciona RoIAlign y cómo se implementa en la biblioteca de torchvision. RoIAlign se puede ver como una capa en una arquitectura de red neuronal y como cada capa que puede propagar hacia adelante y hacia atrás a través de ella, lo que permite entrenar sus modelos de un extremo a otro.
Después de leer este artículo, lo animo a que lea también sobre la agrupación de RoI y por qué se prefiere RoIAlign. Si entendió RoIAlign, comprender la agrupación de RoI no debería ser un problema.