Deep Learning (CNN)

Francis Loayza
Repaso de la clase anterior

2
¿Qué es Deep Learning?

Un subcampo de aprendizaje automático de representaciones de datos de

aprendizaje.
Excepcional efectivo en los patrones de aprendizaje.
Los algoritmos de aprendizaje profundo intentan aprender (múltiples niveles)
de representación mediante el uso de una jerarquía de múltiples capas
Proporciona al sistema toneladas de información, comienza a comprenderlo y
responder de formas útiles.

Tumor:
Maligno
Benigno

Tumor:
Maligno
Benigno
3
¿Por qué es útil?

Las características diseñadas manualmente a menudo están sobre

especificadas, incompletas y toman mucho tiempo para diseñar y validar
Las características aprendidas son fáciles de adaptar, rápidas de aprender
El aprendizaje profundo proporciona un marco de aprendizaje universal muy
flexible (¿casi?) Para representar información global, visual y lingüística.
Puede aprender tanto sin supervisión como supervisado
Aprendizaje eficaz de un sistema conjunto de extremo a extremo
Utiliza grandes cantidades de datos de entrenamiento

En el 2010 se inició con estas

técnicas, especialmente diseñadas
para visión y lenguaje.

4
Tendencias de uso de IA

5
CNN introducción
Pesos

Activation
functions
How do we
train?

  4 + 2 = 6 neurons (not counting

inputs)
  [3 x 4] + [4 x 2] = 20 weights
4 + 2 = 6 biases
  26 learnable parameters

6
CNN

Trabaja sólo con imágenes

La idea principal, es extraer automáticamente
las características a través de un kernel de
convolución.
Esto toma muuuuucho tiempo de cómputo

Convolutional
Input 3x3 filter
matrix [Link]

7
Operación de convolución

8
Convolution, Padding

Same padding Full padding

9
Convolución, ejemplos

10
Una vez que los filtros han pasado sobre la imagen, se genera un
mapa de características para cada filtro. Estos se toman a través
de una función de activación, que decide si cierta característica
está presente en una ubicación determinada de la imagen.
Entonces podemos hacer muchas cosas, como agregar más capas
de filtrado y crear más mapas de características, que se vuelven
cada vez más abstractos a medida que creamos una CNN más
profunda.
También podemos usar capas de agrupación para seleccionar los
valores más grandes en los mapas de entidades y usarlos como
entradas para las capas posteriores.
En teoría, cualquier tipo de operación se puede hacer en capas de
agrupación, pero en la práctica, solo se utiliza la agrupación
máxima porque queremos encontrar los valores atípicos: ¡es
cuando nuestra red ve la característica!

11
12
Solo para reiterar lo que hemos encontrado hasta
ahora. Sabemos que las MLP:
●
No escalar bien para imágenes
●
Ignora la información que aporta la posición de los píxeles y la
correlación con los vecinos.
●
No se pueden manejar las traducciones.
La idea general de CNN es adaptarse
inteligentemente a las propiedades de las imágenes:
●
La posición del píxel y el vecindario tienen significados semánticos.
●
Los elementos de interés pueden aparecer en cualquier lugar de la
imagen.

13
 Comparison of architecture for MLP and CNN.

14
Las CNN también están compuestas por capas,
pero esas capas no están completamente
conectadas:
tienen filtros, conjuntos de pesos en forma de
cubo que se aplican en toda la imagen.
Cada segmento 2D de los filtros se llaman
Kernels.
Estos filtros introducen la traslación de la
invarianza y el intercambio de parámetros.
¿Cómo se aplican? Convoluciones!

15
Ejemplo del kernel de convolución

16
Padding

Una buena pregunta para en este momento es ¿qué sucede en los

bordes de la imagen? Si aplicamos convoluciones en una imagen
normal, el resultado se reducirá en una cantidad dependiendo del
tamaño del filtro. ¿Qué hacemos si no queremos que esto suceda?
Podemos usar relleno.

17
Padding

El relleno esencialmente hace que los mapas de

características producidos por los núcleos de
filtro tengan el mismo tamaño que la imagen
original. Esto es muy útil para las CNN
profundas, ya que no queremos que la salida se
reduzca, de modo que solo nos quede una región
2x2 al final de la red sobre la cual predecir
nuestro resultado.

18
¿Cómo conectamos los filtros?

Si tenemos muchos mapas de características, ¿cómo se

combinan en nuestra red para ayudarnos a obtener nuestro
resultado final?

19
Para ser claros, cada filtro está enlazado con la totalidad del
cubo de entrada 3D, pero genera un mapa de características
2D.
●
Debido a que tenemos múltiples filtros, terminamos con una salida 3D: un mapa
de características 2D por filtro
●
La dimensión del mapa de características puede cambiar drásticamente de una
capa convolucional a la siguiente: podemos ingresar una capa con una entrada
de 32x32x16 y salir con una salida de 32x32x128 si esa capa tiene 128 filtros.
●
Convolver la imagen con un filtro produce un mapa de características que resalta
la presencia de una característica dada en la imagen.
En una capa convolucional, básicamente estamos aplicando
múltiples filtros sobre la imagen para extraer diferentes
características. Pero lo más importante, ¡estamos aprendiendo
esos filtros! Una cosa que nos falta: la no linealidad.

20
Introducción a ReLU

La no linealidad más exitosa para la CNN es la

unidad no lineal rectificada (ReLU), que combate
el problema del desvanecimiento del gradiente
que ocurre en los sigmoides. ReLU es más fácil
de calcular y genera separación (no siempre es
beneficioso).

21
Capas en una CNN

Hay tres tipos de capas en una red neuronal

convolucional:
capa convolucional,
capa de agrupación
capa totalmente conectada.
Cada una de estas capas tiene diferentes
parámetros que se pueden optimizar y realizar
una tarea diferente en los datos de entrada.

22
Convolutional layer

Las capas convolucionales son las capas donde los filtros se aplican a la imagen original,
o a otros mapas de características en una CNN profunda. Aquí es donde la mayoría de
los parámetros especificados por el usuario están en la red. Los parámetros más
importantes son el número de núcleos y el tamaño de los núcleos.

Convolutional layer

Acción Parámetros Entrada / salida

●
Aplicar filtros para ●
Número de kernels ●
Entrada: Cubo 3D
extraer ●
Tamaño de los previamente
características kernels (W y H establecido por el
●
Los filtros está solamente, D es mapa de
compuestos de definido por el cubo características
pequeños kernels de entrada ●
Salida: Cubo 3D un
●
Un bias por cada ●
La función de mapa 2D por filtro.
filtro activación
●
Aplica la función de ●
Stride
activación para cada ●
Padding
valor del mapa de ●
Tipo de
características regularización
23
Pooling layers
Las capas de agrupación (pooling) son similares a las capas convolucionales, pero
realizan una función específica como la agrupación máxima, que toma el valor máximo
en una determinada región de filtro, o la agrupación promedio, que toma el valor
promedio en una región del filtro. Normalmente se utilizan para reducir la
dimensionalidad de la red.
Pooling layers

Acción Parámetros Entrada / salida

●
Reduce la ●
Stride ●
Entrada: Cubo 3D
dimensionalidad ●
Tamaño de ventana previamente
●
Extrae el máximo establecido por el
del promedio de una mapa de
región características
●
Enfoque de ventana ●
Salida: Cubo 3D un
deslizante mapa 2D por filtro.
●
Dimensiones
espaciales reducidas

24
Fully connected layers
Las capas completamente conectadas se colocan antes de la salida del clasificador de
una CNN y se usan para aplanar los resultados antes de la clasificación. Esto es similar a
la capa de salida de un MLP.

Pooling layers

Acción Parámetros Entrada / salida

●
Agregar información ●
Número de nodos ●
Entrada: Cubo 3D
del mapa final de ●
Función de aplanado
características activación: ●
Salida: cubo 3D, un
●
Generar la usualmente cambia, mapa 2D por cada
clasificación final dependiendo del rol filtro.
en la capa. Si agrega
información usar
ReLU. Si es la capa
final, usar SoftMax.

25
Arquitectura estándar de una CNN

26
¿Qué aprenden las capas CNN?
●
Cada capa de CNN aprende filtros de complejidad creciente.
●
Las primeras capas aprenden filtros de detección de
características básicas: bordes, esquinas, etc.
●
Las capas intermedias aprenden filtros que detectan partes
de objetos. Para las caras, pueden aprender a responder a los
ojos, narices, etc.
●
Las últimas capas tienen representaciones más altas:
aprenden a reconocer objetos completos, en diferentes
formas y posiciones.

27
28
Dropout

El Dropout es una técnica de regularización para

modelos de redes neuronales propuesta por
Srivastava, et al. en su artículo de 2014 Dropout: A
Simple Way to Prevent Neural Networks from
Overfitting (descargue el PDF).
El Dropout es una técnica en la que ciertas
neuronas seleccionadas al azar se ignoran durante
el entrenamiento. Se "abandonan" al azar. Esto
significa que su contribución a la activación de las
neuronas aguas abajo se elimina temporalmente en
el paso feedforward y las actualizaciones de peso
no se aplican a la neurona en el paso backward.

29
Dropout

A medida que una red neuronal aprende, los pesos de las neuronas se
asientan en su contexto dentro de la red. Los pesos de las neuronas
están ajustados para características específicas que proporcionan cierta
especialización. Las neuronas vecinas vuelven a confiar en esta
especialización, que si se lo realiza constantemente, puede dar como
resultado un modelo frágil demasiado especializado para los datos de
entrenamiento. Esta dependencia del contexto de una neurona durante
el entrenamiento se refiere a complejas adaptaciones.
Si las neuronas se eliminan aleatoriamente de la red durante el
entrenamiento, otras neuronas tendrán que intervenir y manejar la
representación requerida para hacer predicciones para las neuronas
faltantes. Se cree que esto da como resultado que la red aprenda
múltiples representaciones internas independientes.
El efecto es que la red se vuelve menos sensible a los pesos específicos
de las neuronas. Esto a su vez da como resultado una red que es capaz
de una mejor generalización y es menos probable que sobreajuste
(overfit) los datos de entrenamiento.

30
Dropout

Durante el entrenamiento, un cierto número de salidas de capa son ignoradas o "abandonadas" al

azar. Esto tiene el efecto de hacer que la capa se vea y se trate como una capa con un número
diferente de nodos y conectividad con la capa anterior. En efecto, cada actualización de una capa
durante el entrenamiento se realiza con una "vista" diferente de la capa configurada.
Al abandonar una unidad, nos referimos a eliminarla temporalmente de la red, junto con todas sus
conexiones entrantes y salientes.
- Abandono: una forma simple de evitar el sobreajuste de las redes neuronales, 2014.
El dropout tiene el efecto de hacer que el proceso de capacitación sea ruidoso, forzando a los nodos
dentro de una capa a asumir más o menos responsabilidad de las entradas.
Esta conceptualización sugiere que tal vez las situaciones de ruptura de deserción en las que las
capas de red se adaptan conjuntamente para corregir los errores de las capas anteriores, lo que a su
vez hace que el modelo sea más robusto.
... las unidades pueden cambiar de manera que arreglen los errores de las otras unidades. Esto puede conducir a complejas
adaptaciones. Esto a su vez conduce a un sobreajuste porque estas co-adaptaciones no se generalizan a datos invisibles. [...]
- Dropout: una forma simple de evitar el sobreajuste de las redes neuronales, 2014.
El dropout simula una activación dispersa de una capa dada, lo que, a su vez, anima a la red a
aprender una representación dispersa como efecto secundario. Como tal, puede usarse como una
alternativa a la regularización de actividades para alentar representaciones dispersas en modelos de
autoencoder.
Debido a que las salidas de una capa bajo Dropout se submuestrean aleatoriamente, tiene el efecto
de reducir la capacidad o debilitar la red durante el entrenamiento. Como tal, una red más amplia, p.
Es posible que se requieran más nodos cuando se usa el dropout.

31
3D visualization of CNN

[Link]

32
 ¿qué hace la convolución?

Generalmente, los patrones importantes que

hacen la diferencia están en pequeñas
regiones de la imagen

Can represent a small region with fewer parameters

“beak” detector
Algunos patrones aparecen en diferentes lugares
de la imagen, y pueden ser comprimidos!
Los kernels de convolución son pequeños
detectores que se mueven al rededor de toda la
imagen.

“upper-left beak”
detector

They can be compressed

to the same parameters.

“middle beak”
detector
La capa convolucional
Una CNN es una red neuronal con algunas capas convolucionales.
(y algunas otras capas). Una capa convolucional tiene un número
de filtros que hace operación convolucional.

Beak detector

A filter
 CNN
Primero,se normalizan los datos.!! y no olvidar el preprocesamiento previo.

Se aplica la convolución: 3x3, stride=1

Convolución k=3x3

Max-Pooling 2x2
Número de parámetros: Ejemplo

Imagen de entrada= 28x28 px = 784 neuronas

1º convolución con 32 kernels, se tienen 32
imágenes lo que da 28x28x32 = 25088 neuronas
Subsampling: max-pooling 2x2
Se obtendría una imagen reducida a la mitad:
14x14x32 = 6272 neuronas
Esto en la primera capa de convolución. Luego
continúa con mas capas ocultas.

En la etapa de backpropagation, se ajusta el valor

de los pesos de los distintos kernels de forma
individual:
1º convolución: 3x3x32 = 288 parámetros
 1 -1 -1
Convolution -1 1 -1 Filter 1
-1 -1 1
stride=1

1 0 0 0 0 1 Dot
product
0 1 0 0 1 0
3 -1
0 0 1 1 0 0

1 0 0 0 1 0

0 1 0 0 1 0

0 0 1 0 1 0

6 x 6 image
 1 -1 -1
Convolution -1 1 -1 Filter 1
-1 -1 1
If stride=2

1 0 0 0 0 1

0 1 0 0 1 0
3 -3
0 0 1 1 0 0

1 0 0 0 1 0

0 1 0 0 1 0

0 0 1 0 1 0

6 x 6 image
 1 -1 -1
Convolution -1 1 -1 Filter 1
-1 -1 1
stride=1

1 0 0 0 0 1

0 1 0 0 1 0
3 -1 -3 -1
0 0 1 1 0 0

1 0 0 0 1 0 -3 1 0 -3
0 1 0 0 1 0

0 0 1 0 1 0 -3 -3 0 1

6 x 6 image 3 -2 -2 -1
 -1 1 -1

Convolution -1 1 -1 Filter 2
-1 1 -1

stride=1
Repeat this for each filter
1 0 0 0 0 1

0 1 0 0 1 0
3 -1 -3 -1
0 0 1 1 0 0 -1 -1 -1 -1

1 0 0 0 1 0 -3 1 0 -3
-1 -1 -2 1
0 1 0 0 1 0 Feature
0 0 1 0 1 0 -3 -3 Map0 1
-1 -1 -2 1

6 x 6 image 3 -2 -2 -1
-1 0 -4 3

Two 4 x 4 images
Forming 2 x 4 x 4 matrix
 Color image: RGB 3 channels
1 -1 -1 -1 1 -1
1 -1 -1 -1 1 -1
1 -1 -1 -1 1 -1
-1 1 -1 -1 1 -1
-1 1 -1 -1 1 -1
-1 1 -1 Filter 1 -1 1 -1 Filter 2
-1 -1 1 -1 1 -1
-1 -1 1 -1 1 -1
-1 -1 1 -1 1 -1
Color image
1 0 0 0 0 1
1 0 0 0 0 1
0 11 00 00 01 00 1
0 1 0 0 1 0
0 00 11 01 00 10 0
0 0 1 1 0 0
1 00 00 10 11 00 0
1 0 0 0 1 0
0 11 00 00 01 10 0
0 1 0 0 1 0
0 00 11 00 01 10 0
0 0 1 0 1 0
0 0 1 0 1 0
Convolution v.s. Fully Connected

1 0 0 0 0 1 1 -1 -1 -1 1 -1
0 1 0 0 1 0 -1 1 -1 -1 1 -1

0 0 1 1 0 0 -1 -1 1 -1 1 -1

1 0 0 0 1 0
0 1 0 0 1 0
0 0 1 0 1 0
convolution
image

x1
1 0 0 0 0 1
0 1 0 0 1 0
x2
Fully- 0 0 1 1 0 0

connected 1 0 0 0 1 0
…
…

…
…
0 1 0 0 1 0
0 0 1 0 1 0

x36
1 -1 -1 1 1
Filter 1
-1 1 -1 2 0

-1 -1 1 3 0
4: 3
0
1 0 0 0 0 1

…
0 1 0 0 1 0 0
0 0 1 1 0 0 8 1
1 0 0 0 1 0 9 0
0 1 0 0 1 0 10:
0

…
0 0 1 0 1 0
13 0
6 x 6 image
14 0
Considere la 15 1 Only connect to 9
inputs, not fully
imagen como un 16 1 connected
vector unitario
…
The whole CNN

cat dog ……
Convolution

Max Pooling
Can repeat
Fully Connected many times
Feedforward network
Convolution

Max Pooling

Flattened
Max Pooling
1 -1 -1 -1 1 -1

-1 1 -1 Filter 1 -1 1 -1 Filter 2
-1 -1 1 -1 1 -1

3 -1 -3 -1 -1 -1 -1 -1

-3 1 0 -3 -1 -1 -2 1

-3 -3 0 1 -1 -1 -2 1

3 -2 -2 -1 -1 0 -4 3
 Why Pooling

Subsampling pixels no cambian el objeto

o imagen final
bird
bird

Subsampling

We can subsample the pixels to make image smaller

Se reduce el número de parámetros: lo mas importante!

 A CNN compresses a fully connected
network in two ways:

Reducing number of connections

Shared weights on the edges
Max pooling further reduces the complexity
 Only modified the network structure and
CNN in Keras input format (vector -> 3-D tensor)

input

Convolution
1 -1 -1
-1 1 -1
There are 25
-1 1 -1
-1 1 -1 … 3x3 filters.
-1 -1 1
-1 1 -1 … Max Pooling
Input_shape = ( 28 , 28 , 1)

28 x 28 pixels 1: black/white, 3: RGB Convolution

3 -1 3 Max Pooling

-3 1
 Only modified the network structure and
CNN in Keras input format (vector -> 3-D array)

Input
1 x 28 x 28

Convolution
How many parameters
for each filter? 9 25 x 26 x 26

Max Pooling
25 x 13 x 13

Convolution
How many parameters 225=
for each filter? 50 x 11 x 11
25x9
Max Pooling
50 x 5 x 5
 Only modified the network structure and
CNN in Keras input format (vector -> 3-D array)

Input
1 x 28 x 28
Output
Convolution

25 x 26 x 26

Fully connected Max Pooling

feedforward network
25 x 13 x 13

Convolution

50 x 11 x 11

Max Pooling
1250 50 x 5 x 5
Flattened
Deep learning architectures

57
CNN architectures

Overview of
architectures until
2018. Source:
Simone Bianco et al.
2019

58
CNN architectures

59 Source: Papers with Code - Imagenet Benchmark

Tipos de escalado de la arquitectura

60
Macro arquitecturas CNN
Convolutional Neural Networks

VGG

LeNet

AlexNet DenseNet

Inception
ResNet
Desarrollo de las arquitecturas de DL

2010 concurso de reconocimiento de imágenes

Imagenet.
ImageNet es una enorme base de datos con más
de 14 millones de imágenes etiquetadas en más
de 1000 clases.
Los datos fueron recogidos y etiquetados desde
la web por humanos (liderada por Fei Fei Li -
2010)
Lenet (Lecun et. al. 1998)

Ideas principales
Convolución, capa de activación ‘TanH’
Spatial subsampling
Lenet (Lecun et. al. 1998)

# implementación en Keras

model = [Link]()
[Link](layers.Conv2D(filters=6, kernel_size=(3, 3),
activation='relu', input_shape=(32,32,1)))
[Link](layers.AveragePooling2D())
[Link](layers.Conv2D(filters=16, kernel_size=(3, 3),
activation='relu'))
[Link](layers.AveragePooling2D())
[Link]([Link]())
[Link]([Link](units=120, activation='relu'))
[Link]([Link](units=84, activation='relu'))
[Link]([Link](units=10, activation = 'softmax'))
Alexnet (Alex Krizhevsky et al 2012)

5 capas convolucionales y 3 capas

densas
Main ideas
Función de activación: Relu
Kernel de con. De 11x11 en la 1ra
Dropout
capa, 5x5 en la 2da y 3x3 en la 3ra.
Local response normalization, overlapping pooling Max-pooling después de la 1ra, 4ta
Data augmentation y 5ta capa
Multiples GPUs
Alexnet (Krizhevsky et al 2012)

model=[Link]([
[Link].Conv2D(filters=128, kernel_size=(11,11), strides=(4,4), activation='relu',
input_shape=(64,64,3)),
[Link](),
[Link].MaxPool2D(pool_size=(2,2)),
[Link].Conv2D(filters=256, kernel_size=(5,5), strides=(1,1), activation='relu', padding="same"),
[Link](),
[Link].MaxPool2D(pool_size=(3,3)),
[Link].Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), activation='relu', padding="same"),
[Link](),
[Link].Conv2D(filters=256, kernel_size=(1,1), strides=(1,1), activation='relu', padding="same"),
[Link](),
[Link].Conv2D(filters=256, kernel_size=(1,1), strides=(1,1), activation='relu', padding="same"),
[Link](),
[Link].MaxPool2D(pool_size=(2,2)),
[Link](),
[Link](1024,activation='relu'),
[Link](0.5),
[Link](1024,activation='relu'),
[Link](0.5),
[Link](10,activation='softmax') ])
VGG16 -19 (Zisserman et al 2014)

Idea principal
16 capas de profundidad, 13 capas convolucionales, kernels de 3x3 (mas pequeño)
Red de convolución mas profunda
VGG 16

from [Link] import Input, Conv2D, MaxPooling2D

from [Link] import Dense, Flatten conv8 = Conv2D(filters=512, kernel_size=(3,3),
from [Link] import Model padding="same", activation="relu")(pool3)
conv9 = Conv2D(filters=512, kernel_size=(3,3),
_input = Input((224,224,1)) padding="same", activation="relu")(conv8)
conv10 = Conv2D(filters=512, kernel_size=(3,3),
padding="same", activation="relu")(conv9)
conv1 = Conv2D(filters=64, kernel_size=(3,3), padding="same",
activation="relu")(_input) pool4 = MaxPooling2D((2, 2))(conv10)
conv2 = Conv2D(filters=64, kernel_size=(3,3), padding="same",
activation="relu")(conv1)
conv11 = Conv2D(filters=512, kernel_size=(3,3),
pool1 = MaxPooling2D((2, 2))(conv2) padding="same", activation="relu")(pool4)
conv12 = Conv2D(filters=512, kernel_size=(3,3),
conv3 = Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")(conv11)
padding="same", activation="relu")(pool1)
conv13 = Conv2D(filters=512, kernel_size=(3,3),
conv4 = Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")(conv12)
padding="same", activation="relu")(conv3)
pool5 = MaxPooling2D((2, 2))(conv13)
pool2 = MaxPooling2D((2, 2))(conv4)

conv5 = Conv2D(filters=256, kernel_size=(3,3), flat = Flatten()(pool5)

padding="same", activation="relu")(pool2) dense1 = Dense(4096, activation="relu")(flat)
conv6 = Conv2D(filters=256, kernel_size=(3,3), dense2 = Dense(4096, activation="relu")(dense1)
padding="same", activation="relu")(conv5)
output = Dense(1000, activation="softmax")(dense2)
conv7 = Conv2D(filters=256, kernel_size=(3,3),
padding="same", activation="relu")(conv6)
pool3 = MaxPooling2D((2, 2))(conv7) vgg16_model = Model(inputs=_input, outputs=output)
Comparación de arquitecturas hasta
2014:

La diferencia principal
radica en la
profundidad de la red a
través del uso de
kernels de convolución
pequeños.
Se aumentan las no
linealidades en las
imágenes
ResNet 50, 101 y 152 (He et al 2016)

Main Idea
Skip connections promueve la propagación del gradiente
Usa las capas de la red para ajustar y aprender de los residuos de la convolución, en vez de las imágenes.
Esto permite entrenar redes mas profundas.
 ResNet (He et al 2016)
from tensorflow import Tensor inputs = Input(shape=(32, 32, 3))
from [Link] import Input, Conv2D, ReLU, num_filters = 64
BatchNormalization,\
Add, AveragePooling2D, Flatten, Dense t = BatchNormalization()(inputs)
from [Link] import Model t = Conv2D(kernel_size=3,
def relu_bn(inputs: Tensor) -> Tensor: strides=1,
relu = ReLU()(inputs) filters=num_filters,
bn = BatchNormalization()(relu)
padding="same")(t)
return bn
t = relu_bn(t)
def residual_block(x: Tensor, downsample: bool, filters: int,
kernel_size: int = 3) -> Tensor: num_blocks_list = [2, 5, 5, 2]
y = Conv2D(kernel_size=kernel_size, for i in range(len(num_blocks_list)):
strides= (1 if not downsample else 2),
num_blocks = num_blocks_list[i]
filters=filters,
for j in range(num_blocks):
padding="same")(x)
y = relu_bn(y) t = residual_block(t, downsample=(j==0 and i!
=0), filters=num_filters)
y = Conv2D(kernel_size=kernel_size,
strides=1, num_filters *= 2
filters=filters, t = AveragePooling2D(4)(t)
padding="same")(y) t = Flatten()(t)
if downsample: outputs = Dense(10, activation='softmax')(t)
x = Conv2D(kernel_size=1,
model = Model(inputs, outputs)
strides=2,
filters=filters,
[Link](
padding="same")(x) optimizer='adam',
out = Add()([x, y]) loss='sparse_categorical_crossentropy',
out = relu_bn(out) metrics=['accuracy']
return out
)
def create_res_net():
return model
DenseNet(Huang et al 2017)

Main idea
Dense connectivity: crea una ruta corta en la red y fomenta la reutilización de
las características
DenseNet(Huang et al 2017)

Concatenación de capas durante la

propagación hacia adelante
Micro innovaciones en
arquitecturas CNN
Convolución de grupo

Idea principal
Dividir las convoluciones en múltiples grupos
Deep-wise separable Convolution (DSC)

Idea principal
Dividir las convoluciones en múltiples grupos, y
cada grupo tiene un diferente canal
U-net (O. Ronneberger et. al. 2015)

Generalmente
usada para
segmentación de
imágenes
U-net (O. Ronneberger et. al. 2015)

Consta de dos «vías». La primera es la de la

contracción, también llamada codificador. Se
utiliza para captar el contexto de una imagen.
La segunda vía es la de la de expansión simétrica,
también llamada decodificación, que permite una
localización precisa de los puntos de interés
captados durante la codificación, mediante la
convolución transpuesta
●
En la etapa de decodificación se realiza la
deconvolución para restaurar los objetos de
interés captados
U-net (O. Ronneberger et. al. 2015)

Esta red sigue la arquitectura de reloj de arena. Primero aplica

convoluciones a la imagen de entrada, comprimiendo la
información y detectando las diferentes características en la
imagen, para después recuperar el tamaño original con el uso
de deconvoluciones.
En la primera fase se comprime la información (fase Down)
para posteriormente volver a restaurar la resolución original
(fase Up). Estas deconvoluciones se ven favorecidas por la
información aportada al concatenar los "features maps" de
cada uno de los niveles.
●
En la etapa de decodificación se realiza la deconvolución,
que es la operación inversa a una convolución, y por tanto
los filtros que son aprendidos se usan para restaurar la info
comprimida durante la etapa previa
Image segmentation

82
Image segmentation architectures

U-Net

83
 U-Net
from [Link] import Model
from [Link] import Input, concatenate, Conv2D, MaxPooling2D, Activation, UpSampling2D, BatchNormalization
from [Link] import RMSprop
from [Link] import bce_dice_loss, dice_loss, weighted_bce_dice_loss, weighted_dice_loss,
def get_unet_128(input_shape=(128, 128, 3), center = Conv2D(1024, (3, 3), padding='same') up2 = UpSampling2D((2, 2))(up3)
num_classes=1): (down4_pool) up2 = concatenate([down2, up2], axis=3)
inputs = Input(shape=input_shape) center = BatchNormalization()(center) up2 = Conv2D(128, (3, 3), padding='same')(up2)
# 128
center = Activation('relu')(center) up2 = BatchNormalization()(up2)
down1 = Conv2D(64, (3, 3), padding='same')(inputs) center = Conv2D(1024, (3, 3), padding='same')(center) up2 = Activation('relu')(up2)
down1 = BatchNormalization()(down1) center = BatchNormalization()(center) up2 = Conv2D(128, (3, 3), padding='same')(up2)
down1 = Activation('relu')(down1) center = Activation('relu')(center) up2 = BatchNormalization()(up2)
down1 = Conv2D(64, (3, 3), padding='same')(down1)
# center up2 = Activation('relu')(up2)
down1 = BatchNormalization()(down1)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1) up4 = UpSampling2D((2, 2))(center) up2 = BatchNormalization()(up2)
# 64 up4 = Conv2D(512, (3, 3), padding='same')(up4) up2 = Activation('relu')(up2)
up4 = BatchNormalization()(up4) # 64
down2 = Conv2D(128, (3, 3), padding='same')(down1_pool)
up4 = Activation('relu')(up4)
down2 = BatchNormalization()(down2)
up4 = Conv2D(512, (3, 3), padding='same')(up4) up1 = UpSampling2D((2, 2))(up2)
down2 = Activation('relu')(down2)
down2 = Conv2D(128, (3, 3), padding='same')(down2) up4 = BatchNormalization()(up4) up1 = concatenate([down1, up1], axis=3)
down2 = BatchNormalization()(down2) up4 = Activation('relu')(up4) up1 = Conv2D(64, (3, 3), padding='same')(up1)
down2 = Activation('relu')(down2)
up4 = Conv2D(512, (3, 3), padding='same')(up4) up1 = BatchNormalization()(up1)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2) up1 = Activation('relu')(up1)
up4 = BatchNormalization()(up4)
# 32
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up4 = Activation('relu')(up4)
up1 = BatchNormalization()(up1)
down3 = Conv2D(256, (3, 3), padding='same')(down2_pool) # 16
down3 = BatchNormalization()(down3) up1 = Activation('relu')(up1)
down3 = Activation('relu')(down3) up1 = Conv2D(64, (3, 3), padding='same')(up1)
up3 = UpSampling2D((2, 2))(up4)
down3 = Conv2D(256, (3, 3), padding='same')(down3) up1 = BatchNormalization()(up1)
down3 = BatchNormalization()(down3) up3 = concatenate([down3, up3], axis=3)
up1 = Activation('relu')(up1)
down3 = Activation('relu')(down3) up3 = Conv2D(256, (3, 3), padding='same')(up3)
# 128
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3) up3 = BatchNormalization()(up3)
# 16
up3 = Activation('relu')(up3)
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up1)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
down4 = Conv2D(512, (3, 3), padding='same')(down3_pool)
down4 = BatchNormalization()(down4) up3 = BatchNormalization()(up3)
model = Model(inputs=inputs, outputs=classify)
down4 = Activation('relu')(down4) up3 = Activation('relu')(up3)
down4 = Conv2D(512, (3, 3), padding='same')(down4) up3 = Conv2D(256, (3, 3), padding='same')(up3) [Link](optimizer=RMSprop(lr=0.0001), loss=bce_dice_loss,
down4 = BatchNormalization()(down4)
up3 = BatchNormalization()(up3) metrics=[dice_coeff])
down4 = Activation('relu')(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
up3 = Activation('relu')(up3)
#8 # 32 return modelClick to add Text

84
Otras arquitecturas para segmentación
FastFCN —Fast Fully-connected network

In this architecture, a Joint Pyramid Upsampling(JPU) module is

used to replace dilated convolutions since they consume a lot of
memory and time. It uses a fully-connected network at its core
while applying JPU for upsampling. JPU upsamples the low-
resolution feature maps to high-resolution feature maps

85 Huikai Wu [Link] 2019 “FastFCN: Rethinking Dilated Convolution

in the Backbone for Semantic Segmentation”
Otras arquitecturas para segmentación
Mask R-CNN

En esta arquitectura, los objetos se clasifican y localizan mediante un cuadro

delimitador y una segmentación semántica que clasifica cada píxel en un
conjunto de categorías. Cada región de interés tiene una máscara de
segmentación. Se produce una etiqueta de clase y un cuadro delimitador como
resultado final. La arquitectura es una extensión de Faster R-CNN. Faster R-CNN
se compone de una red convolucional profunda que propone las regiones y un
detector que utiliza las regiones.

86 Kaiming He et. al 2017 “Mask R-CNN” | Source

Desarrollos para mejorar el rendimiento
Ensemble learning

• Ensemble learning consiste en entrenar múltiples clasificadores y combinar sus

predicciones
 Ensemble learning generalmente supera los clasificadores individuales
 Bagging (bootstrap aggregating)
o Randomly draw subsets from the training set (i.e., bootstrap samples)
o Train separate classifiers on each subset of the training set
o Perform classification based on the average vote of all classifiers
 Boosting
o Train a classifier, and apply weights on the training set (apply higher weights on
misclassified examples, focus on “hard examples”)
o Train new classifier, reweight training set according to prediction error
o Repeat
o Perform classification based on weighted vote of the classifiers
Consideraciones adicionales:
Deep vs Shallow Networks
Deep vs Shallow Networks

• Deeper networks perform better than shallow networks

 But only up to some limit: after a certain number of layers, the performance of deeper
networks plateaus

output

Shallow Deep
NN NN

……

x1 x2 …… xN

input
Slide credit: Hung-yi Lee – Deep Learning Tutorial
Transformers para procesamiento de
imágenes

Actualmente es el estado del arte para clasificación y

segmentación de imágenes.
Es una arquitectura de redes neuronales que se
propuso por primera vez (Vaswani et al. En 2017) para
el procesamiento de lenguaje natural (NLP)

Transformer es el primer modelo de

*transducción que se basa completamente en la
auto-atención para calcular representaciones de
su entrada y salida sin utilizar RNN alineados en
secuencia o convolución.

* Transducción significa en la conversión de una

secuencia en otra secuencia nueva
Transformers: Arquitectura

El Transformer se basa en un Encoder y un

Decoder.
La idea clave aquí es que se utiliza el encoder
para analizar el contexto de la secuencia de
entrada y el decoder es el encargado de generar
la secuencia del output a partir de este contexto
Transformers: Arquitectura

Embedding de la imagen:
●
Para que el encoder y el decoder puedan trabajar
bien, es necesario realizar un embedding de la
imagen. Embedding, significa simplemente una
representación vectorial de las imágenes. La magia
de esta transformación a vectores, es que
conseguimos una representación vectorial de las
imágenes, y que, además, las características
importantes de la imagen estarán cerca en dicho
espacio vectorial.
Transformers: arquitectura

0 1 2... ..7 8

16x16x16 patches
Transformers: arquitectura

El mecanismo toma 3 valores de entrada:

●
Q: se trata de la query que representa el
vector de un patch de la imagen.
●
K: las keys que son todos los demás patchs
de la secuencia de imágenes.
●
V: el valor vectorial de la imagen que se
procesa en dicho punto temporal.

Realizar el producto escalar de Q y K

(transpuesto) significa calcular la proyección
ortogonal de Q en K. O sea, intentar estimar
la alineación de los vectores y devolver un
peso para cada patch de la imagen.
Transformer
Encoder layer
Transformers: encoder
En esta capa, la imagen entra dividida en tokens (patch) y se
transforma en un vector numérico generalmente de
dimensión 256 o 1024.
Se puede pensar como una tabla de valores donde el modelo
“busca” cual es el vector asociado a un determinado token,
¿de donde saca los valores?: se ajustarán durante el proceso
de entrenamiento del transformer. Sin embargo un vector de
embedding es algo parecido a:
El positional encoding no es más que otra matriz que indica la posición de cada
token en la imagen.

ecuación 1 para la matriz de posiciones ecuación 2 para la matriz de posiciones

●
Q: se trata de la query que representa
el vector de un token de la imagen.
●
K: las keys que son todos los demás
tokens de la secuencia de imágenes.
●
V: el valor vectorial de la imagen que
se procesa en dicho punto temporal.
De esta forma en el proceso de entrenamiento, el
transformer va consiguiendo como se relaciona cada
pixel con sus vecinos y que peso tiene cada una de
esas relaciones.

Se puede agregar tantos encoders como se desee,

donde la entrada del próximo encoder es la salida del
encoder anterior, tal como se muestra en la figura
Transformer: arquitecturas mixtas

CNN transformers:
Métricas

El rendimiento del algoritmo es realizado al

comparar las etiquetas:

107
Matriz de confusión

108
Accuracy

TP+TN 50+100
Accuracy = Accuracy = =0.91=91 %
Total (TP +TN + FN + FP) 165

109
Sensitivity o Recall

110
Specificity

111
Dice coeficient (para imágenes)

112
Trabajos realizados

113
WMH segmentation (Miccai challenge)

114
115
116
117
118