[PYTHON] Ich habe versucht, mein Verständnis zu vertiefen, indem ich einen eigenen Diskriminator erstellt habe, der Binärwerte mithilfe logistischer Regression klassifizieren kann.

Einführung

Dieses Mal werde ich die Inhalte zusammenfassen, die mein Verständnis vertieft haben, indem ich logistische Regression implementiert habe, ohne ein Framework wie Scicit Learn zu verwenden.

Der Umriss ist unten.

• Regressionsanalyse und logistische Regression
• Implementieren Sie eine logistische Regression und versuchen Sie zu verstehen

Regressive Analyse und logistische Regression

Bevor wir die logistische Regression diskutieren, fassen wir die Regressionsanalyse zusammen. Regression ist der Ausdruck der Zielvariablen $ y $ unter Verwendung der erklärenden Variablen $ x $. Und dieses $ y $ nimmt aufeinanderfolgende Werte an. Wenn $ x $ eindimensional ist, wird es als einfache Regression bezeichnet, und wenn es zweidimensional oder mehr ist, wird es als multiple Regression bezeichnet. Als Beispiel

• Vorhersage des Grundstückspreises (Zielvariable) anhand der Größe der Landfläche (erklärende Variable)
• Vorhersage der Anzahl der Ladenbesucher (Zielvariable) aus den Werbekosten (erklärende Variable)
• Vorhersage des Gewichts (Zielvariable) aus der Höhe (erklärende Variable)

Und so weiter. Sie sehen, dass der Grundstückspreis und die Anzahl der Besucher kontinuierliche Werte sind. Die logistische Regression ist andererseits eine Methode zum Schätzen der Wahrscheinlichkeit der Zugehörigkeit zu einer Klasse (z. B. ob eine E-Mail Spam ist) anhand erklärender Variablen. Führen Sie wie bei der linearen Regression lineare Berechnungen basierend auf erklärenden Variablen durch. Anstatt das Berechnungsergebnis unverändert auszugeben, gibt ** die Logistik des Ergebnisses zurück. ** ** **

Logistisch bedeutet, einen Wert von 0 bis 1 auszugeben. Zu diesem Zeitpunkt wird die für die logistische Regression verwendete Funktion als Sigmoidfunktion bezeichnet.

f(x) = \frac{1}{1+e^{-x}} \\
x = β_0×α_0 +β_1

$ β_0 × α_0 + β_1 $ ist die in der linearen Regression verwendete Regressionsgleichung ($ β_0, β_1 $ sind Konstanten und $ α_0 $ sind Variablen). Dieses Mal habe ich es als linearen Ausdruck von $ \ alpha $ als Beispiel angegeben. $ f (x) $ gibt 0 zu 1 zurück.

Der Unterschied zwischen linearer Regression und logistischer Regression wird im Folgenden kurz dargestellt.

Implementieren Sie logistische Regression und versuchen Sie zu verstehen

Übrigens möchte ich diesmal mit der logistischen Regression fortfahren und meine eigene erstellen, ohne ein Framework wie sckit learn zu verwenden.

1. Generiere 100 zufällige Punkte (2D)
2. Klassifizieren Sie die obigen 100 Punkte anhand einer eindimensionalen Geraden (diesmal f (x, y) = 2x + 3y-1) mit f (x, y)> 0 oder <0.
3. Erstellen Sie einen geeigneten Klassifikator $ w $ (3D-Vektor). Ausgabe 0 bis 1 der Kombination $ w und φ $ mit der Basisfunktion $ φ = (x, y, 1) $ mit der Sigmoidfunktion
4. Aktualisieren Sie den Parameter in 3. mit der probabilistischen Abstiegsmethode, um f (x, y) unterscheidbar zu machen.
5. Der Diskriminator kann f (x, y) identifizieren.

Generiere 100 zufällige Punkte (2D)

Generieren Sie zunächst 100 zufällige Punkte in einer zweidimensionalen Ebene mit der Methode np.random.randn () für x- und y-Punkte.

logistic.ipynb

N = 100#Anzahl der Datenpunkte
np.random.seed(0)#Feste Zufallszahlenfolge für Datenpunkte
X = np.random.randn(N, 2)#Generieren Sie eine zufällige N × 2-Matrix=N zufällige Punkte im 2D-Raum

Basierend auf einer eindimensionalen Geraden (diesmal f (x, y) = 2x + 3y-1) werden die obigen 100 Punkte durch f (x, y)> 0 oder <0 klassifiziert.

Zeichnen Sie als nächstes eine eindimensionale Gerade (diesmal f (x, y) = 2x + 3y-1) und klassifizieren Sie zufällige 100 Punkte nach f (x, y)> 0 oder <0.

logistic.ipynb

def f(x, y):
    return 2 * x + 3 * y - 1  #Wahre Trennebene 2x+ 3y = 1

T = np.array([ 1 if f(x, y) > 0 else 0 for x, y in X])
plt.figure(figsize=(6, 6)) 
plt.plot(X[T==1,0], X[T==1,1], 'o', color='red')
plt.plot(X[T==0,0], X[T==0,1], 'o', color='blue')
plt.show()

Ich sah eine gerade Linie, die ich klassifizieren wollte.

Erstellen Sie einen geeigneten Klassifikator $ w $ (dreidimensionaler Vektor). Ausgabe 0 bis 1 der Kombination $ w und φ $ mit der Basisfunktion $ φ = (x, y, 1) $ mit der Sigmoidfunktion

Als nächstes erzeugen Sie einen dreidimensionalen Vektor $ w $ als Klassifikator. Definieren Sie dann $ φ = (x, y, 1) $ als Basisfunktion. Finden Sie dieses innere Produkt (multipliziert mit jeder Komponente). Bei linearen Regressionsproblemen wird dieser interne Produktwert zur Vorhersage verwendet. Bei der logistischen Regression ** geht es jedoch darum, den Wert von 0 bis 1, der durch Einsetzen dieses internen Produktwerts in die Sigmoidfunktion erhalten wird, weiter vorherzusagen. ** ** ** Die tatsächliche Implementierung ist wie folgt.

logistic.ipynb

np.random.seed() #Zufallszahl initialisieren
w = np.random.randn(3)  #Initialisieren Sie die Parameter nach dem Zufallsprinzip

def phi(x, y):#Basisfunktion
    return np.array([x, y, 1])

seq = np.arange(-3, 3, 0.1)
xlist, ylist = np.meshgrid(seq, seq)
zlist = [sigmoid(np.inner(w, phi(x, y))) for x, y in zip(xlist, ylist)]　#Intern Produktparameter und Basisfunktion und Sigmoidfunktion zuordnen
plt.imshow(zlist, extent=[-3,3,-3,3], origin='lower', cmap='bwr')
plt.show()

Die vom Klassifikator erhaltene Verteilung ist in der obigen Abbildung dargestellt. Ungefähr 0,5 oder mehr (= [1]) sind rot und 0,5 oder weniger (= [0]) sind blau (korrekter Bereich für Lehrerdaten). Es ist erfolgreich, wenn dieser unterteilte Bereich mit dem durch f (x, y) bestimmten Bereich übereinstimmt.

Aktualisieren Sie den Parameter in 3. mit der probabilistischen Gradientenabstiegsmethode, um f (x, y) unterscheidbar zu machen.

Aktualisieren Sie dann die Klassifikatorparameter mit der probabilistischen Gradientenabstiegsmethode. Die stochastische Gradientenabstiegsmethode ist ein Beispiel für die Erklärung in einem neuronalen Netzwerk, wird hier jedoch zusammengefasst.

Ich habe versucht, die Lernfunktion im neuronalen Netzwerk sorgfältig zu verstehen, ohne die Bibliothek für maschinelles Lernen zu verwenden (zweite Hälfte). https://qiita.com/Fumio-eisan/items/7507d8687ca651ab301d

Hier ist die Parameteraktualisierungsformel für die stochastische Gradientenabstiegsmethode in der logistischen Regression.

\begin{align}
w_{i+1}& = w_i -\eta ・\frac{δE}{δw}\\
&= w_i -\eta ・(y_n-t_n)φ(x_n)
\end{align}

Zu diesem Zeitpunkt ist $ w $ der Diskriminatorparameter, $ \ eta $ die Lernrate, $ y $ die Wahrscheinlichkeit von 0 zu 1, die durch die Sigmoidfunktion erhalten wird, und $ t $ sind die Lehrerdaten, die 0 oder 1 angeben, $ φ ( x) $ ist die Basisfunktion.

Ich habe die Formel schnell transformiert, aber die Tatsache, dass die folgenden Transformationen durchgeführt werden können, ist eine Transformation, die der logistischen Regression eigen ist. ** ** **

\frac{δE}{δw}=(y_n-t_n)φ(x_n)

In einem neuronalen Netzwerk usw. ist es sehr mathematisch kompliziert, den Gradienten dieser Verlustfunktion zu finden, und es besteht die Sorge, dass der Rechenaufwand zunimmt. Daher wird ein Verfahren wie das Fehlerrückausbreitungsverfahren verwendet. In der logistischen Regression ist es möglich, sie als unerwartet einfache Formel auszudrücken und gleichzeitig die Eigenschaften der Sigmoidfunktion zu verwenden.

In Bezug auf die Formelumwandlung wird die folgende URL sehr sorgfältig erklärt, daher wäre es sehr dankbar, wenn Sie darauf verweisen könnten.

Referenz-URL http://gihyo.jp/dev/serial/01/machine-learning/0019

Übrigens, wenn es tatsächlich implementiert ist, wird es wie folgt sein. Dieses Mal wird die Lernrate anfänglich auf 0,1 eingestellt. Und diesmal senken wir die Lernrate schrittweise, um die Konvergenz zu erleichtern.

logistic.ipynb

#Anfangswert der Lernrate
eta = 0.1

for i in range(len(xlist)):
    list = range(N)
    
    for n in list:
        x_n, y_n = X[n, :]
        t_n = T[n]

        #Vorhersagewahrscheinlichkeit
        feature = phi(x_n, y_n)
        predict = sigmoid(np.inner(w, feature))
        w -= eta * (predict - t_n) * feature

    #Reduzieren Sie die Lernrate für jede Iteration
    eta *= 0.9

Das berechnete Ergebnis ist in der Abbildung dargestellt.

logistic.ipynb

#Streudiagramm und vorhergesagte Verteilung zeichnen
plt.figure(figsize=(6, 6)) 
plt.imshow(zlist, extent=[-3,3,-3,3], origin='lower', cmap='GnBu')
plt.plot(X[T==1,0], X[T==1,1], 'o', color='red')
plt.plot(X[T==0,0], X[T==0,1], 'o', color='blue')
plt.show()

Wir konnten erfolgreich einen Klassifikator erstellen, der die blauen und roten Bereiche zufälliger Punkte trennen kann.

Am Ende

Dieses Mal habe ich meinen eigenen logistischen Regressionsdiskriminator erstellt. Es war interessant zu verfolgen, wie die Verlustfunktion mathematisch optimiert werden kann.

Das vollständige Programm finden Sie hier. https://github.com/Fumio-eisan/logistic_20200411