[PYTHON] Lineare multiple Regression, logistische Regression, mehrschichtiges Perzeptron, Auto-Encoder, Chainer Yo!
Verwenden Sie Chainer, um die Grundideen des tiefen Lernens zu lernen.
Chainer Grundteile
chainer.Variable
In Chainer werden Variablen als eine Klasse namens Variable beschrieben.
import numpy as np
from chainer import Variable
x1 = Variable(np.array([0.12]).astype(np.float32))
x2 = Variable(np.array([0.34]).astype(np.float32))
x3 = Variable(np.array([0.56]).astype(np.float32))
Führen Sie die "Vorwärtsberechnung" mit der folgenden Berechnung durch. Beim tiefen Lernen werden diese Koeffizienten (0,5, 0,3, 0,2 usw. unten) als "Gradienten" bezeichnet, und der Zweck der Berechnung besteht darin, den optimalen Gradientenwert zu finden.
z = 0.5 * x1 + 0.3 * x2 + 0.2 * x3
Das Ergebnis der Operation ist auch ein Objekt der Variablenklasse.
z
variable([0.274])
Mit dem Attribut .data können Sie auf das Objekt numpy.ndarray verweisen, das den Inhalt der Daten enthält.
z.data
array([0.274], dtype=float32)
Führen Sie die "Rückwärtsberechnung" wie folgt durch. Der Zweck der Rückwärtsberechnung besteht darin, den Fehler im Vorwärtsberechnungsergebnis "rückpropagieren" und den oben erwähnten "Koeffizienten" fein einstellen.
z.backward()
Die umgekehrte Berechnung ergibt den "Differenzwert", der für die Feinabstimmung der Koeffizienten jeder Variablen benötigt wird.
x1.grad, x2.grad, x3.grad
(array([0.5], dtype=float32),
array([0.3], dtype=float32),
array([0.2], dtype=float32))
Bisher waren Variablen eindimensional, Sie können jedoch auch mehrdimensionale Arrays verwenden, wie unten gezeigt.
x1 = Variable(np.array([0.12, 0.21]).astype(np.float32))
x2 = Variable(np.array([0.34, 0.43]).astype(np.float32))
x3 = Variable(np.array([0.56, 0.65]).astype(np.float32))
z = 0.5 * x1 + 0.3 * x2 + 0.2 * x3
z
variable([0.274, 0.364])
Wenn die Variable mehrdimensional ist, müssen Sie die Dimension der Steigung der Funktion im Voraus kennen, bevor Sie die "umgekehrte Berechnung" durchführen.
z.grad = np.ones(2, dtype=np.float32)
z.backward()
x1.grad, x2.grad, x3.grad
(array([0.5, 0.5], dtype=float32),
array([0.3, 0.3], dtype=float32),
array([0.2, 0.2], dtype=float32))
chainer.links.Linear
Chainer bietet eine lineare Konvertierungsfunktion als chainer.links.Linear, die verwendet wird, wenn Daten in einem neuronalen Netzwerk (NN), das tiefes Lernen durchführt, von einer Schicht zur nächsten übertragen werden. Lineare Transformation
Es wird ausgedrückt als. Bevor Sie chainer.links.Linear verwenden, drücken wir eine lineare Transformation mit numpy aus.
import numpy as np
W = np.array([[ 5, 1, -2 ],
[ 3, -5, -1 ]], dtype=np.float32)
b = np.array([2, -3], dtype=np.float32)
Wenn nur eine Eingabedaten vorhanden sind (nur eine Daten bestehen aus drei Variablen), können diese wie folgt berechnet werden.
x = np.array([0, 1, 2])
y = x.dot(W.T) + b
y
array([ -1., -10.])
Wenn 5 Eingabedaten vorhanden sind (5 Daten bestehen aus 3 Variablen), können diese wie folgt berechnet werden. Auf diese Weise besteht die Stärke der Matrixberechnung darin, dass sie auch dann parallel berechnet werden kann, wenn eine große Datenmenge vorhanden ist.
x = np.array(range(15)).astype(np.float32).reshape(5, 3)
x
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.],
[ 9., 10., 11.],
[12., 13., 14.]], dtype=float32)
y = x.dot(W.T) + b
y
array([[ -1., -10.],
[ 11., -19.],
[ 23., -28.],
[ 35., -37.],
[ 47., -46.]], dtype=float32)
Eine ähnliche Berechnung kann mit chainer.links.Linear erreicht werden.
import chainer.links as L
h = L.Linear(3,2) #Lineare Aktionsfunktion y, die einen dreidimensionalen Vektor eingibt und einen zweidimensionalen Vektor ausgibt= Wx + b
h.W.data #Random ist standardmäßig eingegeben
array([[ 0.5469049 , -0.35929427, -0.9921321 ],
[ 1.4973897 , 0.620568 , 0.78245926]], dtype=float32)
h.b.data #Enthält standardmäßig den Vektor 0
array([0., 0.], dtype=float32)
x = Variable(np.array(range(15)).astype(np.float32).reshape(5, 3))
x.data # Variable.data ist ein Array-Objekt von Numpy
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.],
[ 9., 10., 11.],
[12., 13., 14.]], dtype=float32)
y = h(x)
y.data
array([[ -2.3435585, 2.1854866],
[ -4.757123 , 10.886737 ],
[ -7.170687 , 19.587988 ],
[ -9.584251 , 28.289238 ],
[-11.997816 , 36.990486 ]], dtype=float32)
x.data.dot(h.W.data.T) + h.b.data #Überprüfung der Konten
array([[ -2.3435585, 2.1854866],
[ -4.757123 , 10.886737 ],
[ -7.170687 , 19.587988 ],
[ -9.584251 , 28.289238 ],
[-11.997816 , 36.990486 ]], dtype=float32)
chainer.functions
Chainer bietet verschiedene Funktionen in chainer.functions, die Objekte der Variablenklasse als Argumente verwenden. Ein typisches Beispiel ist der mittlere quadratische Fehler chainer.functions.mean_squared_error.
import chainer.functions as F
y_pred = Variable(np.array([0.1, 0.2, 0.3]).astype(np.float32))
y_real = Variable(np.array([0.2, 0.1, 0.3]).astype(np.float32))
loss = F.mean_squared_error(y_pred, y_real)
loss
variable(0.00666667)
Multiple lineare Regression (MLR)
Lassen Sie uns nun als Übung für Chainer eine lineare multiple Regression durchführen. Als zu verarbeitende Daten behandeln wir die Daten von Iris (Ayame), die häufig im Bereich des maschinellen Lernens verwendet werden.
Ayame-Daten
import numpy as np
from sklearn import datasets
iris = datasets.load_iris() #Irisdaten lesen
data = iris.data.astype(np.float32)
X = data[:, :3] #Die ersten drei der Irismessdaten werden als erklärende Variablen verwendet.
Y = data[:, 3].reshape(len(data), 1) #Der letzte sei die Zielvariable.
#Die ungeraden Daten seien die Lehrerdaten und die geraden Daten die Testdaten.
index = np.arange(Y.size)
X_train = X[index[index % 2 != 0], :] #Erklärende Variable (Lehrerdaten)
X_test = X[index[index % 2 == 0], :] #Erklärende Variable (Testdaten)
Y_train = Y[index[index % 2 != 0], :] #Objektive Variable (Lehrerdaten)
Y_test = Y[index[index % 2 == 0], :] #Zielvariable (Testdaten)
chainer.Sequential
Definieren Sie in chainer.Sequential die Struktur des neuronalen Netzwerks.
import chainer.links as L
from chainer import Sequential
n_input = 3 #Eingabedaten sind 3 Variablen
n_output = 1 #Ausgabedaten sind eine Variable
mlr = Sequential( #Definieren Sie ein neuronales Netzwerk
L.Linear(n_input, n_output) #Neuronales Netz bestehend aus nur einer Schicht
)
Bei der ersten Definition enthält es eine Zufallszahl als Koeffizienten (Gradient).
mlr[0].W.data, mlr[0].b.data #Auf diese Weise können Sie auf den Koeffizienten verweisen
(array([[ 0.8395325 , 0.26789278, -0.4547218 ]], dtype=float32),
array([0.], dtype=float32))
Sie können die "Vorwärtsberechnung" wie folgt durchführen. Da der Koeffizient jedoch ein zufälliger Anfangswert bleibt, ist der vorhergesagte erhaltene Wert ebenfalls unregelmäßig.
Y_pred = mlr(X_test) #Vorwärtsberechnung
Y_pred
variable([[4.5826297],
[4.211921 ],
[4.525466 ],
[4.136074 ],
[3.8342214],
[4.842596 ],
[4.196824 ],
[5.3951936],
[4.9871187],
[5.0303006],
[4.6712837],
[4.3715415],
[4.07662 ],
[4.380943 ],
[4.6397934],
[4.132669 ],
[4.7818465],
[4.2620945],
[4.9639153],
[3.9064832],
[4.544149 ],
[3.9600616],
[4.435637 ],
[4.5720534],
[4.758643 ],
[4.596792 ],
[4.395105 ],
[4.11534 ],
[4.0359087],
[4.226083 ],
[3.1419218],
[3.807672 ],
[3.841272 ],
[3.458812 ],
[3.7482173],
[3.6278338],
[3.73065 ],
[4.1945934],
[4.276256 ],
[3.7678359],
[3.5324283],
[3.8191838],
[3.2909057],
[4.318143 ],
[3.6407008],
[3.313174 ],
[3.7469225],
[3.5148606],
[3.6523929],
[3.5871825],
[3.44477 ],
[4.0815 ],
[3.623253 ],
[2.7371933],
[3.657213 ],
[3.995137 ],
[4.01153 ],
[3.300307 ],
[3.7596698],
[4.02334 ],
[4.058117 ],
[4.1678634],
[3.9169993],
[3.7725363],
[3.5766659],
[4.188837 ],
[3.5766659],
[3.2712274],
[3.653448 ],
[3.6582088],
[3.908893 ],
[3.2735178],
[3.9169993],
[3.6851778],
[3.660439 ]])
chainer.optimizers
chainer.optimizers bietet eine Vielzahl von Optimierungstechniken. Eine davon ist der stochastische Gradientenabstieg (SGD).
from chainer import optimizers
optimizer = optimizers.SGD(lr=0.01) #Wählen Sie SGD als Optimierungsmethode
optimizer.setup(mlr) #Richten Sie das definierte Netzwerk ein
<chainer.optimizers.sgd.SGD at 0x7f2e090bb7f0>
Vergleichen Sie den vorher erhaltenen vorhergesagten Wert Y_pred mit dem tatsächlich beobachteten Wert Y_train, um seinen durchschnittlichen Quadratwurzelfehler MSE zu erhalten. Es gibt verschiedene andere Möglichkeiten, um den Fehler zu definieren. Beim tiefen Lernen werden diese Fehler als "Verlust" bezeichnet, und die Funktion zum Auffinden von Verlust wird als "Verlustfunktion" bezeichnet. Deep Learning zielt darauf ab, diesen Verlust zu minimieren.
import chainer.functions as F
loss = F.mean_squared_error(Y_pred, Y_train)
loss
variable(9.235707)
Führen Sie die umgekehrte Berechnung durch und aktualisieren Sie den Gradienten, um den Fehler wie folgt zu reduzieren:
mlr.cleargrads() #Gradienteninitialisierung
loss.backward() #Umgekehrte Berechnung
optimizer.update() #Verlaufsaktualisierung
Mal sehen, dass sich der Steigungswert geändert hat.
mlr[0].W.data, mlr[0].b.data
(array([[ 0.51864076, 0.08801924, -0.63399327]], dtype=float32),
array([-0.05653327], dtype=float32))
Wiederholen Sie die obige Berechnung, bis der Verlust konvergiert.
%time
for i in range(50):
Y_pred = mlr(X_test) #Vorwärtsberechnung
loss = F.mean_squared_error(Y_pred, Y_train) #Fehlerberechnung
mlr.cleargrads() #Gradienteninitialisierung
loss.backward() #Umgekehrte Berechnung
optimizer.update() #Verlaufsaktualisierung
CPU times: user 3 µs, sys: 1 µs, total: 4 µs
Wall time: 8.11 µs
Stellen Sie sicher, dass der Verlust reduziert ist.
loss
variable(0.15386367)
vom Anfang bis zum Ende
Der obige Fluss kann wie folgt zusammengefasst werden.
%time
import numpy as np
import chainer.links as L
import chainer.functions as F
from chainer import Sequential
from chainer import optimizers
from sklearn import datasets
iris = datasets.load_iris()
data = iris.data.astype(np.float32)
X = data[:, :3]
Y = data[:, 3].reshape(len(data), 1)
index = np.arange(Y.size)
X_train = X[index[index % 2 != 0], :]
X_test = X[index[index % 2 == 0], :]
Y_train = Y[index[index % 2 != 0], :]
Y_test = Y[index[index % 2 == 0], :]
n_input = 3
n_output = 1
mlr = Sequential(
L.Linear(n_input, n_output)
)
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(mlr)
loss_history = []
for i in range(100):
Y_pred = mlr(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
loss_history.append(np.mean(loss.data))
mlr.cleargrads()
loss.backward()
optimizer.update()
CPU times: user 2 µs, sys: 1e+03 ns, total: 3 µs
Wall time: 4.77 µs
loss
variable(0.05272739)
mlr[0].W.data, mlr[0].b.data
(array([[ 0.11841334, -0.2642416 , 0.324636 ]], dtype=float32),
array([0.08475045], dtype=float32))
Ich habe den Wert des Verlusts für jede iterative Berechnung aufgezeichnet, daher werde ich ihn veranschaulichen und prüfen, ob der Verlust konvergiert hat.
%matplotlib inline
import matplotlib.pyplot as plt
plt.plot(loss_history)
[<matplotlib.lines.Line2D at 0x7f2e08bfcbe0>]
Es scheint, dass es konvergiert hat. Schauen wir uns nun das y-y-Diagramm an, in dem die vorhergesagten und gemessenen Werte verglichen werden. Je näher es an der Diagonale liegt, desto besser ist die Vorhersage.
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(6,6))
plt.scatter(Y_train.flatten(), mlr(X_train).data.flatten(), alpha=0.5, label='train')
plt.plot([min(Y), max(Y)], [min(Y), max(Y)])
plt.grid()
plt.legend()
plt.xlabel('Observed')
plt.ylabel('Predicted')
plt.show()
Logistische Regression (LR)
Als nächstes führen wir eine logistische Regression durch, eine Methode zur Rückkehr zur Sigmoidfunktion (logistische Funktion), die auch als Klassifizierungsmethode verwendet wird.
Ayame-Daten
Verwenden wir dieses Mal die vier Messdaten von Ayame als erklärende Variable und die Sorten von Ayame (3 Typen) als Zielvariable.
import numpy as np
from sklearn import datasets
iris = datasets.load_iris() #Irisdaten lesen
X = iris.data.astype(np.float32) #4 Variablen als erklärende Variablen
Y = iris.target #Ayame-Sorten (3 Arten) als objektive Variablen
#Eine Sorte Iris-In heißen Vektor konvertieren.
Y_ohv = np.zeros(3 * Y.size).reshape(Y.size, 3).astype(np.float32)
for i in range(Y.size):
Y_ohv[i, Y[i]] = 1.0 # one-hot vector
#Die ungeraden Daten seien die Lehrerdaten und die geraden Daten die Testdaten.
index = np.arange(Y.size)
X_train = X[index[index % 2 != 0], :] #Erklärende Variable (Lehrerdaten)
X_test = X[index[index % 2 == 0], :] #Erklärende Variable (Testdaten)
Y_train = Y_ohv[index[index % 2 != 0], :] #Zielvariable eins-heißer Vektor (Lehrerdaten)
Y_test = Y_ohv[index[index % 2 == 0], :] #Zielvariable eins-heißer Vektor (Testdaten)
Y_ans_train = Y[index[index % 2 != 0]] #Objektive Variable (Lehrerdaten)
Y_ans_test = Y[index[index % 2 == 0]] #Zielvariable (Testdaten)
Definition des neuronalen Netzes
from chainer import Sequential
import chainer.links as L
import chainer.functions as F
n_input = 4 #Eingabe ist 4 Variablen
n_output = 3 #Die Ausgabe besteht aus 3 Variablen
lr = Sequential(
L.Linear(n_input, n_output), #Lineare Transformation
F.sigmoid, #Sigmaid-Funktion
F.softmax #Softmax-Funktion, die in eine positive reelle Zahl umgewandelt wird, deren Summe 1 ist.
)
Optimierung
from chainer import optimizers
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(lr)
<chainer.optimizers.sgd.SGD at 0x7f2e0878b7b8>
Y_pred = lr(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
loss
variable(0.21429048)
lr.cleargrads()
loss.backward()
optimizer.update()
Y_pred = lr(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
loss
variable(0.21422786)
%time
for i in range(50):
Y_pred = lr(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
lr.cleargrads()
loss.backward()
optimizer.update()
CPU times: user 7 µs, sys: 1 µs, total: 8 µs
Wall time: 28.1 µs
loss
variable(0.21126282)
vom Anfang bis zum Ende
Der obige Fluss kann wie folgt zusammengefasst werden.
%time
import numpy as np
import chainer.links as L
import chainer.functions as F
from chainer import Sequential
from chainer import optimizers
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data.astype(np.float32)
Y = iris.target
Y_ohv = np.zeros(3 * Y.size).reshape(Y.size, 3).astype(np.float32)
for i in range(Y.size):
Y_ohv[i, Y[i]] = 1.0 # one-hot vector
index = np.arange(Y.size)
X_train = X[index[index % 2 != 0], :]
X_test = X[index[index % 2 == 0], :]
Y_train = Y_ohv[index[index % 2 != 0], :]
Y_test = Y_ohv[index[index % 2 == 0], :]
Y_ans_train = Y[index[index % 2 != 0]]
Y_ans_test = Y[index[index % 2 == 0]]
n_input = 4
n_output = 3
lr = Sequential(
L.Linear(n_input, n_output),
F.sigmoid,
F.softmax
)
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(lr)
loss_history = []
for i in range(100000):
Y_pred = lr(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
loss_history.append(np.mean(loss.data))
lr.cleargrads()
loss.backward()
optimizer.update()
CPU times: user 2 µs, sys: 0 ns, total: 2 µs
Wall time: 5.01 µs
loss
variable(0.14579579)
Ich habe den Wert des Verlusts für jede iterative Berechnung aufgezeichnet, daher werde ich ihn veranschaulichen und prüfen, ob der Verlust konvergiert hat.
%matplotlib inline
import matplotlib.pyplot as plt
plt.plot(loss_history)
[<matplotlib.lines.Line2D at 0x7f2e06445080>]
lr[0].W.data, lr[0].b.data
(array([[ 0.7060194 , 1.5789627 , -2.7305322 , -1.5006719 ],
[-0.6907905 , -0.43505952, -0.78199637, -0.06515903],
[-1.7571408 , -2.1365883 , 2.8683107 , 2.772224 ]],
dtype=float32),
array([ 0.2556363 , -0.15823539, -0.9368208 ], dtype=float32))
Da die letzte Schicht eine Softmax-Funktion ist, die die Summe in eine positive reelle Zahl umwandelt, kann die Ausgabe als "die Wahrscheinlichkeit angesehen werden, dass sie als solche angesehen werden kann". Lassen Sie uns die richtige Antwortrate finden, wenn die Sorte mit der maximalen Wahrscheinlichkeit die "vorhergesagte Sorte" ist.
Y_pred = lr(X_train)
nrow, ncol = Y_pred.data.shape
count = 0
for i in range(nrow):
cls = np.argmax(Y_pred.data[i, :])
if cls == Y_ans_train[i]:
count += 1
print(count, " / ", nrow, " = ", count / nrow)
50 / 75 = 0.6666666666666666
Mehrschichtiges Perzeptron (MLP)
Bisher habe ich mit Chainer lineare multiple Regressions- und logistische Regressionsmodelle erstellt. Wenn Sie die Schicht verdicken, wird sie auf die gleiche Weise zu "tiefem Lernen". Das einfachste Modell für tiefes Lernen ist das mehrschichtige Perzeptron.
Klassifizierung nach MLP
%time
import numpy as np
from chainer import Sequential
from chainer import optimizers
import chainer.links as L
import chainer.functions as F
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data.astype(np.float32)
Y = iris.target
Y_ohv = np.zeros(3 * Y.size).reshape(Y.size, 3).astype(np.float32)
for i in range(Y.size):
Y_ohv[i, Y[i]] = 1.0 # one-hot vector
index = np.arange(Y.size)
X_train = X[index[index % 2 != 0], :]
X_test = X[index[index % 2 == 0], :]
Y_train = Y_ohv[index[index % 2 != 0], :]
Y_test = Y_ohv[index[index % 2 == 0], :]
Y_ans_train = Y[index[index % 2 != 0]]
Y_ans_test = Y[index[index % 2 == 0]]
n_input = 4
n_hidden = 6
n_output = 3
mlp = Sequential(
L.Linear(n_input, n_hidden),
F.sigmoid,
L.Linear(n_hidden, n_output),
F.softmax
)
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(mlp)
loss_history = []
for i in range(100000):
Y_pred = mlp(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
loss_history.append(np.mean(loss.data))
mlp.cleargrads()
loss.backward()
optimizer.update()
CPU times: user 3 µs, sys: 0 ns, total: 3 µs
Wall time: 5.48 µs
loss
variable(0.01375966)
%matplotlib inline
import matplotlib.pyplot as plt
plt.plot(loss_history)
[<matplotlib.lines.Line2D at 0x7f2e08746fd0>]
Y_pred = mlp(X_train)
nrow, ncol = Y_pred.data.shape
count = 0
for i in range(nrow):
cls = np.argmax(Y_pred.data[i, :])
if cls == Y_ans_train[i]:
count += 1
print(count, " / ", nrow, " = ", count / nrow)
74 / 75 = 0.9866666666666667
Rückgabe per MLP
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
data = iris.data.astype(np.float32)
X = data[:, :3]
Y = data[:, 3].reshape(len(data), 1)
index = np.arange(Y.size)
X_train = X[index[index % 2 != 0], :]
X_test = X[index[index % 2 == 0], :]
Y_train = Y[index[index % 2 != 0], :]
Y_test = Y[index[index % 2 == 0], :]
%time
import numpy as np
from chainer import Sequential
from chainer import optimizers
import chainer.links as L
import chainer.functions as F
n_input = 3
n_hidden = 6
n_output = 1
mlpr = Sequential(
L.Linear(n_input, n_hidden),
F.sigmoid,
L.Linear(n_hidden, n_output)
)
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(mlpr)
loss_history = []
for i in range(10000):
Y_pred = mlpr(X_train)
loss = F.mean_squared_error(Y_pred, Y_train)
loss_history.append(np.mean(loss.data))
mlpr.cleargrads()
loss.backward()
optimizer.update()
CPU times: user 4 µs, sys: 0 ns, total: 4 µs
Wall time: 8.82 µs
loss
variable(0.04921096)
%matplotlib inline
import matplotlib.pyplot as plt
plt.plot(loss_history)
[<matplotlib.lines.Line2D at 0x7f2e064200f0>]
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(6,6))
plt.scatter(Y_train.flatten(), mlpr(X_train).data.flatten(), alpha=0.5, label='train')
plt.plot([min(Y), max(Y)], [min(Y), max(Y)])
plt.grid()
plt.legend()
plt.xlabel('Observed')
plt.ylabel('Predicted')
plt.show()
Auto Encoder (AE)
Ein Autoencoder ist ein neuronales Netzwerk, das zu sich selbst zurückkehrt. Der Wandler von Eingangsschicht zu Zwischenschicht wird als Codierercodierer bezeichnet, und der Wandler von Zwischenschicht zu Ausgangsschicht wird als Decodiererdecodierer bezeichnet. "Dimensionsreduktion" (Dimensionsreduktion) kann durchgeführt werden, indem die Anzahl der Neuronen in der mittleren Schicht auf weniger als die Eingabedaten reduziert wird.
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data.astype(np.float32)
%time
import numpy as np
from chainer import Sequential
from chainer import optimizers
import chainer.links as L
import chainer.functions as F
n_input = 4
n_hidden = 2
n_output = 4
ae = Sequential(
L.Linear(n_input, n_hidden),
F.sigmoid,
L.Linear(n_hidden, n_output),
)
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(ae)
loss_history = []
for i in range(10000):
X_pred = ae(X)
loss = F.mean_squared_error(X_pred, X)
loss_history.append(np.mean(loss.data))
ae.cleargrads()
loss.backward()
optimizer.update()
CPU times: user 5 µs, sys: 0 ns, total: 5 µs
Wall time: 9.54 µs
loss
variable(0.09372737)
%matplotlib inline
import matplotlib.pyplot as plt
plt.plot(loss_history)
[<matplotlib.lines.Line2D at 0x7f2e06699a58>]
Zeigen Sie die auf die mittlere Ebene projizierten Daten an
latent = F.sigmoid(ae[0](X))
%matplotlib inline
import matplotlib.pyplot as plt
plt.scatter(latent.data[0:50, 0], latent.data[0:50, 1], alpha=0.5)
plt.scatter(latent.data[50:100, 0], latent.data[50:100, 1], alpha=0.5)
plt.scatter(latent.data[100:150, 0], latent.data[100:150, 1], alpha=0.5)
plt.grid()
Recommended Posts