[PYTHON] Die Beziehung zwischen Gehirnforschung und unbeaufsichtigtem Lernen. Maximieren Sie die Informationsmenge MNIST: Google Colabratory (PyTorch)
In diesem Artikel werde ich die Implementierung von IIC erläutern, die mit MNIST eine hohe Leistung beim unbeaufsichtigten Lernen, in der Gehirnforschung und beim unbeaufsichtigten Lernen bietet.
Die in diesem Artikel behandelten Artikel sind Invariant Information Clustering for Unsupervised Image Classification and Segmentation ist.
In diesem Artikel verwenden wir einen Index mit dem Namen ** Gegenseitiger Informationsbetrag **, um handgeschriebene numerische Bilder durch Clustering von unbeaufsichtigtem Lernen zu klassifizieren.
Es heißt IIC (Invariant Information Clustering).
In diesem Artikel werde ich Gehirnforschung und unbeaufsichtigtes Lernen, IIC-Punkte und Implementierungsbeispiele in MNIST erläutern.
Das Inhaltsverzeichnis lautet wie folgt.
- Gehirnforschung und unbeaufsichtigtes Lernen
- Konzentrieren Sie sich auf unbeaufsichtigtes Lernen im Bereich der künstlichen Intelligenz
- Punkte der vorgeschlagenen Methode IIC
- Implementierung von IIC mit MNIST (Google Colabratory und PyTorch)
Hier befindet sich der Implementierungscode "MNIST_IIC.ipynb". Implementierungscode-Repository
1. Gehirnforschung und unbeaufsichtigtes Lernen
Der jüngste Boom bei KI und künstlicher Intelligenz wird durch Deep-Learning-Technologie vorangetrieben.
Das meiste tiefe Lernen ist jedoch überwachtes Lernen oder verbessertes Lernen (wie Alpha Go).
Es ist nicht üblich, Deep Learning für unbeaufsichtigtes Lernen zu verwenden (Ich sehe die Dimensionskomprimierung durch AutoEncoder dargestellt, aber es gibt wenig Clustering).
Mit Blick auf das Gebiet der Gehirnforschung, OIST (Okinawa Science and Technology Graduate University) Das Buch von Professor Doya "Einladung zur Computational Neuroscience" mit dem Ziel, den Lernmechanismus des Gehirns zu verstehen " Wie in der folgenden Abbildung gezeigt, wird die Beziehung zwischen den drei Lerntypen der künstlichen Intelligenz und dem Gehirn vorgeschlagen.
Es ist die Entwicklung der Großhirnrinde (insbesondere des Frontallappens), die den Menschen von anderen Organismen in der Intelligenz unterscheidet. ** In der Großhirnrinde wird die Bedeutung des unbeaufsichtigten Lernens nahegelegt. ** **.
Die Arbeit von Huber und Weasel, die 1981 den Nobelpreis für Physiologie und Medizin erhielten, ist unter Hirnforschern bekannt.
Sie durchbohren die Nervenzellen im Gehirn der Katze mit Elektroden Durch Messung der Aktivität von Nervenzellen bei der Darstellung verschiedener Symbole und beweglicher Stäbe Im Gesichtsfeld der Großhirnrinde hat jede Nervenzelle eine Symbolpräsentationsposition und die Richtung, in die sich der Stab erstreckt (vertikal, horizontal, diagonal) usw. ** Es zeigte sich, dass Nervenzellen selektiv entsprechend dem vorgestellten Objekt wirken **.
In der folgenden Abbildung ist diese Nervenzelle ein Neuron, das stark auf den vertikalen Balken reagiert.
Mit anderen Worten, es gibt Nervenzellen, die den horizontalen Balken entsprechen, und Nervenzellen, die den vertikalen Balken entsprechen, und die Verarbeitung dieser Neuronen wird auf komplexe Weise verarbeitet, um das Objekt zu erkennen.
Dann, im 21. Jahrhundert, ** Ein Gehirnteil, der sich als Reaktion auf ein Gesichtsbild entzündet, und ein Gehirnteil, das sich als Reaktion auf eine bestimmte Berühmtheit entzündet, wurden entdeckt. ** **. Mechanismus der Gesichtserkennung - aus der Oktober 2017-Ausgabe von Nikkei Science
Weil es eine solche Prämisse gab (die Existenz von Neuronen, die spezifisch auf Objekte in der Großhirnrinde reagieren), In den frühen Tagen des tiefen Lernens, Google ** Ankündigung, dass Neuronen, die dem Gesicht der Katze entsprechen, in der mittleren Schicht des tiefen Lernens geboren wurden ** War eine große Neuigkeit. Using large-scale brain simulations for machine learning and A.I.
Dies liegt daran, dass tiefes Lernen Eigenschaften erworben hat, die denen eines echten lebenden Gehirns ähneln.
Und es gibt ein weiteres bekanntes Experiment zum Gehirn, insbesondere zum unbeaufsichtigten Lernen.
Blackmore und Cooper experimentieren. Sie sind, ** Wenn Sie ein Kätzchen in einer Umgebung aufziehen, in der Sie die vertikalen Linien nur vorübergehend sehen können, können Sie die horizontalen Linien vorerst nicht erkennen ** Ich habe es klar gemacht.
Es ist eine Umgebung wie im Bild unten.
Cats and Vision: is vision acquired or innate?
Mit anderen Worten, Hubel und Weasel enthüllten die Existenz von Neuronen, die selektiv auf vertikale und horizontale Balken reagieren. Blackmore und Cooper haben gezeigt, dass solche Neuronen während der Entwicklung des Kätzchens in der Großhirnrinde geboren werden, wobei solche Landschaften in die Augen gelangen.
Es ist eine Erkenntnis aus der Gehirnforschung, dass ** unbeaufsichtigtes Lernen aufgrund der Entwicklung des Gesichtsfeldes von Kätzchen ** eine wichtige Rolle bei der Objekterkennung spielen wird.
2. Konzentrieren Sie sich auf unbeaufsichtigtes Lernen im Bereich der künstlichen Intelligenz
Selbst im Bereich der KI-Forscher gibt es auffällige Bemerkungen, die sich eher auf die Bedeutung der Bemühungen um unbeaufsichtigtes Lernen als auf das konventionelle Tiefenlernen des überwachten Lernens konzentrieren.
Hinton wurde 2017 in PFN Okanoharas Blog vorgestellt.
Professor Geoffrey Hinton auch [Link] "Es gibt 10 ^ 14 Gehirnsynapsen, aber Menschen können nur 10 ^ 9 Sekunden leben. Es gibt weit mehr Parameter als Proben (dieser Synapsen). Wir brauchen 10 ^ 5 Einschränkungen pro Sekunde (um die Gewichte zu bestimmen), und wir kommen auf die Idee, dass wir viel unbeaufsichtigt lernen. "
5 Jahre nach dem Gegenangriff des neuronalen Netzes
Es sagt aus.
Wir führen derzeit Forschungsarbeiten durch und kündigten im Februar 2020 SimCLR (A Simple Framework for Contrastive Learning of Visual Representations) an.
Geben Sie in SimCLR ** verschiedene konvertierte Paare in dasselbe Bild ein und lernen Sie, dass sie gleich sind, während Sie lernen, dass sich verschiedene Bilder durch unbeaufsichtigtes Lernen und die Merkmalsmenge des Bildes von ihnen unterscheiden Holen Sie sich die Technik, um zuerst zu extrahieren. ** **.
Darüber hinaus war Jan Lucan im Februar 2020 bei AAAI.
Herr Lucan sagte, dass die nächste Innovation des tiefen Lernens nicht überwachtes Lernen ist, sondern "unbeaufsichtigtes Lernen", das Merkmale aus Daten ohne korrekte Antwort-Tags extrahiert, und "selbstüberwachtes Lernen (Selbst-), das korrekte Antworten aus Lerndaten erzeugt. Überwachtes Lernen) ". "Dies sind die gleichen Aufgaben, die Neugeborene der Welt antun", erklärt Lucan. Babys können selbst lernen, ohne die "richtige Antwort" zu geben.
Es sagt aus. Was sind die aktuellen KI-Mängel, auf die die drei "Gottväter" des tiefen Lernens hingewiesen haben
Wenn wir weiterhin über Gehirnforschung und KI sprechen, können wir die ursprüngliche Implementierung nicht erreichen. Gehen Sie also hier.
Ein weiteres Beispiel ist Hintons Nature Reviews Neuroscience-Artikel "Back Propagation and the Brain" vom April 2020. Backpropagation and the brain
NGRAD-Gesetz in ([Darstellung des neuronalen Gradienten durch Aktivitätsunterschiede](https://syncedreview.com/2020/04/23/new-hinton-nature-paper-revisits-backpropagation-offers-insights-for-understanding-learning- im Kortex /)))
Ist vorgestellt.
Andere, ● Gespräch zwischen Hirnforscher und IT-Ingenieur über DL und künstliche Intelligenz für allgemeine Zwecke ● Geschäftsanwendung des vertieften Lernens und wie KI die natürliche Sprache versteht
Ist auch ein empfohlener früherer Artikel über Gehirnforschung und KI.
3. Punkte der vorgeschlagenen Methode IIC
Na dann, dieses Papier, Invariant Information Clustering for Unsupervised Image Classification and Segmentation
Ich werde die Punkte von IIC (Invariant Information Clustering) in erläutern.
Darüber hinaus enthält das IIC-Papier selbst keine Beschreibung wie "Wie funktioniert das Gehirn ...", sondern ein Papier mit einer reinen Berechnungsmethode.
Es gibt zwei Punkte in IIC.
** Der erste Punkt wird eingegeben **. Zur Eingabe ・ Daten (diesmal handgeschriebenes numerisches Bild) ・ Entsprechend konvertierte Daten Verwenden Sie zwei davon. Geben Sie jeden in das Netzwerk ein und erhalten Sie die Ausgabe von jedem.
Das Deep Learning-Netzwerk von IIC ähnelt dem überwachten Lernen. Die Anzahl der Neuronen in der Ausgabeschicht beträgt 10 (entsprechend den Zahlen 0 bis 9). Multiplizieren Sie die Ausgabe mit der Softmax-Funktion, um den Wahrscheinlichkeitswert auszugeben, dass das Eingabebild entweder 0 bis 9 ist.
Der zweite Punkt ist die ** Verlustfunktion **. Da es sich um unbeaufsichtigtes Lernen handelt, verwenden wir keine Lehreretiketten. Stattdessen, ・ Ausgabevektor (10 Elemente), der durch Eingabe eines handgeschriebenen numerischen Bildes in das neuronale Netzwerk ausgegeben wird Wann,
- Ausgabevektor (10 Elemente), der durch Eingabe eines Bildes ausgegeben wird, das ein wenig zufällig aus einem handgeschriebenen Zahlenbild konvertiert wurde Berechnen Sie die ** gegenseitige Informationsmenge ** von und trainieren Sie sie, um sie zu maximieren.
Daher müssen Sie mit gegenseitigen Informationen befreundet sein, um IIC zu verstehen.
Unten finden Sie eine Folie, in der die Menge der gegenseitigen Informationen erläutert wird.
Einige schwierige Formeln sind in einer Reihe, aber ** schließlich werden die von den beiden Daten gemeinsam genutzten Informationen als gegenseitige Informationsmenge ** bezeichnet.
Der Schlüssel ist ** gleichzeitige Verteilung und periphere Wahrscheinlichkeitsverteilung ** im Protokoll.
In der obigen Abbildung zeigt Beispiel 1 ein Beispiel für das Werfen von zwei unabhängigen Münzen, und Beispiel 2 zeigt ein Beispiel für das Werfen von zwei nicht unabhängigen Münzen. (Das heißt, in Beispiel 2 hat die zweite Münze das gleiche Ergebnis wie die erste)
Das Bild oben ist ein Beispiel für eine Münze, die zwei ausgibt, vorne und hinten.
Im Fall eines neuronalen MNIST-Netzwerks werden 10 Teile von 0 bis 9 ausgegeben.
Stellen Sie sich die beiden Ausgabeversionen des neuronalen Netzwerks von MNIST vor, während die Münze oben wirft.
Wenn die beiden in Beispiel 1 unabhängig sind, beträgt die Wahrscheinlichkeit (zurück, zurück) 0,25. Und die Wahrscheinlichkeit, dass sich das erste Blatt nach der Marginalisierung auf der Rückseite befindet, beträgt 0,5 für (Rückseite, Rückseite) + (Rückseite, Vorderseite). In ähnlicher Weise beträgt die Wahrscheinlichkeit, dass sich das zweite Blatt auf der Rückseite befindet, 0,5 für (vorne, hinten) + (hinten, hinten). Wenn Sie diese in die Protokollberechnung einbeziehen, ist das Protokollergebnis 0.
Wenn Sie nicht nur (hinten, hinten), sondern auch (hinten, vorne), (vorne, hinten), (vorne, vorne) berechnen, sind alle 0 und die Summe ist 0.
Wenn Sie also zwei unabhängige Münzen werfen, beträgt die Menge an gegenseitigen Informationen zwischen dem ersten und dem zweiten Ergebnis 0.
Da die Versuche zum Werfen von Münzen unabhängig sind und das erste und zweite Ergebnis irrelevant sind, gibt es keine Informationen, die miteinander geteilt werden können, und ich denke, Sie können davon überzeugt sein, dass es 0 sein wird.
Berücksichtigen Sie die Menge an gegenseitigen Informationen, wenn die zweite Münze, die in Beispiel 2 nicht unabhängig ist, das gleiche Ergebnis wie die erste Münze liefert.
Die Wahrscheinlichkeit zu werden (zurück, zurück) beträgt 0,5. Und die Wahrscheinlichkeit, dass sich das erste Blatt nach der Marginalisierung auf der Rückseite befindet, beträgt 0,5 für (Rückseite, Rückseite) + (Rückseite, Vorderseite). Ebenso ist das zweite Stück 0,5. Dann wird die Berechnung in log (1 / 0,5) und log2 = 0,69. Multiplizieren Sie dies mit der Wahrscheinlichkeit von (zurück, zurück) 0,5, um ungefähr 0,35 zu erhalten. (Hinten, vorne) ist 0, (vorne, vorne) ist ungefähr 0,35 wie (hinten, hinten) und (vorne, hinten) ist 0, also ist die Summe 0,69.
Daher ist im Fall eines nicht unabhängigen Münzwurfs die Menge an gegenseitiger Information größer als 0.
Mit anderen Worten, das Ergebnis des ersten Münzwurfs und das Ergebnis des zweiten Münzwurfs haben Informationen. Dieses Mal ist das Ergebnis des zweiten Blattes das gleiche wie das des ersten Blattes, also denke ich, dass Sie es verstehen können.
Stellen Sie sich dies in IIC als Münzwurf in 10 verschiedenen Versionen der MNIST-Bildausgabe 0-9 vor.
Und die zweite Münze ist das MNIST-Bild mit entsprechender Konvertierung.
Als geeignete Konvertierung dreht und streckt die affine Konvertierung das Bild, und das Rauschen ist enttäuschend.
** Ich möchte das Netzwerk so trainieren, dass das Ausgabeergebnis der Wahrscheinlichkeit, dass das Bild mit dieser geringfügigen Konvertierung und das Originalbild entweder 0 bis 9 sind, gleich ist **
Das ist das Gefühl von IIC.
Ein Bild, das eine gewisse Konvertierung erfahren hat, simuliert schließlich ein Bild derselben Klasse.
Hier gibt es zwei Punkte.
Erstens entspricht der Netzwerkausgang weder den Zahlen 0 bis 9 in der Reihenfolge noch den Zahlen. ** Trennen Sie einfach ähnliche Bilder in dieselbe Klasse. ** **.
Der zweite Punkt ist, dass ich mir Sorgen mache, dass sie alle in derselben Klasse sein werden, aber erinnere mich an die Menge an gegenseitigen Informationen beim Münzwurf. Die zweite Münze in Beispiel 2 hat das gleiche Ergebnis wie die erste Münze.
Die Menge an gegenseitigen Informationen ist bei Münzen mit derselben Vorder- und Rückseite größer als bei Münzen mit allen Rückseiten.
Bei Münzen, die alle eine Rückseite haben, beträgt die Wahrscheinlichkeit zu werden (Rückseite, Rückseite) 1,0. Und die Wahrscheinlichkeit, dass sich das erste Blatt nach der Marginalisierung auf der Rückseite befindet, beträgt 1,0 für (Rückseite, Rückseite) + (Rückseite, Vorderseite). Ebenso ist das zweite Stück 1.0. Dann wird die Berechnung in log (1/1) und log1 = 0,0.
** Um die Menge an gegenseitiger Information zu maximieren, wird die Menge an gegenseitiger Information maximiert, wenn die Wahrscheinlichkeiten gleichmäßig auf 2 Typen verteilt sind, wenn es 2 Typen gibt, und 10 Typen, wenn es 10 Typen gibt. ** **.
Wenn Sie also die Mini-Batch-Menge berechnen, existieren 10 Klassen, die natürlich getrennt sind, gleichmäßig.
Das Obige ist die Punkterklärung von IIC.
Dann werden wir mit der Implementierung beginnen.
4. Implementierung von IIC mit MNIST (Google Colabratory und PyTorch)
Die Umgebung verwendet Google Colaboratory und das Framework verwendet PyTorch.
Implementieren Sie IIC für MNIST.
Hier befindet sich der Implementierungscode "MNIST_IIC.ipynb". Implementierungscode-Repository
https://github.com/RuABraun/phone-clustering Ich werde es mit Bezug auf implementieren, aber ich habe viele Änderungen vorgenommen.
Befestigen Sie zuerst den Samen
#Zufälliger Startwert behoben
import os
import random
import numpy as np
import torch
SEED_VALUE = 1234 #Das kann alles sein
os.environ['PYTHONHASHSEED'] = str(SEED_VALUE)
random.seed(SEED_VALUE)
np.random.seed(SEED_VALUE)
torch.manual_seed(SEED_VALUE) #Bei Verwendung von PyTorch
Überprüfen Sie als Nächstes die GPU-Nutzung. Für Google Colaboratory von "Runtime" im oberen Menü Wählen Sie "Laufzeittyp ändern" und wechseln Sie "Keine" zur GPU.
#Wenn eine GPU verfügbar ist, wählen Sie GPU aus (geben Sie bei Google Colaboratory die GPU zur Laufzeit an).
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(device)
#Verwendet GPU. Bestätigen Sie, dass cuda ausgegeben wird.
Laden Sie das MNIST-Image herunter und verwenden Sie es als PyTorch-Datenlader. Bereiten Sie sich auf Training und Tests vor.
#Laden Sie das MNIST-Image herunter und machen Sie es zu einem DataLoader (Train and Test).
from torchvision import datasets, transforms
batch_size_train = 512
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('.', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
])),
batch_size=batch_size_train, shuffle=True, drop_last=True)
# drop_last wird nicht verwendet, wenn der letzte Mini-Batch kleiner als die angegebene Größe ist
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('.', train=False, transform=transforms.Compose([
transforms.ToTensor(),
])),
batch_size=1024, shuffle=False)
Als nächstes folgt das IIC-Deep-Learning-Modell. Es ist dasselbe wie normales überwachtes Lernen, aber es ist schwerer als nur überwachtes Lernen, um eine reichhaltigere Ausdruckskraft im Netzwerk zu erlangen.
Die letzte Ausgabeebene besteht aus 10 Arten von Klassen, von denen Sie erwarten möchten, dass sie 0-9 entsprechen. Außerdem wird eine Technologie namens Overclustring verwendet.
Dies macht es noch kategorisierter als die 10 erwarteten Typen.
Die letzte Ausgabeebene ist die 10-Typ-Version und die Overclustering-Version, und die Verlustfunktion berechnet auch die Ausgabe von beiden und verwendet die Summe.
Es wird erwartet, dass die Leistung der üblichen 10 Klassifizierungstypen verbessert wird, wenn geringfügige Änderungen vom überindustriellen Netzwerk erfasst werden können.
In dem IIC-Papier wird diese Ausgabeschicht als Mehrkopf weiter gemultiplext. Dies dient jedoch dazu, Fehler in Abhängigkeit vom Anfangswert der Ausgabeschicht zu vermeiden Ich habe es weggelassen, weil es für mich nicht viel Sinn macht und die Implementierung schwierig ist.
#Deep-Learning-Modell
import torch.nn as nn
import torch.nn.functional as F
OVER_CLUSTRING_Rate = 10 #Bereiten Sie auch Overclsutering vor, um mehr zu klassifizieren
class NetIIC(nn.Module):
def __init__(self):
super(NetIIC, self).__init__()
self.conv1 = nn.Conv2d(1, 128, 5, 2, bias=False)
self.bn1 = nn.BatchNorm2d(128)
self.conv2 = nn.Conv2d(128, 128, 5, 1, bias=False)
self.bn2 = nn.BatchNorm2d(128)
self.conv3 = nn.Conv2d(128, 128, 5, 1, bias=False)
self.bn3 = nn.BatchNorm2d(128)
self.conv4 = nn.Conv2d(128, 256, 4, 1, bias=False)
self.bn4 = nn.BatchNorm2d(256)
# 0-10 Arten von Klassen, von denen Sie erwarten, dass sie 9 unterstützen
self.fc = nn.Linear(256, 10)
# overclustering
#Wenn Sie mehr als die tatsächliche Annahme gruppieren, können Sie kleinste Änderungen im Netzwerk erfassen.
self.fc_overclustering = nn.Linear(256, 10*OVER_CLUSTRING_Rate)
def forward(self, x):
x = F.relu(self.bn1(self.conv1(x)))
x = F.relu(self.bn2(self.conv2(x)))
x = F.relu(self.bn3(self.conv3(x)))
x = F.relu(self.bn4(self.conv4(x)))
x_prefinal = x.view(x.size(0), -1)
y = F.softmax(self.fc(x_prefinal), dim=1)
y_overclustering = F.softmax(self.fc_overclustering(
x_prefinal), dim=1) # overclustering
return y, y_overclustering
Definieren Sie die Modellgewichtsinitialisierungsfunktion.
import torch.nn.init as init
def weight_init(m):
"""Gewichtsinitialisierung"""
if isinstance(m, nn.Conv2d):
init.xavier_normal_(m.weight.data)
if m.bias is not None:
init.normal_(m.bias.data)
elif isinstance(m, nn.BatchNorm2d):
init.normal_(m.weight.data, mean=1, std=0.02)
init.constant_(m.bias.data, 0)
elif isinstance(m, nn.Linear):
# Xavier
#init.xavier_normal_(m.weight.data)
# He
init.kaiming_normal_(m.weight.data)
if m.bias is not None:
init.normal_(m.bias.data)
Definieren Sie als Nächstes die Transformation, um ein Bild zu erstellen, das mit dem Eingabebild gepaart wird. Die affine Transformation wird verwendet, um sich zu drehen und zu dehnen und dann jedem Pixel Rauschen hinzuzufügen.
#Definition von Funktionen, die Daten rauschen
import torchvision as tv
import torchvision.transforms.functional as TF
def perturb_imagedata(x):
y = x.clone()
batch_size = x.size(0)
#Führen Sie eine zufällige affine Konvertierung durch
trans = tv.transforms.RandomAffine(15, (0.2, 0.2,), (0.2, 0.75,))
for i in range(batch_size):
y[i, 0] = TF.to_tensor(trans(TF.to_pil_image(y[i, 0])))
#Rauschen hinzufügen
noise = torch.randn(batch_size, 1, x.size(2), x.size(3))
div = torch.randint(20, 30, (batch_size,),
dtype=torch.float32).view(batch_size, 1, 1, 1)
y += noise / div
return y
Und es ist die Berechnung der Menge an gegenseitiger Information, die der Schlüssel zu IIC ist. Was wir tun, ist die Berechnung der Menge an gegenseitiger Information, wie in 3 erläutert.
Ich möchte die Menge der gegenseitigen Informationen maximieren, aber um sie zu einem Verlust zu machen, multiplizieren Sie sie mit Minus und Ich ersetze es durch ein Minimierungsproblem.
Ebenfalls, Einfache Methode, um MNIST-korrekte Antwortrate von 97% oder mehr zu erhalten, indem ohne Lehrer gelernt wird (ohne Transferlernen) Zur Berechnung der Menge der in eingebrachten gegenseitigen Informationen wird ein Koeffiziententerm hinzugefügt, der es den Klassen erleichtert, zu variieren.
Der obige Artikel führt die Implementierung in TensorFlow2 sorgfältig ein und wird für TensorFlow dringend empfohlen.
#Definition der Verlustfunktion durch IIS
#Referenz: https://github.com/RuABraun/phone-clustering/blob/master/mnist_basic.py
import sys
def compute_joint(x_out, x_tf_out):
# x_out、x_tf_raus ist Fackel.Size([512, 10]).. Multiplizieren Sie diese beiden, um die gleichzeitige Verteilung Fackel zu finden.Size([2048, 10, 10])Zu.
# torch.Size([512, 10, 1]) * torch.Size([512, 1, 10])
p_i_j = x_out.unsqueeze(2) * x_tf_out.unsqueeze(1)
# p_i_j ist Fackel.Size([512, 10, 10])
#Addiere alle Mini-Chargen ⇒ Fackel.Size([10, 10])
p_i_j = p_i_j.sum(dim=0)
#Zur Quermatrix hinzufügen und teilen (Symmetrie) ⇒ Brenner.Size([10, 10])
p_i_j = (p_i_j + p_i_j.t()) / 2.
#Standardisierung ⇒ Brenner.Size([10, 10])
p_i_j = p_i_j / p_i_j.sum()
return p_i_j
#Immerhin p_i_j zeigt die Wahrscheinlichkeitsverteilungstabelle, von welcher der 100 Muster alle Mini-Batch für 100 Muster von 10 Arten der Beurteilungsausgabe des normalen Bildes und 10 Arten der Beurteilung des konvertierten Bildes waren.
def IID_loss(x_out, x_tf_out, EPS=sys.float_info.epsilon):
# torch.Size([512, 10])Die letzten 10 sind die Anzahl der Klassifizierungen, also 100 für Überclustering
bs, k = x_out.size()
p_i_j = compute_joint(x_out, x_tf_out) # torch.Size([10, 10])
#Summieren Sie aus der Verteilungstabelle der gleichzeitigen Wahrscheinlichkeit 10 Muster des konvertierten Bildes und begrenzen Sie es, um eine Verteilungstabelle der peripheren Wahrscheinlichkeit nur für das Originalbild zu erstellen
p_i = p_i_j.sum(dim=1).view(k, 1).expand(k, k)
#Summieren Sie aus der Verteilungstabelle der gleichzeitigen Wahrscheinlichkeit 10 Muster des Originalbilds und begrenzen Sie es, um eine Verteilungstabelle der peripheren Wahrscheinlichkeit nur für das konvertierte Bild zu erstellen.
p_j = p_i_j.sum(dim=0).view(1, k).expand(k, k)
#Vermeiden Sie es, einen Wert nahe 0 in das Protokoll einzugeben, da dieser abweicht.
#p_i_j[(p_i_j < EPS).data] = EPS
#p_j[(p_j < EPS).data] = EPS
#p_i[(p_i < EPS).data] = EPS
#Referenz GitHub-Implementierung (↑) ist PyTorch Version 1.Wenn es 3 oder mehr ist, tritt ein Fehler auf.
# https://discuss.pytorch.org/t/pytorch-1-3-showing-an-error-perhaps-for-loss-computed-from-paired-outputs/68790/3
#Vermeiden Sie es, einen Wert nahe 0 in das Protokoll einzugeben, da dieser abweicht.
p_i_j = torch.where(p_i_j < EPS, torch.tensor(
[EPS], device=p_i_j.device), p_i_j)
p_j = torch.where(p_j < EPS, torch.tensor([EPS], device=p_j.device), p_j)
p_i = torch.where(p_i < EPS, torch.tensor([EPS], device=p_i.device), p_i)
#Berechnen Sie die Menge der gegenseitigen Information aus der gleichzeitigen Wahrscheinlichkeit des Originalbilds und des konvertierten Bildes und der peripheren Wahrscheinlichkeit
#Multiplizieren Sie es jedoch mit Minus, um es zu einem Minimierungsproblem zu machen.
"""
Ich möchte die Menge an gegenseitigen Informationen maximieren
⇒ Immerhin x_out, x_tf_Ich möchte, dass mehr Informationen von out geteilt werden
⇒ Der Punkt ist x_out, x_tf_Ich möchte zusammen sein
p_i_j ist x_out, x_tf_Bei gleichzeitiger Wahrscheinlichkeitsverteilung von out bin ich froh, dass die Mini-Charge so weit wie möglich, verschiedene Muster von 10 × 10, gleichmäßig gleichmäßig ist
Erster halber Abschnitt, Fackel.log(p_i_j)Ist p_Wenn ij nahe bei 1 liegt, wird es ein großer Wert (nahe bei 0).
Wenn einer von ihnen 1 ist und nicht mit 0 variiert, hat log0 einen kleinen Wert (großer negativer Wert).
Mit anderen Worten, die erste Hälfte der Laufzeit
Der letztere Begriff ist ein Begriff, der berechnet, welcher der 10 Typen des Originalbilds oder des konvertierten Bildes an den Rand gedrängt wird.
Wenn der erste Halbjahr durch Subtrahieren des marginalisierten 10x10-Musters kleiner wird,
x_raus und x_tf_out teilte nicht viele Informationen.
"""
# https://qiita.com/Amanokawa/items/0aa24bc396dd88fb7d2a
#Fügen Sie das Gewicht Alpha mit Bezug auf hinzu
#Kleine Strafen aufgrund von Abweichungen in der Tabelle der gleichzeitigen Wahrscheinlichkeitsverteilung = Machen Sie die Verteilung der gleichzeitigen Wahrscheinlichkeit leicht variabel
alpha = 2.0 #Alpha ist 1 für Papiere und normale gegenseitige Informationsberechnung
loss = -1*(p_i_j * (torch.log(p_i_j) - alpha *
torch.log(p_j) - alpha*torch.log(p_i))).sum()
return loss
Wir werden Schulungen durchführen.
#Durchführung von Schulungen
total_epoch = 20
#Modell-
model = NetIIC()
model.apply(weight_init)
model.to(device)
#Optimierungsfunktion einstellen
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
def train(total_epoch, model, train_loader, optimizer, device):
model.train()
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
optimizer, T_0=2, T_mult=2)
for epoch in range(total_epoch):
for batch_idx, (data, target) in enumerate(train_loader):
#Änderung der Lernrate
scheduler.step()
#Erstellen Sie subtil konvertierte Daten. GLEICHZEITIG_Bilden Sie ein Paar für NUM
data_perturb = perturb_imagedata(data) #Gib Lärm
#Senden, wenn an die GPU gesendet
data = data.to(device)
data_perturb = data_perturb.to(device)
#Initialisierung der Optimierungsfunktion
optimizer.zero_grad()
#Neuronale Netzwerkausgabe
output, output_overclustering = model(data)
output_perturb, output_perturb_overclustering = model(data_perturb)
#Verlustberechnung
loss1 = IID_loss(output, output_perturb)
loss2 = IID_loss(output_overclustering,
output_perturb_overclustering)
loss = loss1 + loss2
#Aktualisiert, um Verluste zu reduzieren
loss.backward()
optimizer.step()
#Protokollausgabe
if batch_idx % 10 == 0:
print('Train Epoch {}:iter{} - \tLoss1: {:.6f}- \tLoss2: {:.6f}- \tLoss_total: {:.6f}'.format(
epoch, batch_idx, loss1.item(), loss2.item(), loss1.item()+loss2.item()))
return model, optimizer
model_trained, optimizer = train(
total_epoch, model, train_loader, optimizer, device)
Während des Trainings wird der Cosine Annealing Warm Restarts des Schedulers verwendet, um die Lernrate zu ändern. Dieser Scheduler erhöht oder senkt die Lernrate wie unten gezeigt.
Abbildung: Zitat
https://www.kaggle.com/c/imet-2019-fgvc6/discussion/94783
Wenn die Lernrate sinkt und stark zunimmt, können Sie die lokale Lösung verlassen und sich den Parametern der globalen Minimallösung nähern.
Schliessen Sie schließlich die Testdaten mit dem trainierten Modell ab.
#Überprüfen Sie die Ergebnisse des Modellklassifizierungsclusters
def test(model, device, train_loader):
model.eval()
#Liste zum Speichern der Ergebnisse
out_targs = []
ref_targs = []
cnt = 0
with torch.no_grad():
for data, target in test_loader:
cnt += 1
data = data.to(device)
target = target.to(device)
outputs, outputs_overclustering = model(data)
#Klassifizierungsergebnis zur Liste hinzufügen
out_targs.append(outputs.argmax(dim=1).cpu())
ref_targs.append(target.cpu())
#Sammeln Sie die Liste
out_targs = torch.cat(out_targs)
ref_targs = torch.cat(ref_targs)
return out_targs.numpy(), ref_targs.numpy()
out_targs, ref_targs = test(model_trained, device, train_loader)
Suchen Sie schließlich die Häufigkeitstabelle der Ausgabeergebnisse. Die vertikale Achse zeigt die tatsächlichen Beschriftungen von 0 bis 9 und die horizontale Achse zeigt die beurteilte Klasse.
import numpy as np
import scipy.stats as stats
#Machen Sie eine Verwirrungsmatrix
matrix = np.zeros((10, 10))
#Erstellen Sie eine Häufigkeitstabelle von Klassen, die vertikal mit den Zahlen 0 bis 9 und horizontal bewertet werden
for i in range(len(out_targs)):
row = ref_targs[i]
col = out_targs[i]
matrix[row][col] += 1
np.set_printoptions(suppress=True)
print(matrix)
Das Ausgabeergebnis ist
[[ 1. 978. 1. 0. 0. 0. 0. 0. 0. 0.]
[ 1. 0. 4. 1110. 2. 0. 2. 0. 13. 3.]
[ 0. 5. 4. 0. 0. 0. 0. 0. 1023. 0.]
[ 0. 0. 2. 0. 0. 4. 962. 0. 39. 3.]
[ 1. 0. 0. 0. 960. 0. 0. 19. 1. 1.]
[ 1. 1. 0. 0. 0. 866. 17. 0. 3. 4.]
[ 940. 7. 0. 0. 0. 3. 0. 0. 4. 4.]
[ 0. 0. 921. 1. 0. 0. 1. 92. 13. 0.]
[ 0. 6. 0. 0. 0. 2. 4. 2. 2. 958.]
[ 0. 4. 14. 0. 2. 7. 27. 949. 2. 4.]]
Zum Beispiel ist die Zahl 0 die erste in der Klasse, die 978 sammelt. Wenn es die Nummer 9 ist, werden 949 Stücke auf dem 7. Platz gesammelt.
Wenn Sie in jeder geschätzten Klasse die gleichen Zahlen auf jedes richtige Antwortetikett anwenden,
#Alle Daten
total_num = matrix.sum().sum()
print(total_num)
#Jede Zahl ist ordentlich in jede Klasse unterteilt.
#Zum Beispiel ist die Zahl 0 die erste in der Klasse, die 978 sammelt. Wenn es die Nummer 9 ist, wurden 949 Stücke auf dem 7. Platz gesammelt.
#Wenn Sie also die größten hinzufügen, die Anzahl der richtigen Antworten
correct_num_list = matrix.max(axis=0)
print(correct_num_list)
print(correct_num_list.sum())
print("Richtige Antwortrate:", correct_num_list.sum()/total_num*100)
Und die Ausgabe ist
10000.0
[ 940. 978. 921. 1110. 960. 866. 962. 949. 1023. 958.]
9667.0
Richtige Antwortrate: 96.67
ist. Die richtige Antwortrate betrug 97%.
Hier befindet sich der Implementierungscode "MNIST_IIC.ipynb". Implementierungscode-Repository
schließlich
Wir haben IIC (Invariant Information Clustering) eingeführt, ein unbeaufsichtigtes Lernen, bei dem die Maximierung der gegenseitigen Information genutzt wird.
Die Idee, ähnliche Eingaben aus demselben Bild in IIC gleichzusetzen, ist dem Kontrastlernen von SimCLR (Ein einfacher Rahmen für das kontrastive Lernen visueller Darstellungen) in Hinton et al.
In IIC selbst erscheint die Menge an gegenseitiger Information nur in der Fehlerfunktion, und die Lücke zwischen dem IIC-Papier und dem biologischen Gehirn ist ziemlich groß.
Die Menge an gegenseitiger Information kann jedoch auch durch die Menge an Calvac-Liber-Informationen ausgedrückt und auf das Prinzip der freien Energie von Carl Friston erweitert werden (glaube ich).
IIC war eine sehr interessante Arbeit und Methode. Ich hoffe, dass in Zukunft der Fortschritt des unbeaufsichtigten Lernens und der Fortschritt des Gehirns und der Neurowissenschaften weiter integriert werden.
Dieses Mal habe ich IIC mit Bilddaten durchgeführt, aber das nächste Mal werde ich einen Artikel darüber schreiben, was passiert, wenn ich IIC mit von BERT verarbeiteten Textdaten mache (hier universell für Organismen mit einem Gesichtsfeld namens Objekterkennung). Es ist ein interessantes Ergebnis, dass der Unterschied zwischen dem Mechanismus des Zielhirns und der menschenspezifischen Eigenschaft der natürlichen Sprache bemerkenswert wird.
Vielen Dank für das Lesen der oben genannten.
[Haftungsausschluss] Dieser Artikel ist die Meinung / Übermittlung des Autors, nicht die offizielle Meinung des Unternehmens, zu dem der Autor gehört.
Recommended Posts