[PYTHON] Ich habe versucht, die Extreme-Lernmaschine zu implementieren

Was ist Extreme Learning Machine (ELM)?

ELM ist eine spezielle Form des Feed-Forward-Perzeptrons. Es hat eine verborgene Schicht, aber das Gewicht der verborgenen Schicht wird zufällig bestimmt, und das Gewicht der Ausgangsschicht wird unter Verwendung einer pseudo-inversen Matrix bestimmt. In Bezug auf das Bild ist die verborgene Ebene so, als würde man viele zufällige Merkmalsextraktoren erstellen und Merkmale in der Ausgabeebene auswählen.

ELM hat die folgenden Eigenschaften.

• Da nur eine pseudo-inverse Matrix gelöst wird, ist es möglich, die Lösung mit hoher Geschwindigkeit zu finden.
• Konvexes Problem (keine lokale Lösung)
• Beliebige Funktion kann angenähert werden (wie gewöhnliches Perceptron)
• Jede Aktivierung kann verwendet werden (keine Differenzierung erforderlich)

Implementierung

import numpy as np


class ExtremeLearningMachine(object):
    def __init__(self, n_unit, activation=None):
        self._activation = self._sig if activation is None else activation
        self._n_unit = n_unit

    @staticmethod
    def _sig(x):
        return 1. / (1 + np.exp(-x))

    @staticmethod
    def _add_bias(x):
        return np.hstack((x, np.ones((x.shape[0], 1))))

    def fit(self, X, y):
        self.W0 = np.random.random((X.shape[1], self._n_unit))
        z = self._add_bias(self._activation(X.dot(self.W0)))
        self.W1 = np.linalg.lstsq(z, y)[0]

    def transform(self, X):
        if not hasattr(self, 'W0'):
            raise UnboundLocalError('must fit before transform')
        z = self._add_bias(self._activation(X.dot(self.W0)))
        return z.dot(self.W1)

    def fit_transform(self, X, y):
        self.W0 = np.random.random((X.shape[1], self._n_unit))
        z = self._add_bias(self._activation(X.dot(self.W0)))
        self.W1 = np.linalg.lstsq(z, y)[0]
        return z.dot(self.W1)

Prüfung

Ich werde es vorerst mit Iris versuchen.

Methode

from sklearn import datasets

iris = datasets.load_iris()
ind = np.random.permutation(len(iris.data))

y = np.zeros((len(iris.target), 3))
y[np.arange(len(y)), iris.target] = 1

acc_train = []
acc_test = []
N = [5, 10, 15, 20, 30, 40, 80, 160]
for n in N:
    elm = ExtremeLearningMachine(n)
    elm.fit(iris.data[ind[:100]], y[ind[:100]])
    acc_train.append(np.average(np.argmax(elm.transform(iris.data[ind[:100]]), axis=1) == iris.target[ind[:100]]))
    acc_test.append(np.average(np.argmax(elm.transform(iris.data[ind[100:]]), axis=1) == iris.target[ind[100:]]))
plt.plot(N, acc_train, c='red', label='train')
plt.plot(N, acc_test, c='blue', label='test')
plt.legend(loc=1)
plt.savefig("result.png ")

Ergebnis

Fazit

• Da nur wenige Parameter manipuliert werden müssen, scheint die Abstimmung einfacher zu sein als bei einem normalen neuronalen Netzwerk.
• Obwohl im Originalpapier erwähnt wurde, dass die Generalisierungsleistung hoch ist, ist sie normalerweise überpasst.
• Sowohl Fit als auch Transformation sind wahnsinnig schnell, daher scheint es verschiedene Verwendungszwecke zu haben.