[PYTHON] 100 Amateur-Sprachverarbeitungsklopfen: 73
Es ist ein Herausforderungsrekord von 100 Sprachverarbeitungsklopfen 2015. Die Umgebung ist Ubuntu 16.04 LTS + Python 3.5.2 : : Anaconda 4.1.1 (64-Bit). Klicken Sie hier, um eine Liste der vergangenen Schläge anzuzeigen (http://qiita.com/segavvy/items/fb50ba8097d59475f760).
Kapitel 8: Maschinelles Lernen
In diesem Kapitel wird die Aufgabe, Sätze mithilfe des Satzpolaritätsdatensatzes v1.0 von Movie Review Data, veröffentlicht von Bo Pang und Lillian Lee (Polaritätsanalyse), in positive (positive) oder negative (negative) zu klassifizieren. Arbeiten Sie daran.
73. Lernen
Lernen Sie das logistische Regressionsmodell anhand der in> 72 extrahierten Eigenschaften.
Der fertige Code:
main.py
# coding: utf-8
import codecs
import snowballstemmer
import numpy as np
fname_sentiment = 'sentiment.txt'
fname_features = 'features.txt'
fname_theta = 'theta.npy'
fencoding = 'cp1252' # Windows-1252 scheint
learn_alpha = 6.0 #Lernrate
learn_count = 1000 #Anzahl der Lerniterationen
stemmer = snowballstemmer.stemmer('english')
#Liste der Stoppwörter http://xpo6.com/list-of-english-stop-words/Aus dem CSV-Format
stop_words = (
'a,able,about,across,after,all,almost,also,am,among,an,and,any,are,'
'as,at,be,because,been,but,by,can,cannot,could,dear,did,do,does,'
'either,else,ever,every,for,from,get,got,had,has,have,he,her,hers,'
'him,his,how,however,i,if,in,into,is,it,its,just,least,let,like,'
'likely,may,me,might,most,must,my,neither,no,nor,not,of,off,often,'
'on,only,or,other,our,own,rather,said,say,says,she,should,since,so,'
'some,than,that,the,their,them,then,there,these,they,this,tis,to,too,'
'twas,us,wants,was,we,were,what,when,where,which,while,who,whom,why,'
'will,with,would,yet,you,your').lower().split(',')
def is_stopword(str):
'''Gibt zurück, ob das Zeichen ein Stoppwort ist
Fall ausgleichen
Rückgabewert:
Richtig für Stoppwörter, Falsch für anders
'''
return str.lower() in stop_words
def hypothesis(data_x, theta):
'''Hypothetische Funktion
data_Verwenden Sie für x Theta für Daten_Vorhersage y
Rückgabewert:
Vorhersagewertmatrix
'''
return 1.0 / (1.0 + np.exp(-data_x.dot(theta)))
def cost(data_x, theta, data_y):
'''Zielfunktion
data_Berechnen Sie die Differenz zwischen dem vorhergesagten Ergebnis und der richtigen Antwort für x
Rückgabewert:
Unterschied zwischen Vorhersage und korrekter Antwort
'''
m = data_y.size #Anzahl der Daten
h = hypothesis(data_x, theta) # data_Vorhersagewertmatrix von y
j = 1 / m * np.sum(-data_y * np.log(h) -
(np.ones(m) - data_y) * np.log(np.ones(m) - h))
return j
def gradient(data_x, theta, data_y):
'''Berechnung des Gefälles beim steilsten Abstieg
Rückgabewert:
Gradientenmatrix für Theta
'''
m = data_y.size #Anzahl der Daten
h = hypothesis(data_x, theta) # data_Vorhersagewertmatrix von y
grad = 1 / m * (h - data_y).dot(data_x)
return grad
def extract_features(data, dict_features):
'''Extrahieren Sie die Identität aus dem Text
Diktieren Sie aus dem Text_Extrahieren Sie die in den Funktionen und enthaltenen Funktionen
dict_features['(Identität)']Gibt eine Matrix mit der Position 1 zurück.
Das erste Element ist auf 1 festgelegt. Für Gewichte, die nicht der Natur entsprechen.
Rückgabewert:
Das erste Element und die Position des entsprechenden Elements+Matrix mit 1 als 1
'''
data_one_x = np.zeros(len(dict_features) + 1, dtype=np.float64)
data_one_x[0] = 1 #Das erste Element ist fest und 1 für Gewichte, die nicht der Natur entsprechen.
for word in data.split(' '):
#Entfernen Sie vorher und nachher leere Zeichen
word = word.strip()
#Stoppen Sie die Wortentfernung
if is_stopword(word):
continue
#Stemming
word = stemmer.stemWord(word)
#Identitätsindex abrufen, entsprechenden Teil der Matrix auf 1 setzen
try:
data_one_x[dict_features[word]] = 1
except:
pass # dict_Ignorieren Sie Funktionen, die nicht in Funktionen enthalten sind
return data_one_x
def load_dict_features():
'''features.Lesen Sie txt und erstellen Sie ein Wörterbuch, um die Identität in einen Index umzuwandeln
Der Indexwert basiert auf 1 Features.Entspricht der Zeilennummer in txt.
Rückgabewert:
Ein Wörterbuch, das Identitäten in Indizes konvertiert
'''
with codecs.open(fname_features, 'r', fencoding) as file_in:
return {line.strip(): i for i, line in enumerate(file_in, start=1)}
def create_training_set(sentiments, dict_features):
'''Erstellen Sie eine zu lernende Matrix und eine Matrix mit polaren Beschriftungen aus den richtigen Antwortdatenstimmungen
Die Größe des zu lernenden Zeilenbeispiels ist die Anzahl der Überprüfungen der richtigen Antwortdaten ×(Elementare Nummer+1)。
Der Wert der Spalte ist 1, wenn für jede Überprüfung eine geeignete Veranlagung vorliegt, andernfalls 0.
Der Index der Spaltenidentität ist diktiert_features['(Identität)']Es wird von entschieden.
Die erste Spalte ist immer 1 für Lerngewichte, die nicht der Natur entsprechen.
dict_Ignorieren Sie Features, die in Features nicht vorhanden sind.
Die Größe der Matrix der polaren Markierungen ist die Anzahl der Bewertungen x 1.
1 für positiven Inhalt und 0 für negativen Inhalt.
Rückgabewert:
Matrix gelernt werden,Matrix der polaren Markierungen
'''
#Matrix mit 0 initialisieren
data_x = np.zeros([len(sentiments), len(dict_features) + 1], dtype=np.float64)
data_y = np.zeros(len(sentiments), dtype=np.float64)
for i, line in enumerate(sentiments):
#Identitätsextraktion
data_x[i] = extract_features(line[3:], dict_features)
#Satz polare Etikettenmatrizen
if line[0:2] == '+1':
data_y[i] = 1
return data_x, data_y
def learn(data_x, data_y, alpha, count):
'''Logistische Regression lernen
Rückgabewert:
Ausgebildetes Theta
'''
theta = np.zeros(data_x.shape[1])
c = cost(data_x, theta, data_y)
print('\t Beginnen Sie zu lernen\tcost：{}'.format(c))
for i in range(1, count + 1):
grad = gradient(data_x, theta, data_y)
theta -= alpha * grad
#Berechnen Sie die Kosten und den maximalen Anpassungsbetrag von Theta und zeigen Sie den Fortschritt an (einmal in 100 Mal).
if i % 100 == 0:
c = cost(data_x, theta, data_y)
e = np.max(np.absolute(alpha * grad))
print('\t lernen(#{})\tcost：{}\tE:{}'.format(i, c, e))
c = cost(data_x, theta, data_y)
e = np.max(np.absolute(alpha * grad))
print('\t Lernen abgeschlossen(#{}) \tcost：{}\tE:{}'.format(i, c, e))
return theta
#Identitätswörterbuch lesen
dict_features = load_dict_features()
#Erstellen einer zu trainierenden Matrix und einer Matrix mit polaren Beschriftungen
with codecs.open(fname_sentiment, 'r', fencoding) as file_in:
data_x, data_y = create_training_set(list(file_in), dict_features)
#Lernen
print('Lernrate:{}\t Anzahl der Lernwiederholungen:{}'.format(learn_alpha, learn_count))
theta = learn(data_x, data_y, alpha=learn_alpha, count=learn_count)
#Ergebnisse speichern
np.save(fname_theta, theta)
Ausführungsergebnis:
Ausführungsergebnis
Lernrate: 6.0 Anzahl der Lernwiederholungen: 1000
Lernkosten starten: 0.6931471805599453
Lernen(#100) cost：0.4809284917412944 E:0.006248170735186127
Lernen(#200) cost：0.43188679850114775 E:0.003599155234198481
Lernen(#300) cost：0.4043113376254009 E:0.002616675715766214
Lernen(#400) cost：0.38547454091328076 E:0.0020805226234380772
Lernen(#500) cost：0.37135664408713015 E:0.0017952496476012821
Lernen(#600) cost：0.36017505743644285 E:0.0015873326040173347
Lernen(#700) cost：0.35098616931062043 E:0.0014288227472357999
Lernen(#800) cost：0.343231725184532 E:0.0013037591670736948
Lernen(#900) cost：0.33655507220582787 E:0.0012023865948793643
Lernen(#1000) cost：0.33071511988186225 E:0.0011184180264631118
Lernen abgeschlossen(#1000) cost：0.33071511988186225 E:0.0011184180264631118
Die trainierte Ergebnismatrix $ \ theta $ wird in "theta.npy" ausgegeben. Die Datei wird auf [GitHub] hochgeladen (https://github.com/segavvy/nlp100_Python/tree/master/73).
Installieren Sie NumPy
Zur Vorbereitung müssen Sie eine Bibliothek namens NumPy installieren, die Hochgeschwindigkeitsmatrixoperationen ausführen kann. Glücklicherweise schien es von Anaconda installiert worden zu sein, und ich konnte es so verwenden, wie es war, ohne etwas zu tun. Die offizielle Seite ist hier.
Vektorisierung
Der Grund, warum eine Hochgeschwindigkeitsmatrixberechnung durch NumPy erforderlich ist, besteht darin, dass der für die Lernarbeit des maschinellen Lernens erforderliche Rechenaufwand sehr groß ist. Wenn die Logik nicht implementiert wird, während die Logik durch eine Matrixberechnung durch die Vektorisierungsmethode ersetzt wird, ist die Lernzeit sehr lang. Weil es enden wird.
Die folgende Formel zum Lernen, die in Problem 72 verwendet wird, extrahiert beispielsweise 3.227 Identitäten, sodass n zu 3.227 wird.
In diesem Fall sind 3.227 Multiplikationen und 3.227 Additionen erforderlich, um y einmal zu berechnen. Normalerweise werden $ \ theta_0 $ ~ $ \ theta_ {3227} $ und $ x_1 $ ~ $ x_ {3227} $ aufgelistet. Während Sie mit der for-Anweisung 3.227-mal durchlaufen, multiplizieren Sie jede und addieren Sie sie zu $ y $. Es wäre schön zu gehen, aber es wird eine beträchtliche Zeit in Anspruch nehmen, da diese Formel während des Lernens viele Male berechnet wird.
Erstellen Sie daher anstelle von $ \ theta_0 $ ~ $ \ theta_ {3227} $ und $ x_1 $ ~ $ x_ {3227} $ eine Matrix und implementieren Sie sie, indem Sie das innere Produkt der Matrix verwenden. Das innere Produkt der Matrix wird berechnet, indem die Elemente jeder Matrix nacheinander multipliziert und addiert werden, sodass die Antwort dieselbe ist. Da es mit NumPy schneller ist, das innere Produkt der Matrix zu finden, als die Multiplikation und Addition der Listen mit der for-Anweisung zu wiederholen, beschleunigt dies das Lernen. Eine Matrix mit einer Zeile oder einer Spalte wird als Vektor bezeichnet, daher wird der Prozess der Erstellung einer Matrix als "Vektorisierung" bezeichnet.
Beim Vektorisieren gibt es eine Einschränkung. Es gibt insgesamt 3.228 $ \ theta $ von $ \ theta_0 $ bis $ \ theta_ {3227} $, während $ x $ eine von $ x_1 $ bis $ x_ {3227} $ fehlt. Das ist. Wenn Sie nicht mit den Zahlen übereinstimmen, können Sie das innere Produkt nicht erhalten. Daher bereiten wir $ x_0 $ vor, transformieren den Ausdruck wie folgt und implementieren ihn so, dass der Wert von $ x_0 $ immer 1 ist. Beachten Sie, dass $ x $ eins mehr ist als die Anzahl der Identitäten.
Die Matrix $ X $ und $ \ theta $ sehen folgendermaßen aus: Der Wert ist angemessen.
Jetzt kann $ y $ durch Matrixoperation durch $ X \ theta $ gefunden werden.
Die Methode zum Bearbeiten der Matrix mit NumPy ist in Englisch, aber Sie können sie grob verstehen, indem Sie sich das Schnellstart-Tutorial ansehen. Es gibt viele Kommentarartikel im Internet, bitte beziehen Sie sich auf sie.
Weitere Informationen zur Vektorisierung finden Sie in Junichiros Praktisches Niveau des maschinellen Lernens in einem Monat # 6 (Octave Practical Edition) und in Ken5scals [Für Anfänger] Einführung in die Vektorisierung beim maschinellen Lernen war leicht zu verstehen.
Warum Vektorisierung es schneller macht
Selbst wenn Sie es vektorisieren und NumPy es als Matrix berechnen lassen, sollte die Berechnung im Inneren dieselbe sein. Warum also nicht beschleunigen? Sie können denken, dass NumPy eine entwickelte Speicheranordnung von Matrixelementen hat, so dass es mit der Geschwindigkeit von C / C ++ berechnet werden kann, und es scheint erheblich schneller zu sein als das Berechnen während des Loopings in Python. ..
Da viele der Matrixoperationen intern unabhängig voneinander berechnet werden, können sie außerdem parallel und nicht sequentiell berechnet werden. Abhängig von der verwendeten Bibliothek können Sie daher eine Beschleunigung durch die GPU erwarten.
Anfänglich ist die GPU ein dedizierter Grafikchip, und im Gegensatz zum CPU-Kern, der versucht, erweiterte Aufgaben sequentiell und mit hoher Geschwindigkeit auszuführen, führt der GPU-Kern eine große Anzahl von Pixeldatenberechnungsaufgaben für die parallele Bildschirmanzeige aus. War spezialisiert auf. Die heutigen GPUs sind nicht mehr für Grafiken vorgesehen und können jetzt für Rechenaufgaben wie die Matrixberechnung verwendet werden. Es scheint, dass moderne GPUs mit Tausenden von Kernen ausgestattet sind. Wenn es sich also um eine Aufgabe wie die Matrixberechnung handelt, die der GPU-Kern ausführen kann, kann er viel mehr parallel verarbeiten als eine CPU mit einer begrenzten Anzahl von Kernen. .. Daher ist zu erwarten, dass sich die Verarbeitungszeit erheblich verkürzt.
In Implementierungen im Zusammenhang mit maschinellem Lernen scheint die Vektorisierung eine sehr wichtige Technik zur Beschleunigung der Verarbeitung zu sein.
Hypothetische Funktion
Die in den bisherigen Beispielen verwendete Vorhersagefunktion $ h_ \ theta (x) $ wird als hypothetische Funktion bezeichnet.
Der vorhergesagte Wert von
Dieses Mal werde ich diese Formel etwas weiter verarbeiten und verwenden. Wenn Sie es so verwenden, wie es ist [Problem 72](http://qiita.com/segavvy/items/6695f94c28126607227b#4 Sagen wir es tatsächlich voraus) Wie ich ein wenig erwähnt habe, ist der vorhergesagte Wert von $ y $ mehr als 1, was eine Bestätigung zeigt. Dies liegt daran, dass es schwierig wird, damit umzugehen, wenn es groß oder kleiner als 0 wird, was auf eine Ablehnung hinweist.
In Problem 70 habe ich geschrieben, dass maschinelles Lernen lobt, ob das Ergebnis korrekt vorhergesagt werden kann, und $ \ theta $ schimpft, wenn die Antwort falsch ist. Tatsächlich wird die Differenz von der richtigen Antwort durch die später beschriebene Zielfunktion berechnet, und $ \ theta $ wird so eingestellt, dass die Differenz kleiner wird. Wenn Sie die Bestätigung richtig vorhersagen, ist die korrekte Bezeichnung für $ y $ 1. Wenn diese Formel verwendet wird, ist der vorhergesagte Wert 1, 10 oder 100, und wenn er 10 oder 100 ist, wird die richtige Antwort korrekt vorhergesagt, aber der Unterschied zum richtigen Antwortetikett 1 wird groß. Ich werde am Ende. Daher verwenden wir eine praktische Funktion, die als Sigmoid-Funktion bezeichnet wird.
Sigmaid-Funktion
Diese Funktion konvertiert jeden angegebenen Wert in einen Wert zwischen 0 und 1, und die Größenbeziehung des angegebenen Werts bleibt auch nach der Konvertierung erhalten. Wenn Sie die hypothetische Funktion $ h_ \ theta (x) $ in den $ z $ -Teil dieser Funktion einfügen, ist das Ergebnis immer 0 zu 1.
Es sieht so aus, wenn ich es in ein Diagramm schreibe (ich habe versucht, es auf dem Mac-Standard Grapher zu schreiben, aber das ist praktisch. Ich weiß jedoch nicht, wie ich die Achsenbeschriftung angeben soll, daher verarbeite ich nur das).
Wenn $ z $ um 0 schwankt, schwankt das Ergebnis der Sigmoidfunktion stark um 0,5, während wenn $ z $ größer oder kleiner als ein bestimmtes Niveau wird, das Ergebnis der Sigmoidfunktion um 1 oder um 0 schwankt. Macht fast keinen Unterschied.
Dank dieser Eigenschaft liegt sie, selbst wenn das Ergebnis der hypothetischen Funktion 1, 10 oder 100 ist, wenn Sie sie in $ z $ eingeben, nahe bei 1 und der Unterschied zur korrekten Bezeichnung ist gering.
Dieses Mal habe ich eine hypothetische Funktion verwendet, die diese Sigmoidfunktion verwendet. "Hypothese ()" ist seine Implementierung. Es nimmt eine Matrix aus $ X $ und $ \ theta $ und berechnet den vorhergesagten Wert.
Zielfunktion
Als nächstes werde ich die Zielfunktion erklären, um zu bestimmen, wie genau die Vorhersage gemacht wird. Abhängig vom Ergebnis dieser Zielfunktion werden wir $ \ theta $ anpassen, um eine genauere Vorhersage zu treffen.
Sie können feststellen, ob die Vorhersage korrekt ist, indem Sie den von der Hypothesenfunktion berechneten Vorhersagewert mit der richtigen Bezeichnung vergleichen. Wenn der Unterschied gering ist, ist die Vorhersagegenauigkeit hoch, und wenn der Unterschied groß ist, ist die Vorhersagegenauigkeit niedrig. Daher ist es grundlegend, alle zu lernenden Überprüfungen zu berechnen und zu addieren und schließlich durch die Anzahl der Überprüfungen zu dividieren, um den Durchschnitt zu erhalten. Es ist eine Form.
Normalerweise addieren Sie den quadratischen Wert der Differenz, anstatt einfach die Differenz zu addieren. Es scheint, dass Sie sich keine Gedanken über das Vorzeichen des Unterschieds machen müssen, wenn Sie es quadrieren, und der Wert für den Unterschied wird groß, sodass es einfacher wird, $ \ theta $ anzupassen.
In der Vorhersage, dass das Ergebnis wie diesmal entweder 1 (positiv) oder 0 (negativ) ist, beträgt die Differenz jedoch nur maximal 1, wenn nur die quadratische Differenz verwendet wird, und diese Zielfunktion ist keine konvexe Funktion mehr. Es scheint schwierig zu sein, $ \ theta $ anzupassen, um die Zielfunktion auf den Mindestwert zu bringen.
Daher verwenden wir unter Verwendung der Eigenschaft von $ -log () $ die folgende Zielfunktion, sodass, wenn die Vorhersage und das Ergebnis übereinstimmen, sie 0 sind und wenn sie nicht übereinstimmen, es $ \ infty $ ist. $ y $ ist die korrekte Bezeichnung (1 für positiv, 0 für negativ) und $ h $ ist der von der hypothetischen Funktion vorhergesagte Wert.
In der ersten Hälfte wird der Wert berechnet, wenn die richtige Antwort positiv ist ($ y = 1
Vektorisierung der Zielfunktion
Die Implementierung der Zielfunktion wird auch durch die Verwendung von Matrixoperationen beschleunigt. Um die Zielfunktion bei normaler Implementierung zu berechnen, ermitteln Sie den vorhergesagten Wert $ h $ für jede Überprüfung und $ -y , log (h) - (1 - y) log (1 - h) $ Sie berechnen den Wert von und addieren ihn wiederholt für die Gesamtzahl der Bewertungen. Dies liegt daran, dass das Schreiben in eine Schleife es verlangsamt.
Erstellen Sie zunächst eine Matrix $ X $ mit Funktionen, die aus allen Bewertungen extrahiert wurden. Die Länge der Matrix ist die Anzahl der Überprüfungen, und die Breite ist die Anzahl der Primzahlen + 1. Der Grund für +1 ist, dass ich, wie ich im Abschnitt über Vektorisierung geschrieben habe, immer ein Element von 1 benötige, das $ x_0 $ entspricht, um Matrixoperationen in hypothetischen Funktionen zu verwenden.
Dieses Mal beträgt die Anzahl der Bewertungen 10.662 und die Anzahl der Identitäten 3.227, sodass $ X $ wie folgt aussieht. Es ist nur ein Bild, und der Wert ist angemessen.
$ \ theta $ ist die Form, die im Vektorisierungsabschnitt geschrieben wurde.
Dies gibt Ihnen einen Vorhersagewert von $ H $ für alle Bewertungen in einer Aufnahme von $ X \ theta $.
Machen Sie auf die gleiche Weise die richtige Beschriftung zu einer Matrix.
Jetzt können Sie $ -y , log (h) - (1 --y) log (1 --h) $ durch Matrixoperation berechnen und alle Überprüfungen gleichzeitig berechnen. Ich werde. Cost () ist in dieser Form implementiert.
Beachten Sie, dass die Matrizen $ X $ und $ Y $ mit create_training_set () erstellt werden.
Die steilste Abstiegsmethode
Als nächstes folgt der Teil zum Anpassen von $ \ theta $. Vorhersage mit der Hypothesenfunktion, Berechnung der Differenz von der richtigen Antwort mit der Zielfunktion und Wiederholung der Anpassung von $ \ theta $, so dass der Wert kleiner wird. Diesmal habe ich für diese Einstellung die steilste Abstiegsmethode verwendet. Die Methode mit dem steilsten Abstieg ist eine Methode zum Untersuchen des Gradienten des aktuellen Individuums $ \ theta $ in der Zielfunktion und zum Einstellen des Individuums $ \ theta $ in der Richtung, in der der Wert der Zielfunktion abnimmt.
Unten ist ein Bild, wenn es nur ein $ \ theta $ gibt.
Überprüfen Sie zunächst den Gradienten der Position ① im aktuellen $ \ theta $. Der untersuchte Gradient ist in der Abbildung als gerade Linie dargestellt (die Länge dieser geraden Linie entspricht der später beschriebenen Lernrate). Nehmen Sie dann an, dass der Wert der Zielfunktion entlang der geraden Linie des Gradienten fällt, und ändern Sie $ \ theta $ so, dass er sich in der Position vor der Geradheit befindet. Damit ist die erste Anpassung abgeschlossen, $ \ theta $ wird zu einem neuen Wert und die aktuelle Position wird auf ② verschoben. Überprüfen Sie beim zweiten Mal die Steigung der Position ②. Wiederholen Sie danach diesen Vorgang, fahren Sie mit ③ und ④ fort und stellen Sie die Position ein, an der der Gradient flach wird, um die Zielfunktion zu minimieren.
In der obigen Erklärung der Zielfunktion habe ich geschrieben, dass es ein Problem ist, wenn es keine konvexe Funktion ist, aber wenn es keine konvexe Funktion ist, gibt es eine Delle, die nicht der minimale Punkt in der Mitte der Kurve dieses Diagramms ist. Wenn Sie dies tun, werden Sie an einem anderen Ort als dem Mindestpunkt süchtig und können $ \ theta $ nicht auf den Mindestwert ableiten.
Der Gradient kann durch partielle Differenzierung berechnet werden, aber ich werde die Berechnungsmethode weglassen (oder besser gesagt, ich kann ihn nicht selbst finden, weil ich mich noch nicht an die partielle Differenzierung erinnern kann ^^;). Schließlich können Sie $ \ theta $ mit der folgenden Formel anpassen.
$ m $ ist die Anzahl der Überprüfungen, $ h_ \ theta (x ^ {(i)}) $ ist das $ i $ -Feature, das aus der dritten Überprüfung extrahiert wurde. $ x ^ {(i)} $ wurde verwendet, um die Hypothesenfunktion zu finden $ i $ Voraussichtlicher Wert der 3. Überprüfung, $ y ^ {(i)} $ ist die korrekte Antwortbezeichnung der i-ten Überprüfung, $ x_j ^ {(i)} $ ist das Merkmal, das aus der $ i $ -ten Überprüfung extrahiert wurde Der Wert von j $, $ \ alpha $, ist ein Parameter, der als Lernrate bezeichnet wird. Die Lernrate wird später beschrieben.
Die Berechnung des neuen $ \ theta $ durch diese Methode mit dem steilsten Abstieg wird auch durch die Operation der Matrix beschleunigt, anstatt die Schleife für 3.228 $ \ theta $ wiederholt zu berechnen. Die Gradientenberechnung wird durch "gradient ()" implementiert, und die wiederholte Anpassung von $ \ theta $ wird durch "learn ()" implementiert.
Lernrate und Anzahl der Wiederholungen
Die Lernrate $ \ alpha $ beim Anpassen von $ \ theta $ entspricht der Länge der geraden Linie des Gradienten im Diagramm mit dem steilsten Abstieg oben. Wenn Sie ihn erhöhen, erhöht sich der Anpassungsbetrag von $ \ theta $, und der Wert der Zielfunktion nimmt ebenfalls erheblich ab. Wenn es jedoch zu groß gemacht wird, passiert es den Minimalpunkt der Zielfunktion, und die Zielfunktion wird groß und konvergiert nicht wiederholt. Wenn Sie es jedoch zu klein machen, ist die Verarbeitungszeit sehr lang, obwohl sie sich stetig dem Minimalpunkt der Zielfunktion nähert. Dieser Bereich erfordert Versuch und Irrtum.
Wie oft sollte diese $ \ theta $ -Anpassung wiederholt werden, um das Lernen abzuschließen? Dies ist ein Teil, der Versuch und Irrtum erfordert. Die Zielfunktion wird zunächst immer kleiner, aber ihre Geschwindigkeit wird immer langsamer. Im Allgemeinen wurde gesagt, dass der Anpassungsbetrag von $ \ theta $ als Richtlinie für das Ende nur $ 10 ^ {-3} $ betragen sollte. In dieser Implementierung wird der Anpassungsbetrag in "learn ()" berechnet und als E angezeigt.
Ich habe es mehrmals versucht, aber diesmal habe ich die Lernrate auf 6,0 eingestellt und 1000 Mal wiederholt. E bei der 1000. Anpassung betrug ungefähr 0,001, und der Wert der Zielfunktion änderte sich kaum, so dass es gut erscheint, hier zu enden. Das Lernen auf meinem Computer dauerte übrigens ungefähr 1 Minute.
Empfehlung zum Studium des maschinellen Lernens (Repost)
Ich dachte, ich schreibe diesen Artikel, aber wenn es um solch komplizierte Inhalte geht, ist es schwierig, ihn leicht zu erklären, ohne mein eigenes Verständnis zu kennen ^^; Wie ich in [Empfehlungen für das Studium des maschinellen Lernens in Aufgabe 70](http://qiita.com/segavvy/items/0e91fe02088b875a386a#Recommendations für das Studium des maschinellen Lernens) geschrieben habe, lesen Sie bitte die wunderbaren Lehrmaterialien und Artikel der Weltneuheit. Bitte nutzen Sie es.
Das ist alles für den 74. Schlag. Wenn Sie Fehler haben, würde ich mich freuen, wenn Sie darauf hinweisen könnten.
- Das Ausführungsergebnis enthält einen Teil der Daten, die in für 100 Schläge verwendete Korpusdaten verteilt sind. Ich werde. * *
Recommended Posts