J'ai essayé d'implémenter Extreme Learning Machine

Qu'est-ce que Extreme Learning Machine (ELM)?

L'ELM est une forme spéciale de perceptron à action directe. Il a une couche cachée, mais le poids de la couche cachée est déterminé de manière aléatoire, et le poids de la couche de sortie est déterminé à l'aide d'une matrice pseudo inverse. En termes d'image, la couche cachée revient à créer de nombreux extracteurs d'entités aléatoires et à sélectionner des entités dans la couche de sortie.

ELM présente les caractéristiques suivantes.

• Comme ce n'est qu'une pseudo matrice inverse qui est en cours de résolution, il est possible de trouver la solution à grande vitesse.
• Problème convexe (pas de solution locale)
• La fonction arbitraire peut être approximée (identique à Perceptron ordinaire)
• Toute activation peut être utilisée (pas besoin d'être différenciée)

la mise en oeuvre

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)

tester

Je vais l'essayer avec des iris pour le moment.

Méthode

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 ")

résultat

Conclusion

• Comme il y a peu de paramètres à falsifier, le réglage semble plus facile qu'avec un réseau neuronal normal.
• Bien qu'il ait été mentionné dans l'article original que les performances de généralisation sont élevées, elles sont généralement sur-ajustées.
• L'ajustement et la transformation sont incroyablement rapides, il semble donc avoir diverses utilisations.