Modelos multientrada

Aprendizaje profundo intermedio con PyTorch

Michal Oleszak

Machine Learning Engineer

¿Por qué múltiples entradas?

Uso de más información

Esquema de un modelo que toma dos imágenes de coches como entradas y produce una salida.

Modelos multimodales

Esquema de un modelo que toma como entradas una imagen y un fragmento de texto y produce un texto como salida.

Aprendizaje métrico

Esquema de un modelo que toma imágenes faciales como entradas y predice si son iguales.

Aprendizaje autodirigido

Esquema de un modelo que toma como entradas dos versiones aumentadas de las mismas imágenes y aprende que son iguales.

Conjunto de datos Omniglot

Una muestra de imágenes del conjunto de datos Omniglot.

¹ Lake, B. M., Salakhutdinov, R., and Tenenbaum, J. B. (2015). Aprendizaje de conceptos a nivel humano mediante la inducción probabilística de programas. Science, 350(6266), 1332-1338.

Clasificación de los personajes

Esquema del modelo: las imágenes de los caracteres se pasan a una red neuronal.

Clasificación de los personajes

Esquema del modelo: se pasa un vector alfabético one-hot a una red neuronal.

Clasificación de los personajes

Esquema del modelo: se combinan las incrustaciones de caracteres y del alfabeto.

Clasificación de los personajes

Esquema del modelo: a partir de incrustaciones combinadas, un clasificador predice el carácter.

Conjunto de datos de dos entradas

from PIL import Image

class OmniglotDataset(Dataset):

    def __init__(self, transform, samples):
        self.transform = transform
        self.samples = samples


    def __len__(self):
        return len(self.samples)


    def __getitem__(self, idx):
        img_path, alphabet, label = self.samples[idx]
        img = Image.open(img_path).convert('L')
        img = self.transform(img)
        return img, alphabet, label

Asignar muestras y transformaciones

print(samples[0])

[(
  'omniglot_train/.../0459_14.png',
   array([1., 0., 0., ..., 0., 0., 0.]),
   0
 )]

Implementar __len__()
Cargar y transformar imagen
Devuelve ambas entradas y la etiqueta.

Concatenación de tensores

x = torch.tensor([
  [1, 2, 3],
])

y = torch.tensor([
  [4, 5, 6],
])

Concatenación a lo largo del eje 0

torch.cat((x, y), dim=0)

[[1, 2, 3],
 [4, 5, 6]]

Concatenación a lo largo del eje 1

torch.cat((x, y), dim=1)

[[1, 2, 3, 4, 5, 6]]

Arquitectura de dos entradas

class Net(nn.Module):
    def __init__(self):
        super().__init__()

        self.image_layer = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, padding=1),
            nn.MaxPool2d(kernel_size=2),
            nn.ELU(),
            nn.Flatten(),
            nn.Linear(16*32*32, 128)
        )

        self.alphabet_layer = nn.Sequential(
            nn.Linear(30, 8),
            nn.ELU(),
        )

        self.classifier = nn.Sequential(
            nn.Linear(128 + 8, 964), 
        )

Define la capa de procesamiento de imágenes.
Define la capa de procesamiento del alfabeto.
Define la capa clasificadora.

Arquitectura de dos entradas

def forward(self, x_image, x_alphabet):

    x_image = self.image_layer(x_image)

    x_alphabet = self.alphabet_layer(x_alphabet)

    x = torch.cat((x_image, x_alphabet), dim=1)

    return self.classifier(x)

Pasar imagen a través de la capa de imagen
Pasar el alfabeto a través de la capa alfabética
Concatena las salidas de imagen y alfabeto
Pasa el resultado por el clasificador.

Bucle de entrenamiento

net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

for epoch in range(10):
    for img, alpha, labels in dataloader_train:
        optimizer.zero_grad()
        outputs = net(img, alpha)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

Los datos de entrenamiento constan de tres elementos:
- Imagen:
- Vector alfabético
- Etiquetas
Pasamos las imágenes modelo y los alfabetos.

¡Vamos a practicar!

Aprendizaje profundo intermedio con PyTorch