Ich fing an, maschinelles Lernen zu lernen, aber es war ein wenig schwierig, damit auszukommen. Die Zeichenerkennung ist das erste, was in TensorFlow Tutorial eingeführt wird, wodurch eine neue Atmosphäre entsteht. Es war groß, dass ich dort war. Plötzlich "Lassen Sie uns eine Funktion erstellen, die die Eingabedaten von 784 Elementen (Anzahl der Pixel) auf die Ausgabedaten von 10 Elementen (Zahlen) verteilt. Weil wir eine große Menge manuell eingegebener Daten haben (55.000). Dies ist Hallo für maschinelles Lernen. Es ist Welt. " Es war schwer.

Ich konnte es jedoch nicht ändern, also habe ich es versucht und irgendwie herausgefunden, wie es geht. Deshalb habe ich ein Tutorial erstellt, das ich mir selbst ausgeliehen habe, damit ich es als Memorandum schreiben kann. Ich habe 3.5.1 als Python-Version verwendet.

Was zu machen

--Distributor, der Körpertypen basierend auf Größe und Gewicht in "dünn", "normal" und "mollig" klassifiziert.

Angenommene Situation

Fragen Sie eine große Anzahl von Personen nach "Größe" und "Gewicht".
Notieren Sie sich den Eindruck der "Körperform" (individuelle Subjektivität) der Person in drei Kategorien: "dünn", "normal" und "mollig".

172cm 62kg Normal 181 cm 55 kg dünn ... ```

Wenn eine beträchtliche Menge von Memodaten gesammelt wird, lassen Sie die Maschine die Korrelation zwischen "Größe", "Gewicht" und "Körperform" lernen, damit Sie die Körperform beurteilen können, ohne sich auf die Intuition verlassen zu müssen, wenn Sie "Größe" und "Gewicht" kennen. Zu.

Fluss des maschinellen Lernens durch TensorFlow

Bereiten Sie Lehrerdaten und Testdaten vor
Entwerfen Sie die Datenstruktur von Eingabewert und Ausgabewert aus Lehrerdaten
Annahme eines Korrelationsmodells zwischen Eingabe- und Ausgabewerten
Übergeben Sie die Lehrerdaten an das Modell und trainieren Sie sie
Überprüfen Sie den Lernstatus des Modells
Wenn Sie unabhängig davon, wie viel Sie lernen, nicht das richtige Ergebnis erhalten. → Zurück zu 3.

1. Bereiten Sie Lehrerdaten und Testdaten vor

Bereiten Sie ausreichende Daten und Lehrerdaten vor, um die Korrelation von Daten zu analysieren. Je größer die Anzahl der Daten ist, desto genauer kann gelernt werden.

Y = f(X)

Die Menge von $ X $ und $ Y $ sind die Lehrerdaten. Ich weiß nicht, wie ich $ Y $ finden soll, aber ich möchte die Informationen wissen. $ X $ und $ Y $ sind Vektoren, aber denken Sie nicht weiter, das Bild unten.

\left(
  \begin{array}{ccc}
gewöhnlich\\
Dünn\\
      \vdots
  \end{array}
\right)
 = f\left(
  \begin{array}{ccc}
      172 & 62  \\
      181 & 55  \\
      \vdots & \vdots
  \end{array}
\right)

Für die Lehrerdaten war diesmal das Datenformat CSV. Ich hatte keine Zeit für eine Straßenvermessung, also habe ich es von Hand gemacht.

import numpy as np
import csv
def gen_data(n):
    h = 160 + (np.random.randn(n) * 10)
    w = (h/100) ** 2 * 22 + (np.random.randn(n) * 10)
    bmi = w / (h/100) ** 2
    f = np.vectorize(lambda b: 'Mollig' if b > 25 else 'gewöhnlich' if b > 18.5 else 'Dünn')
    return np.c_[h, w, f(bmi)]
fp = open('train.csv', 'w')
writer = csv.writer(fp)
writer.writerows(gen_data(100))
fp.close()

`train.csv`


172,62,gewöhnlich
181,55,Dünn
...

Leicht zu lesen.

 fp = open('train.csv', 'r')
 train_data = np.array([r for r in csv.reader(fp)])

Dies ist die Datenverteilung im Diagramm

train_plot = [train_data[train_data[:,2] == 'Dünn'],
              train_data[train_data[:,2] == 'gewöhnlich'],
              train_data[train_data[:,2] == 'Mollig']]
plt.plot(train_plot[0][:,0], train_plot[0][:,1], 'o', label = 'skinny')
plt.plot(train_plot[1][:,0], train_plot[1][:,1], 'o', label = 'normal')
plt.plot(train_plot[2][:,0], train_plot[2][:,1], 'o', label = 'fat')

Neben den Lehrerdaten werden auch Testdaten zur Beurteilung des Lernergebnisses des maschinellen Lernens erstellt.

Diese Testdaten sind $ Eine maschinell trainierte Funktion, um Y = f (X in Lehrerdaten) $ in Lehrerdaten so nahe wie möglich zu kommen $ Lehrerdaten Y \ fallender Punkt (Lehrerdaten X) $ Es wird verwendet, um die Leistung dieses $ g $ zu überprüfen. Übergeben Sie $ X $, das sich von den Lehrerdaten unterscheidet, an $ g $ und prüfen Sie, ob das erwartete Ergebnis zurückgegeben wird.

Inhalt prüfen: Ist $ g (X der Testdaten) $ gleich Y $ der $ Testdaten?

Dieses Mal haben wir 100 Lehrerdaten und 50 Testdaten vorbereitet.

2. Entwerfen Sie die Datenstruktur von Eingabewert und Ausgabewert aus Lehrerdaten

Selbst wenn Sie Design sagen, müssen Sie nur die Anzahl der Elemente des Eingabewerts und die Anzahl der Elemente des Ausgabewerts bestimmen und den Typ bestimmen. Diesmal gibt es zwei Eingabeelemente

[Höhe: float,Körpergewicht: float]

3 Ausgabeelemente

[Wahrscheinlichkeit dünn zu sein:float,Wahrscheinlichkeit normal zu sein:float,Wahrscheinlichkeit mollig zu sein:float ]

Und sagte. Die Wahrscheinlichkeit liegt zwischen $ 0 $ und $ 1 $.

Konvertieren Sie die aus CSV gelesenen Daten wie folgt.

train_x = np.array([[float(r[0]), float(r[1])] for r in train_data])
train_y = np.array([ [1,0,0] if r[2] =='Dünn' else [0,1,0] if r[2] == 'gewöhnlich' else [0,0,1] for r in train_data])

$ Y = f (X) $ sieht so aus.

\left(
  \begin{array}{ccc}
     0 & 1 & 0 \\
     1 & 0 & 0 \\
     \vdots & \vdots & \vdots 
  \end{array}
\right)
 = f\left(
  \begin{array}{ccc}
      172 & 62  \\
      181 & 55  \\
      \vdots & \vdots
  \end{array}
\right)

3. Annahme eines Korrelationsmodells zwischen Eingabe- und Ausgabewerten

Das ist die Leber.

Angenommen, die Funktion $ g (X) $ soll wie folgt maschinell gelernt werden.

Y = {\rm softmax}(WX+b)

Die Formel kam plötzlich heraus, aber Lineare Regression Ist damit möglich. Wenn Sie es nicht lösen können [siehe unten](#% E6% 9C% 9F% E5% BE% 85% E3% 81% 97% E3% 81% 9F% E7% B5% 90% E6% 9E% 9C% E3% 81 % AB% E8% BF% 91% E3% 81% A5% E3% 81% 8B% E3% 81% AA% E3% 81% 84).

Dies ist in der Abbildung dargestellt.

$ X_ {i} $ Multipliziere alles mit dem Gewicht $ W_ {i, j} $, addiere Bias $ b_ {j} $ und addiere $ {\ rm softmax} $, um $ y_ {j} $ zu erhalten Bereiten. Indem Sie $ W $ und $ b $ nach und nach ändern, um der Beziehung zwischen $ X $ und $ Y $ in den Lehrerdaten näher zu kommen, wird es meiner Meinung nach irgendwann zu einem Hochleistungsklassifikator. Gibt es.

\left(
  \begin{array}{ccc}
      y_{1,1} & y_{1,2} & y_{1,2}\\
      y_{2,1} & y_{2,2} & y_{1,3}\\
      \vdots & \vdots & \vdots
  \end{array}
\right)
 = {\rm softmax}(
\left(
  \begin{array}{ccc}
      W_{1,1} & W_{1,2} & W_{1,3}  \\
      W_{2,1} & W_{2,2} & W_{2,3} 
  \end{array}
\right) 
\cdot
\left(
  \begin{array}{ccc}
      x_{1,1} & x_{1,2}  \\
      x_{2,1} & x_{2,2}  \\
      \vdots & \vdots
  \end{array}
\right) + 
\left(
  \begin{array}{ccc}
      b_{1} &
      b_{2} &
      b_{3}
  \end{array}
\right))

Wenn Sie eine Zeile entwirren,

$ \ left (\ begin {array} {ccc} Möglichkeit, dünn zu sein y_ {, 1} & Wahrscheinlichkeit, normal zu sein y_ {, 2} & Wahrscheinlichkeit, mollig zu sein y_ {, 3} \ end {array} \ right) $

= 
{\rm softmax}
\left(
  \begin{array}{ccc}
    (W_{1.1} x_{,1} + W_{2.1} x_{,2} + b_{1}),\ (W_{1.2} x_{,1} + W_{2.2} x_{,2} + b_{2}),\ (W_{1.3} x_{,1} + W_{2.3} x_{,2} + b_{3}
  \end{array}
\right))

$ x_ {, 1} $: Höhe, $ x_ {, 2} $: Gewicht

Das ist es.

$ {\ rm softmax} $ blieb übrig.

Die Funktion $ {\ rm softmax} $ ist eine praktische Funktion, wenn ein neuronales Netzwerk wie dieses Mal in mehrere Wahrscheinlichkeitswerte klassifiziert. In der Formel ist $ A = \ left [\ begin {array} {ccc} a_ {1} \ ldots a_n \ end {array} \ right] $ {\ rm softmax} (A) = \ als es $ gab links [\ frac {e ^ {a_ {1}}} {\ sum_ {j = 1} ^ ne ^ {a_j}} \ ldots \ frac {e ^ {a_n}} {\ sum_ {j = 1} ^ ne ^ {a_j}} \ right] Es ist eine Funktion, die zu $ wird, aber bitte ignorieren Sie sie vorerst.

Einfach ausgedrückt werden die relativ größeren Werte auf $ 1 $ und die kleineren Werte auf $ 0 $ normalisiert, so dass die Summe des Arrays $ A $ $ 1 $ beträgt. Es ist ein Ersatz für mich. Dieses Mal gibt es drei Kategorien $ [Wahrscheinlichkeit dünn zu sein, \ Wahrscheinlichkeit normal zu sein, \ Wahrscheinlichkeit mollig zu sein] $ Ich möchte ein Paar finden. Wenn Sie beispielsweise eine 80% ige Chance haben, Gewicht zu verlieren, und eine 20% ige Chance, eine normale Größe und ein normales Gewicht zu haben, lautet die Antwort [0.8,\ 0.2,\ 0.0] Ich will. Außerdem beträgt jede Summe aller Datensätze von Lehrerdaten $ 1 $. [1,\ 0,\ 0]\ {\rm or}\ [0,\ 1,\ 0]\ {\rm or}\ [0,\ 0,\ 1] Daher habe ich nicht das Gefühl, dass es konvergiert, selbst wenn ich ein Ergebnis wie $ [1, \ 2, \ 3] $ erhalte. Ich sage nicht $ [1, \ 2, \ 3] $ ist $ {\ rm softmax} $, um $ [0.09, \ 0.245, \ 0.665] $ zu erhalten. Ich habe das Gefühl, dass ich das schaffen kann.

Übrigens ist beim maschinellen Lernen die Funktion, die den Wert wie folgt normalisiert: $ {\ rm softmax} $ Aktivierungsfunktion Es heißt% 80% A7% E5% 8C% 96% E9% 96% A2% E6% 95% B0).

Die Definition des Modells in TensorFlow lautet

import tensorflow as tf

#Eingabewertdefinition
x = tf.placeholder('float', [None, 2])

#Ausgabewertdefinition
w = tf.Variable(tf.ones([2, 3]))
b = tf.Variable(tf.zeros([3]))
y = tf.nn.softmax(tf.matmul(x, w) + b)

Es wird so sein. Da die Tensorflow-API erschienen ist, werde ich sie kurz erklären

api	Erläuterung
`tf.placeholder`	Eingabewertdefinition. Lehrerdaten und Testdaten finden Sie hier. Sie müssen es zur Laufzeit geben. Die Argumente sind Typ und Anzahl der Dimensionen.
`tf.Variable`	Definition von Werten, die durch Lernen geändert werden sollen. Jedes Mal, wenn Sie lernen, schwankt es, so dass der Fehler kleiner wird. Das Argument ist der Anfangswert.
`tf.ones`	1 Gibt eine gefüllte Matrix zurück
`tf.zeros`	0 Gibt eine gefüllte Matrix zurück
`tf.matmul`	Gibt das Ergebnis der Matrixmultiplikation zurück

4. Übergeben Sie die Lehrerdaten an das Modell und trainieren Sie sie

In der vorherigen Einstellung wurde der Anfangswert entsprechend festgelegt. Selbst wenn Sie $ X $ übergeben, wird nur ein entsprechendes Ergebnis zurückgegeben. Die Richtung zum richtigen Ergebnis muss im Voraus festgelegt werden.

Berechnen Sie, indem Sie $ W $, $ b $ für den Anfangswert und $ X $ für die Lehrerdaten für $ g (X) $ einsetzen, $ Y = {\ rm softmax} (WX + b) $, wie im vorherigen Abschnitt angenommen. ,

\left(
  \begin{array}{ccc}
     0.333 & 0.333 & 0.333 \\
     0.333 & 0.333 & 0.333 \\
     \vdots & \vdots & \vdots 
  \end{array}
\right)
 = g\left(
  \begin{array}{ccc}
      172 & 62  \\
      181 & 55  \\
      \vdots & \vdots
  \end{array}
\right)

Das ist das Ergebnis. Infolgedessen wird der Fehlerwert von $ Y $ und das wahre Ergebnis der Lehrerdaten (festgelegt als $ Y '$) berechnet, und wenn dieser Fehlerwert minimiert werden kann, ist das Lernen abgeschlossen. Der Fehlerwert der Wahrscheinlichkeitsverteilung wird unter Verwendung einer Formel berechnet, die als Kreuzentropie bezeichnet wird.

loss = -\sum Y' {\rm log}(Y)

Dieses Mal haben wir diese Kreuzentropie als Methode zur Messung des Fehlerwerts definiert, denn wenn die genaue Übereinstimmung wahr ist, kann $ 0 $ erhalten werden, und wenn die Differenz unterschiedlich ist, kann ein größerer Wert erhalten werden.

Als nächstes ist es notwendig, den gemessenen Fehlerwert zu reduzieren, während $ W $ und $ b $, die als "tf.Variable" (Wert, der durch Lernen schwankt) definiert sind, im Modell angepasst werden.

Die Funktion, die diesen Fehlerwert erhält (in diesem Fall die Kreuzentropie von $ loss $: $ Y $ und $ Y '$), wird als Zielfunktion bezeichnet.

Es gibt verschiedene Algorithmen zur Optimierung der Zielfunktion.

Ein Algorithmus, der schnell konvergiert, aber wahrscheinlich nicht die optimale Lösung findet
Ein Algorithmus, der es einfach macht, die optimale Lösung zu finden, dessen Konvergenz jedoch lange dauert
Ein Algorithmus, der für ein bestimmtes Problem keine Lösung finden kann
Ein Algorithmus, der das Einstellen von Parametern schwierig macht
Eine solche

TensorFlow verfügt jedoch über eine Implementierung von Many Optimization Algorithms. Wechseln Sie also und probieren Sie es aus. Ist einfach.

Diesmal Gradientenabstiegsmethode (tf.train.GradientDescentOptimizer) und Adam % A2% BA% E7% 8E% 87% E7% 9A% 84% E5% 8B% BE% E9% 85% 8D% E9% 99% 8D% E4% B8% 8B% E6% B3% 95 # Adam) ( Ich habe zwei davon ausprobiert (tf.train.AdamOptimizer), aber beide haben mir eine Lösung gegeben. Adam entschied sich schließlich dafür, weil es schneller konvergierte.

Der Optimierungsalgorithmus von TensorFlow ändert die Schwankungswerte $ W $ und Bias $ b $ nach und nach, so dass das Ergebnis (= Fehlerwert) der Zielfunktion klein wird.

Selbst wenn Sie alles auf einmal ändern, werden Sie die Antwort nicht finden, so dass Sie sie nach und nach ändern müssen, aber dieser Änderungsbetrag kann mit Parametern angepasst werden. Wenn es zu groß ist, kann die Antwort nicht gefunden werden, und wenn es zu klein ist, braucht es Zeit, um die Antwort zu finden. Diesmal betrug der Einstellwert für "Adam Optimizer" 0,05.

Die Definition des Lernens in TensorFlow lautet wie folgt.

#Beantworten Sie den Eingabebereich für Lehrerdaten(Y')
y_ = tf.placeholder('float', [None, 3])
#Zielfunktion-sum(Y'log(Y))
#log(0)Die Mindestmenge wurde angepasst, um nan anzuzeigen(tf.clip_by_value)
loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.clip_by_value(y, 1e-10, 1.0))))
#Optimieren Sie die Variationswerte schrittweise, damit das Ergebnis der Zielfunktion minimiert wird
train_step = tf.train.AdamOptimizer(0.05).minimize(loss)

#Variable Initialisierung
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

train_feed_dict={x: train_x, y_: train_y}
for i in range(100001):
    #Lernen
    sess.run(train_step, feed_dict=train_feed_dict)

Das Ausführen von sess.run wertet den Inhalt des ersten Parameters aus. Zu diesem Zeitpunkt werden die Daten, die dem Platzhalter zugeordnet sind, der zur Berechnung des Parameters erforderlich ist, an den Parameter feed_dict übergeben. Da für "train_step" $ X $ und $ Y '$ Lehrerdaten erforderlich sind, setzen Sie diese wie oben.

Das Lernen wurde 100.000 Mal durchgeführt.

5. Überprüfen Sie den Lernstatus des Modells

Lernen braucht Zeit. Es ist traurig, wenn das Ergebnis nach dem Warten nicht erhalten wird. Daher möchte ich während der Ausführung überprüfen, ob das festgelegte Modell ordnungsgemäß funktioniert, dh ob der Fehlerwert in Richtung Konvergenz geht.

TensorBoard wird in TensorFlow als Visualisierungstool bereitgestellt, diesmal jedoch nicht.

Visualisiert auf einer schlammigen Konsole.

test_feed_dict={x: test_x}
for i in range(100001):
    sess.run(train_step, feed_dict=train_feed_dict)
    if(i % 10000 == 0 or (i % 1000 == 0 and i < 10000) or (i % 100 == 0 and i < 1000) or (i % 10 == 0 and i < 100)):
        #Fehlerausgabe
        test_y = ['Dünn' if max(a) == a[0] else 'gewöhnlich' if max(a) == a[1] else 'Mollig' for a in sess.run(y, feed_dict=test_feed_dict)]
        bools = train_data[:,2] == test_y
        print (i, sess.run(loss, feed_dict=train_feed_dict), str(sum(bools) / len(bools) * 100) + '%')

Die Häufigkeit des Lernens, der Fehlerwert mit den Lehrerdaten und die korrekte Antwortrate bei Verwendung von $ X $ der Testdaten ($ Y '$ ist für feed_dict nicht erforderlich) werden ausgegeben. Korrigieren Sie den Ausgangszeitpunkt entsprechend.

10 89.8509 64.0%
20 80.4948 64.0%
30 73.6655 64.0%
40 68.4465 65.0%
50 64.4532 69.0%
60 61.0676 73.0%
70 58.317 73.0%
80 56.0346 74.0%
90 54.1317 74.0%
100 52.5213 74.0%
200 44.4377 79.0%
300 41.6028 79.0%
400 40.2241 80.0%
...

Es wird so angezeigt. Irgendwie scheint das Lernen erfolgreich zu sein.

Ich wollte es ein wenig verständlicher machen, also habe ich versucht, es mit pyplot zu visualisieren.

import matplotlib.pyplot as plt

# height: 130～190, weight:Machen Sie alle Kombinationen von 20-100 und extrahieren Sie y aus der gelernten Funktion
px, py = np.meshgrid(np.arange(130, 190+1, 1), np.arange(20, 100+1, 1))
graph_x = np.c_[px.ravel() ,py.ravel()]
graph_y = sess.run(y, feed_dict={x: graph_x})
#y ist die Farbabstufung (-In 1 zu 1 konvertieren)
pz = np.hsplit(np.array([sum(e * [-1, 0, 1]) for e in graph_y]), len(px))
plt.pcolor(px, py, pz)
plt.cool()

Der Lehrerdatenbereich wurde diesmal für alle Kombinationsmuster, die in Schritten von 1 cm Höhe und 1 kg Gewicht aufgenommen werden können, auf $ X $ festgelegt, und das Modell wurde bewertet und aufgezeichnet.

Ich denke, das ist als Lernsituation leichter zu verstehen.

6. Wenn Sie unabhängig davon, wie viel Sie lernen, nicht das richtige Ergebnis erhalten.

Überprüfen Sie das Modelldesign. Je nach Problem kann ein einfaches Modell wie dieses nicht damit umgehen, sodass nach und nach Anpassungen vorgenommen werden müssen.

Ich habe die Details nicht verstanden. Wenn Sie also ein einfaches Beispiel geben

Das Lernen ist langsam oder hört in der Mitte auf

Schneiden Sie eine Mini-Charge
Passen Sie die Parameter des Optimierungsalgorithmus an --Versuchen Sie, zu einem anderen Algorithmus zu wechseln

Halten Sie sich von den erwarteten Ergebnissen fern

Versuchen Sie, eine Zwischenebene hinzuzufügen (versteckte Ebene).

Das Beispiel von TensorFlow Playground ist leicht zu verstehen.

Da $ WX + b $ ein linearer Ausdruck ist, kann er nichtlineare Probleme nicht behandeln. Durch Vorbereiten einer in diesem Modell weggelassenen Zwischenschicht zwischen der Eingangsschicht und der Ausgangsschicht wird es jedoch möglich, ein kompliziertes nichtlineares Modell durch Kombinieren linearer Modelle zu trainieren. Es ist weniger zeiteffizient, kann jedoch den endgültigen Fehlerwert verringern.

Beispiel für das Hinzufügen einer Zwischenschicht

#Mittelschicht
with tf.name_scope('hidden'):
    w0 = tf.Variable(tf.ones([2, 4])) #Empfängt 2 x von der Eingabeebene und konvertiert in 4 Ausgänge
    b0 = tf.Variable(tf.zeros([4]))   #Vorspannung an jedem Ausgang
    h0 = tf.nn.relu(tf.matmul(x, w0) + b0)

#Ausgabeschicht
with tf.name_scope('output'):
    w = tf.Variable(tf.ones([4, 3])) #Empfängt 4 Ausgänge von der mittleren Ebene und konvertiert sie in 3 Ausgänge
    b = tf.Variable(tf.zeros([3]))   #Vorspannung an jedem Ausgang
    y = tf.nn.softmax(tf.matmul(h0, w) + b)

Versuchen Sie, die Eingabedaten zu verarbeiten

Es kann sich lohnen, zu versuchen, die Eingabedaten beispielsweise linear zu verarbeiten, indem $ {x_ {1}} ^ 2, \ {\ rm sin} (x_ {2}) $ als neues $ x_i $ hinzugefügt wird. In ein behebbares Problem konvertieren.

Beispiel für die Verarbeitung von Eingabedaten

#Eingabeebene
with tf.name_scope('input'):
    x = tf.placeholder('float', [None, 2])
    #Vorverarbeitung des Eingabewerts
    x1, x2 = tf.split(1, 2, x)
    x_ = tf.concat(1, [x, x1 ** 2, tf.sin(x2)])
#Ausgabeschicht
with tf.name_scope('output'):
    w = tf.Variable(tf.ones([4, 3])) #[[x1, x2, x1**2, sin(x2)],[skinny, normal, fat]] 
    b = tf.Variable(tf.zeros([3]))
    y = tf.nn.softmax(tf.matmul(h0, w) + b)

Eingabedaten hinzufügen

Ich vermute, dass möglicherweise nicht genügend Eingabeinformationen vorhanden sind. In diesem Beispiel kann das Hinzufügen von Geschlecht, Alter usw. zu den Daten die Genauigkeit weiter verbessern. Es ist jedoch erforderlich, von der Datenerfassung neu zu beginnen.

Lernergebnis

In diesem Modell waren 100 Fälle 100.000 Mal und die Berechnungszeit betrug etwa 2 Minuten. (Core i5 1,8 GHz)

...
70000 3.63972 99.0%
80000 3.27686 100.0%
90000 3.02285 100.0%
100000 2.80263 100.0%

Die richtige Antwortrate erreichte um das 80.000ste Mal 100%.

Die Grafik ist auch schön

Siehe auch die Werte von $ W $ und $ b $

print ('w:',sess.run(w))
print ('b:',sess.run(b))

`Konsole`


w: [[ 3.11868572  1.0388186  -0.9223755 ]
 [-2.45032024  0.99802458  3.3779633 ]]
b: [-172.08648682   -3.14501309  158.91401672]

Verteilungsfunktion $ (Wahrscheinlichkeit dünn zu sein, Wahrscheinlichkeit normal zu sein, Wahrscheinlichkeit mollig zu sein) $ $ = {\ rm softmax} ((3,12 Höhe -2,45 Gewicht -172,96), (1,04 Höhe + Gewicht -3,15), (-0,92 Höhe + 3,38 Gewicht + 158,91)) $ Abgeschlossen.

Für alle Fälle mit ipython überprüft

import numpy as np
#Da Softmax nicht numpy war, habe ich meine eigene Definition gemacht
def softmax(a):
    e = np.exp(np.array(a))
    return e / np.sum(e)
def taikei(h, w):
    return softmax([(3.12*h - 2.45*w - 172.96), (1.04*h + w - 3.15), (-0.92*h + 3.38*w + 158.91)])
print(np.round(taikei(172,60),2))

↓ [ 0. 1. 0.]

Wenn Sie 172 cm groß und 60 kg schwer sind 100% normal.

Eine zarte Linie, Höhe 172 cm, Gewicht 74 kg

print(np.round(taikei(172,74),2))

↓ [ 0. 0.26 0.74] 74% mollig.

Alle Quellcode

import numpy as np
import tensorflow as tf
import csv
import matplotlib.pyplot as plt
import math

def read(path):
    fp = open(path, 'r')
    data = np.array([r for r in csv.reader(fp)])
    fp.close()
    return data

def convert(data):
    return [np.array([[float(r[0]), float(r[1])] for r in data]),
            np.array([ [1,0,0] if r[2] =='Dünn' else [0,1,0] if r[2] == 'gewöhnlich' else [0,0,1]  for r in data])]

train_data = read('train.csv')
test_data = read('test.csv')

#Anzeige der Lehrerdaten
plt.xlabel('height')
plt.ylabel('weight')
plt.xlim(130, 190)
plt.ylim(20, 100)
train_plot = [train_data[train_data[:,2] == 'Dünn'],
              train_data[train_data[:,2] == 'gewöhnlich'],
              train_data[train_data[:,2] == 'Mollig']]
plt.plot(train_plot[0][:,0], train_plot[0][:,1], 'o', label = 'skinny')
plt.plot(train_plot[1][:,0], train_plot[1][:,1], 'o', label = 'normal')
plt.plot(train_plot[2][:,0], train_plot[2][:,1], 'o', label = 'fat')
plt.legend()

train_x, train_y = convert(train_data)
test_x, test_y = convert(test_data)

#Eingabeebene
with tf.name_scope('input'):
    x = tf.placeholder('float', [None, 2])

#Ausgabeschicht
with tf.name_scope('output'):
    w = tf.Variable(tf.ones([2, 3]))
    b = tf.Variable(tf.zeros([3]))
    y = tf.nn.softmax(tf.matmul(x, w) + b)

with tf.name_scope('train'):
    #Beantworten Sie den Eingabebereich für Lehrerdaten(Y')
    y_ = tf.placeholder('float', [None, 3])
    #Zielfunktion-sum(Y'log(Y))
    #log(0)Die Mindestmenge wurde angepasst, um nan anzuzeigen(tf.clip_by_value)
    loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.clip_by_value(y, 1e-10,1.0))))
    #Optimieren Sie die Variationswerte schrittweise, damit das Ergebnis der Zielfunktion minimiert wird
    train_step = tf.train.AdamOptimizer(0.05).minimize(loss)

#Variable Initialisierung
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

train_feed_dict={x: train_x, y_: train_y}
test_feed_dict={x: test_x}
for i in range(100001):
    sess.run(train_step, feed_dict=train_feed_dict)
    if(i % 10000 == 0 or (i % 1000 == 0 and i < 10000) or (i % 100 == 0 and i < 1000) or (i % 10 == 0 and i < 100)):
        #Fehlerausgabe
        test_y = ['Dünn' if max(a) == a[0] else 'gewöhnlich' if max(a) == a[1] else 'Mollig' for a in sess.run(y, feed_dict=test_feed_dict)]
        bools = train_data[:,2] == test_y
        print (i, sess.run(loss, feed_dict=train_feed_dict), str(sum(bools) / len(bools) * 100) + '%')
        #Anzeige des Klassifizierungsstatus
        # height: 130～190, weight:Machen Sie alle Kombinationen von 20-100 und extrahieren Sie y aus der gelernten Funktion
        px, py = np.meshgrid(np.arange(130, 190+1, 1), np.arange(20, 100+1, 1))
        graph_x = np.c_[px.ravel() ,py.ravel()]
        graph_y = sess.run(y, feed_dict={x: graph_x})
        #y ist die Farbabstufung (-In 1 zu 1 konvertieren)
        pz = np.hsplit(np.array([sum(e * [-1, 0, 1]) for e in graph_y]), len(px))
        plt.pcolor(px, py, pz)
        plt.cool()
        plt.pause(.01)
print ('w:',sess.run(w))
print ('b:',sess.run(b))

Impressionen

Ich habe nicht das Gefühl, dass ich es nicht einfach machen würde. Es war mein erstes Mal, dass ich Python ernsthaft berührte, aber ich war beeindruckt, wie einfach es war, Matrixoperationen durchzuführen. Ich möchte ein praktisches Material für maschinelles Lernen finden, aber ich kann es nicht leicht finden.

[PYTHON] TensorFlow Tutorial Tutorial