Diesmal habe ich eine verwandte Vektormaschine implementiert. Es ist im Vergleich zur Support-Vektor-Maschine nicht so berühmt, aber es scheint Vorteile zu haben, beispielsweise, dass der Ausgabewert eine Wahrscheinlichkeit ist. Ich denke, dass viele Leute es verwenden werden, wenn es sich um Scikit-Learn handelt (eine Bibliothek, die Methoden des maschinellen Lernens implementiert), aber ich habe es nicht implementiert, weil Microsoft ein Patent hat.

Verwandte Vektormaschine

Kapitel 7 ist "Kernel-Maschinen mit spärlichen Lösungen", aber die Diskussion verwandter Vektor-Maschinen ist im Allgemeinen ohne Verwendung der Kernel-Methode gültig. Parameter wie lineare Regression{\bf w}Vorherige Verteilung vonp({\bf w}|\alpha)=\mathcal{N}({\bf w}|{\bf 0},\alpha^{-1}I)Als ein Superparameter\alphaIch habe das eingestellt

p({\bf w}|{\bf \alpha}) = \prod_i\mathcal{N}(w_i|0,\alpha_i^{-1})

** Führen Sie für jeden Parameter Superparameter ein **. Danach wird der Superparameter $ {\ bf \ alpha} $ auf dieselbe Weise geschätzt wie Kapitel 3 Evidence Approximation. Das geschätzte $ \ alpha $ hat viele Komponenten, die unendlich werden. Dies bedeutet, dass die Varianz des Parameters $ w $ $ \ alpha ^ {-1} $ nahe bei 0 liegt und der Parameter $ w $ eine steile Verteilung mit dem Durchschnitt der ursprünglich festgelegten vorherigen Verteilung von 0 ist. Der Wert des Parameters $ w $ wird spärlich und Features mit hoher Relevanz werden automatisch ausgewählt (automatische Relevanzbestimmung).

Implementierung

Bibliothek

Auch hier ist der Algorithmus-Teil nur mit numpy codiert.

import matplotlib.pyplot as plt
import numpy as np

Ganzer Code

`relevance_vector_regression.py`


import matplotlib.pyplot as plt
import numpy as np


class RelevanceVectorRegression(object):

    def __init__(self, alpha=1., beta=1.):
        self.alpha = alpha
        self.beta = beta

    def _kernel(self, x, y):
        return np.exp(-10 * (x - y) ** 2)

    def fit(self, x, t, iter_max=1000):
        self.x = x
        self.t = t
        N = len(x)
        Phi = self._kernel(*np.meshgrid(x, x))
        self.alphas = np.zeros(N) + self.alpha
        for _ in xrange(iter_max):
            params = np.hstack([self.alphas, self.beta])
            self.precision = np.diag(self.alphas) + self.beta * Phi.T.dot(Phi)
            self.covariance = np.linalg.inv(self.precision)
            self.mean = self.beta * self.covariance.dot(Phi.T).dot(t)
            gamma = 1 - self.alphas * np.diag(self.covariance)
            self.alphas = gamma / np.square(self.mean)
            self.alphas = np.clip(self.alphas, 0, 1e10)
            self.beta = (N - np.sum(gamma)) / np.sum((t - Phi.dot(self.mean)) ** 2)
            if np.allclose(params, np.hstack([self.alphas, self.beta])):
                break
        else:
            print "paramters may not have converged"

    def predict_dist(self, x):
        K = self._kernel(*np.meshgrid(x, self.x, indexing='ij'))
        mean = K.dot(self.mean)
        var = 1 / self.beta + np.sum(K.dot(self.covariance) * K, axis=1)
        return mean, np.sqrt(var)


def create_toy_data(func, low=0., high=1., n=10, std=0.1):
    x = np.random.uniform(low, high, n)
    t = func(x) + np.random.normal(scale=std, size=n)
    return x, t


def main():

    def func(x):
        return np.sin(2 * np.pi * x)

    x, t = create_toy_data(func, n=10)
    plt.scatter(x, t, color="blue", alpha=0.5, label="observation")

    regression = RelevanceVectorRegression()
    regression.fit(x, t)
    relevance_vector = np.abs(regression.mean) > 0.1

    x_test = np.linspace(0, 1, 100)
    plt.scatter(x[relevance_vector], t[relevance_vector], color="green", s=100, marker="D", label="relevance vector")
    plt.plot(x_test, func(x_test), color="blue", label="sin($2\pi x$)")
    y, y_std = regression.predict_dist(x_test)
    plt.plot(x_test, y, color="red", label="predict_mean")
    plt.fill_between(x_test, y - y_std, y + y_std, color="pink", alpha=0.5, label="predict_std")
    plt.legend()
    plt.show()


if __name__ == '__main__':
    main()

Ergebnis

Als Ergebnis des Zurückziehens der blauen und grünen Punkte als Trainingsdaten mit der zugehörigen Vektormaschine ist das Ergebnis wie in der folgenden Abbildung gezeigt (Reproduktion von PRML Abbildung 7.9). Die grünen Punkte werden als verwandte Vektoren dargestellt.

Am Ende

Es scheint, dass es schnellere Vorhersagen treffen kann, während es die gleiche Generalisierungsleistung wie die Support-Vektor-Maschine aufweist. Daher möchte ich diese Gelegenheit nutzen, um nicht nur die Support-Vektor-Maschine, sondern auch die zugehörige Vektor-Maschine zu verwenden. Es ist auch ein schöner Vorteil, die Ausgabe wie Bayes behandeln und die Verteilung bewerten zu können. Es ist jedoch schade, dass die prädiktive Varianz gegen die menschliche Intuition klein wird, wenn keine Trainingsdatenpunkte vorhanden sind. Dieses Mal habe ich das Regressionsproblem mit der zugehörigen Vektormaschine gelöst, aber es kann natürlich mithilfe der logistischen Sigmoid-Funktion auf das Klassifizierungsproblem erweitert werden. Wenn ich eine Chance habe, würde ich das auch gerne umsetzen.

PRML Kapitel 7 Verwandte Vector Machine Python-Implementierung für Regressionsprobleme

Verwandte Vektormaschine