glom pytorch

GLOM – Pytorch

Eine Implementierung von Glom, der neuen Idee von Geoffrey Hinton, die Konzepte aus neuronalen Feldern, Top-Down-Bottom-Up-Verarbeitung und Aufmerksamkeit (Konsens zwischen Spalten) integriert, um entstehende Teil-Ganze-Hierarchien aus Daten zu lernen.

Das Video von Yannic Kilcher hat mir maßgeblich geholfen, dieses Papier zu verstehen

Installieren

$ pip install glom-pytorch

Verwendung

 import torch
from glom_pytorch import Glom

model = Glom (
    dim = 512 ,         # dimension
    levels = 6 ,        # number of levels
    image_size = 224 ,  # image size
    patch_size = 14    # patch size
)

img = torch . randn ( 1 , 3 , 224 , 224 )
levels = model ( img , iters = 12 ) # (1, 256, 6, 512) - (batch - patches - levels - dimension)

Übergeben Sie das Schlüsselwortargument return_all = True bei „forward“, und Sie erhalten alle Spalten- und Ebenenzustände pro Iteration zurück (einschließlich des Anfangszustands, der Anzahl der Iterationen + 1). Sie können dies dann verwenden, um etwaige Verluste zu jedem beliebigen Zeitpunkt mit den Ausgängen beliebiger Ebenen zu verknüpfen.

Außerdem erhalten Sie Zugriff auf alle Ebenendaten über die Iterationen hinweg für die Clusterbildung, anhand derer Sie nach den theoretisierten Inseln in der Arbeit suchen können.

 import torch
from glom_pytorch import Glom

model = Glom (
    dim = 512 ,         # dimension
    levels = 6 ,        # number of levels
    image_size = 224 ,  # image size
    patch_size = 14    # patch size
)

img = torch . randn ( 1 , 3 , 224 , 224 )
all_levels = model ( img , iters = 12 , return_all = True ) # (13, 1, 256, 6, 512) - (time, batch, patches, levels, dimension)

# get the top level outputs after iteration 6
top_level_output = all_levels [ 7 , :, :, - 1 ] # (1, 256, 512) - (batch, patches, dimension)

Selbstüberwachtes Lernen entrauschen, um Emergenz zu fördern, wie von Hinton beschrieben

 import torch
import torch . nn . functional as F
from torch import nn
from einops . layers . torch import Rearrange

from glom_pytorch import Glom

model = Glom (
    dim = 512 ,         # dimension
    levels = 6 ,        # number of levels
    image_size = 224 ,  # image size
    patch_size = 14    # patch size
)

img = torch . randn ( 1 , 3 , 224 , 224 )
noised_img = img + torch . randn_like ( img )

all_levels = model ( noised_img , return_all = True )

patches_to_images = nn . Sequential (
    nn . Linear ( 512 , 14 * 14 * 3 ),
    Rearrange ( 'b (h w) (p1 p2 c) -> b c (h p1) (w p2)' , p1 = 14 , p2 = 14 , h = ( 224 // 14 ))
)

top_level = all_levels [ 7 , :, :, - 1 ]  # get the top level embeddings after iteration 6
recon_img = patches_to_images ( top_level )

# do self-supervised learning by denoising

loss = F . mse_loss ( img , recon_img )
loss . backward ()

Sie können den Status der Spalte und der Ebenen zurück in das Modell übergeben, um dort fortzufahren, wo Sie aufgehört haben (vielleicht, wenn Sie aufeinanderfolgende Bilder eines langsamen Videos verarbeiten, wie im Artikel erwähnt).

 import torch
from glom_pytorch import Glom

model = Glom (
    dim = 512 ,
    levels = 6 ,
    image_size = 224 ,
    patch_size = 14
)

img1 = torch . randn ( 1 , 3 , 224 , 224 )
img2 = torch . randn ( 1 , 3 , 224 , 224 )
img3 = torch . randn ( 1 , 3 , 224 , 224 )

levels1 = model ( img1 , iters = 12 )                   # image 1 for 12 iterations
levels2 = model ( img2 , levels = levels1 , iters = 10 ) # image 2 for 10 iteratoins
levels3 = model ( img3 , levels = levels2 , iters = 6 )  # image 3 for 6 iterations

Anerkennung

Vielen Dank an Cfoster0 für die Überprüfung des Codes

Todo

• Kontrastive/Konsistenz-Regularisierung der obersten Ebenen

Zitate

 @misc { hinton2021represent ,
    title   = { How to represent part-whole hierarchies in a neural network } , 
    author  = { Geoffrey Hinton } ,
    year    = { 2021 } ,
    eprint  = { 2102.12627 } ,
    archivePrefix = { arXiv } ,
    primaryClass = { cs.CV }
}