[Super Einführung] Maschinelles Lernen mit Python - Von der Umgebungskonstruktion bis zur Implementierung von Simple Perceptron-

Als allererstes

Dieser Artikel ist ein Artikel von ** DMM WEBCAMP Adventskalender Tag 7 **. Dieses Mal ist es eine super Einführungsausgabe, also habe ich sie für ** Leute erstellt, die noch nie maschinelles Lernen gemacht haben, aber anfangen wollen **.

** Da der Zweck darin besteht, maschinelles Lernen grob zu verstehen und vorerst zu versuchen, einfaches Perzeptron zu implementieren **, habe ich sehr grob über die Erklärung des maschinellen Lernens usw. geschrieben (wenn Sie es einzeln richtig schreiben) Es wird wahnsinnig lang sein). Wenn Sie mehr Details wissen möchten, überprüfen Sie es bitte.

Außerdem stellen wir dieses Mal die Umgebungskonstruktion für Windows 10 vor. Wenn es Teile gibt, die schwer zu vermitteln sind oder in Qiitas erstem Beitrag fälschlicherweise erkannt werden, würde ich es begrüßen, wenn Sie sie in den Kommentaren hervorheben könnten.

Overview Eine grobe Erklärung des maschinellen Lernens Python-Installation Miniconda installieren Implementierung von Simple Perceptron (Neuronales Netzwerk)

Eine grobe Erklärung des maschinellen Lernens

Was ist maschinelles Lernen?

Angenommen, eine Person, die von vorne kommt, nimmt ein Tier mit auf einen Spaziergang. Ich denke, Sie beurteilen hauptsächlich visuell, was das Tier ist (Hund oder Katze?) Und was die Hund- oder Katzenart ist. Angenommen, Sie hören ein Geräusch wie "Klicken, Klicken, Klicken ...". Ich denke, Sie beurteilen hauptsächlich, ob das Geräusch, das Sie hören, das Geräusch von Schritten, das Geräusch des Klatschens oder das Geräusch der Zeiger der Uhr ist. Auf diese Weise treffen Menschen Entscheidungen basierend auf ihren Erfahrungen in ihrem täglichen Leben.

Es gibt maschinelles Lernen, um daraus auch einen Computer zu machen. Indem der Computer iteriert und Entscheidungen mit hoher Genauigkeit trifft, können die Ergebnisse für unbekannte Daten vorhergesagt werden.

Arten des maschinellen Lernens

Methoden des maschinellen Lernens können grob in zwei Arten unterteilt werden: ** unbeaufsichtigt ** maschinelles Lernen und ** überwachtes ** maschinelles Lernen.

Maschinelles Lernen ohne Lehrer

Der größte Unterschied zum überwachten maschinellen Lernen besteht darin, dass es keine korrekten Antwortdaten gibt. Wenn 1000 Daten vorhanden sind, werden alle als Trainingsdaten behandelt. Es wird hauptsächlich nach gemeinsamen Merkmalen gruppiert und gruppiert. Die bekannteste Implementierungsmethode ist die ** K-Means-Methode **. Ich werde ohne Lehrer nicht mehr auf maschinelles Lernen eingehen, aber wenn Sie interessiert sind, schauen Sie es sich bitte an.

Maschinelles Lernen mit einem Lehrer

Im Gegensatz zum maschinellen Lernen ohne Lehrer handelt es sich um eine Lernmethode mit korrekten Antwortdaten. Unter der Annahme, dass 1000 Daten vorhanden sind, werden beispielsweise 700 Teile in Trainingsdaten unterteilt und 300 Teile sind korrekte Antwortdaten, und das Lernen wird wiederholt. Unter ihnen werde ich diesmal auf neuronale Netze und tiefes Lernen eingehen.

neurales Netzwerk

Dies ist eine Lernmethode, die auf einem Modell von Nervenzellen im menschlichen Gehirn basiert. Mehrere Nervenzellen sind verbunden, erhalten Eingaben von der Synapse der benachbarten Nervenzelle und übertragen Informationen an die benachbarte Nervenzelle. Auf diese Weise wird das neuronale Netzwerk in eine Eingangsschicht und eine Ausgangsschicht unterteilt, und wenn das Gesamtgewicht der Eingangsschichten einen bestimmten Wert überschreitet, wird ein Wert in die Ausgangsschicht eingegeben. Dieses Mal werden wir ein Programm erstellen, das dieses neuronale Netzwerk implementiert.

Tiefes Lernen

Grob gesagt wird Deep Learning durch die Integration eines neuronalen Netzwerks in mehrere Schichten erschwert. Im Vergleich zum maschinellen Lernen im letztjährigen Artikel ** DMM WEBCAMP Adventskalender ** "Für Super-Anfänger. Unterschiede zwischen Deep Learning und maschinellem Lernen" Es wurde über tiefes Lernen geschrieben, bitte beziehen Sie sich auch darauf.

Eine grobe Erklärung wurde fortgesetzt, aber das ist alles für die Erklärung. Könnten Sie irgendwie verstehen, wie maschinelles Lernen ist? Lassen Sie uns nun eine Umgebung für maschinelles Lernen erstellen.

Python-Installation

Schließlich müssen Sie zuerst Python installieren.

Windows-Versionsprüfung

Stellen Sie vorher sicher, dass Sie über die neueste Version von Windows verfügen. Die neueste Version vom Dezember 2019 ist ** Version 1909 **. Wenn es sich nicht um die neueste Version handelt, empfehlen wir die Aktualisierung auf die neueste Version.

Python-Installation

Gehen Sie zu https://www.python.org und gehen Sie zu ** Download ** in der Mitte der Seite, die Sie zuletzt besucht haben. ** Python (* Vision *) )**Klicken. Die neueste Version von Python ab Dezember 2019 ist ** Python 3.8.0 **.

Klicken Sie unten auf der Zielseite unter ** Dateien ** auf ** ausführbares Windows x86-64-Installationsprogramm **, um das Python-Installationsprogramm herunterzuladen.

Starten Sie das heruntergeladene Installationsprogramm und aktivieren Sie ** Python (* Virsion *) zu PATH hinzufügen **, bevor Sie mit der Installation beginnen. Auf diese Weise können Sie Python an der Eingabeaufforderung starten. Wenn Sie es nicht benötigen, starten Sie die Installation, ohne es zu überprüfen.

Wenn auf dieser Seite ** Pfadlängenbeschränkung deaktivieren ** angezeigt wird und Sie benachrichtigt werden, dass die Installation abgeschlossen ist, können Sie diese auswählen, um die Dateipfadlängenbeschränkung zu entfernen. Das Image ist nicht sichtbar, da es bei der vorherigen Installation von Python angehoben wurde.

Damit ist die Python-Installation abgeschlossen. Sie können ** IDLE ** in das Startmenü von Windows eingeben und den Code in das ausgewählte und gestartete Programm eingeben. So ist es einfach, Python-Programme ohne einen Texteditor wie Sublime Text 3 oder Visual Stdio Code zu schreiben.

** Wenn Sie noch nie ein Python-Programm geschrieben haben **, sollten Sie es vor der Implementierung von Simple Perceptron ein wenig berühren. Wenn Sie regelmäßig C oder Java schreiben, können Sie mit einer kleinen Menge an Beschreibung ausdrücken, was Sie tun möchten, damit Sie es leicht verstehen können.

Miniconda installieren

Was ist Miniconda?

Miniconda ist eines der Systeme, die von einem Open-Source-Managementsystem namens ** Conda ** bereitgestellt werden. Es gibt eine andere ** Anaconda **, die Miniconda ähnelt, aber im Grunde dieselbe ist. Da für die Installation von Anaconda eine ziemlich große Datei erforderlich ist, sind nur die minimal erforderlichen Funktionen erforderlich. Das ist Miniconda. Es sieht aus wie ** Anaconda ⊆ Miniconda **.

Die Datenanalyse kann bequemer mit Python + Miniconda durchgeführt werden.

Miniconda installieren

Gehen Sie zur Dokumentation zu Miniconda - Conda (https://docs.conda.io/en/latest/miniconda.html) und laden Sie das Miniconda-Installationsprogramm herunter. Wählen Sie im ** Windows-Installationsprogramm ** die neueste Version von Python ** Miniconda3 Windows 64-Bit ** aus und laden Sie sie herunter. Ich habe diesmal kein Python 3.8 Miniconda, aber Python 3.7 Miniconda ist in Ordnung.

Starten Sie das heruntergeladene Installationsprogramm, wählen Sie Next-> I Agree und stellen Sie sicher, dass das Optionsfeld ** Just Me (empfohlen) ** ausgewählt ist, bevor Sie fortfahren.

Es wird empfohlen, mit dem nächsten Bildschirm fortzufahren, ohne Änderungen vorzunehmen, da das Ändern des ** Zielordners **, der auf dem nächsten Bildschirm angezeigt wird, problematisch sein kann.

Korrigieren Sie im Bildschirm ** Erweiterte Installationsoptionen ** die Standard-Python-Version auf 3.7, deaktivieren Sie ** Registrieren Sie Aaconda als meine Standard-Python 3.7 ** und starten Sie die Installation von **.

Deaktivieren Sie in diesem Bildschirm, der nach Abschluss der Installation angezeigt wird, beide, bevor Sie das Installationsprogramm beenden.

Aufbau einer virtuellen Umgebung

Starten wir Anaconda Prompt über die Startschaltfläche von Windows. Ich habe Miniconda installiert, aber wie bereits erwähnt, hat Miniconda unter Anaconda nur die Mindestfunktionen, daher lautet die Notation Anaconda. Geben Sie den folgenden Befehl ein, um mit der Umgebungskonstruktion fortzufahren.

Update der installierten conda

conda update conda -y

AnacondaPrompt

>conda update conda -y
Collecting package metadata (current_repodata.json): done
Solving environment: done

# All requested packages already installed.

Wenn es so herauskommt, gibt es kein Problem.

Ab Dezember 2019 gibt es keine Miniconda, die Python 3.8 unterstützt, daher unterstützt Anaconda Prompt Python in Version 3.7. Es gibt jedoch fast kein Problem. Sie können es mit conda list überprüfen.

AnacondaPrompt

>conda list
# packages in environment at C:\Users\Nutzername\Miniconda3:
#
# Name                    Version                   Build  Channel
asn1crypto                1.2.0                    py37_0
ca-certificates           2019.11.27                    0
･ ･ ･
python                    3.7.4                h5263a28_0

Erstellen einer virtuellen Umgebung

Der Umgebungsname ist frei, aber dieses Mal fahren wir mit ** NN_sample ** fort. Geben Sie die Python-Version auf 3.7.4 an und erstellen Sie eine virtuelle Umgebung, um das Problem zu beheben, das durch den Versionsunterschied verursacht wird, der durch die Installation von Python 3.8 verursacht wird. Geben Sie für ** Weiter ([y] / n)? **, das unterwegs angezeigt wird, ** y ** ein und drücken Sie die Eingabetaste.

conda create -n NN_sample python=3.7.4

AnacondaPrompt

>conda create -n NN_sample python=3.7.4
Collecting package metadata (current_repodata.json): done
Solving environment: done

## Package Plan ##

  environment location: C:\Users\Nutzername\Miniconda3\envs\NN_sample



Proceed ([y]/n)? y

Preparing transaction: done
Verifying transaction: done
Executing transaction: done
#
# To activate this environment, use
#
#     $ conda activate NN_sample
#
# To deactivate an active environment, use
#
#     $ conda deactivate

Starten Sie die virtuelle Umgebung. Es kann mit "Umgebungsname aktivieren" aktiviert werden. Wenn der Start erfolgreich ist, ändert sich ** (Basis) ** in ** (Umgebungsname) **.

AnacomdaPrompt

(base) C:\Users\Nutzername>activate NN_sample
(NN_sample) C:\Users\Nutzername>

Fügen Sie die erforderlichen Bibliotheken hinzu

Wir werden die erforderlichen Bibliotheken in die virtuelle Umgebung einfügen, damit "#include <~ .h>" in C und "import java.io" in Java ausgeführt werden können. Bitte fahren Sie mit der gestarteten virtuellen Umgebung fort. Die folgenden 5 werden dieses Mal installiert.

• Jupyter Lab
• NumPy
• matplotlib
• TensorFlow
• Keras

** jupyter lab ** ist keine Bibliothek, sondern ein Texteditor, wie ein Web-Tool, mit dem Sie im Gegensatz zu den anderen, die Sie diesmal installieren, beim Überprüfen von Daten Code erstellen können. Früher war ** jupyter notebook ** der Mainstream, heute ist es ein Bild der Verwendung von jupyter lab. Geben Sie den folgenden Befehl ein, um jupyter lab zu installieren.

AnacondaPrompt

>conda install -c conda-forge jupyterlab

Wir werden die notwendigen Bibliotheken installieren. Ich werde nicht auf die Beschreibung jeder Bibliothek eingehen, aber zumindest werden sie alle benötigt, um ein einfaches Perceptron zu implementieren.

AnacondaPrompt

>conda install numpy matplotlib tensorflow keras

Es gibt viele andere Bibliotheken, und ich werde nur einige schreiben, die ich in Zukunft für maschinelles Lernen verwenden werde.

• Python Imaging Library
• SciPy
• pandas
• NetWorkX (Graph-Algorithmen statt maschinelles Lernen)

Das ist alles für den Aufbau der Umgebung, einschließlich der virtuellen Umgebung.

Implementierung von Simple Perceptron

Ich bin endlich da. Wir werden ein Programm erstellen, das Simple Perceptron im Jupyter Lab implementiert. Lassen Sie uns vorher einen kurzen Blick auf das Simple Perceptron werfen.

Was ist einfaches Perceptron?

Wie bereits erwähnt, ist ein einfaches Perzeptron eine Art neuronales Netzwerk. Daher wird es in eine Eingabeschicht und eine Ausgabeschicht unterteilt, und wenn die Summe der Eingabeschichten einen bestimmten Wert überschreitet, werden Informationen an die Ausgabeschicht übertragen. Ein einfaches Perzeptron hat ** mehrere Eingänge und einen einzigen Ausgang **. Wenn die Gewichte jeder Eingabeschicht W1, W2, ..., Wx und die Gewichte, die nicht mit der Eingabeschicht zusammenhängen, θ sind, ist die Summe des Produkts jedes Eingabewerts und des Gewichts und der Summe von θ größer als 0. Ausgänge 1, sonst 0. Wenn Sie es in ein Modell schreiben, ist es wie folgt. Wenn Sie es in einer mathematischen Formel schreiben,

N₁ × W₁ + N₂ × W₂ + ... + Nx × Wx + θ > 0 

Es wird sein. Auch wenn Sie die linke Seite organisieren,

\frac{N₁}{N₂} × W₁ + W₂ + \frac{θ}{N₂} = 0 \\
W₂ = (- \frac{N₁}{N₂}) × W₁ + (- \frac{θ}{N₂})

Es ist schwer zu verstehen, wenn Sie also die Variable ändern

y = a × x + b

Sie können sehen, dass es eine gerade Linie ist. Mit anderen Worten, mit dem einfachen Perzeptron können Sie eine gerade Linie zeichnen, die den Eingabewert und den Ausgabewert wie unten gezeigt in zwei Teile teilt.

Das ist eine grobe Erklärung des einfachen Perzeptrons. Könntest du das auch irgendwie verstehen? Dieses Mal erstellen wir ein Programm, das sich für die ** UND-Funktion ** mit zwei Eingängen in zwei Teile teilt. Die UND-Funktion gibt 1 aus, wenn beide Eingänge 1 sind, andernfalls 0. Daher wird die Aufteilung wie folgt erwartet.

Vorbereitungen

Verwenden Sie den Befehl ** cd **, um in den Arbeitsordner zu wechseln und dann jupyter lab zu starten. Dieses Mal machen wir es unter "Dokumente / Beispiel".

AnacondaPrompt

(base) C:\Users\Nutzername>cd Documents

#Beispielordner erstellen
(base) C:\Users\Nutzername\Documents>mkdir sample

(base) C:\Users\Nutzername\Documents>cd sample

(base) C:\Users\Nutzername\Documents\sample>activate NN_sample

(NN_sample) C:\Users\Nutzername\Documents\sample>

Starten Sie Jupyter Lab

Geben Sie für jupyter lab einfach "jupyter lab" ein, um jupyter lab zu starten und den Webbrowser zu starten. Wenn es nicht gestartet wird, kopieren Sie nach dem Ausführen von "jupyter lab" die URL, die am Ende des angezeigten Satzes steht, und greifen Sie mit einem Browser darauf zu.

AnacondaPrompt

(NN_sample) C:\Users\Nutzername\Documents\Ordnernamen>jupyter lab
[I 20:43:50.910 LabApp] JupyterLab extension loaded from C:\Users\Nutzername\Miniconda3\envs\Umgebungsname\lib\site-packages\jupyterlab
･ ･ ･
    Or copy and paste one of these URLs:
        http://localhost:8888/?token=43ed3a669bd4da587fa6febf75f3e38b0f7de64916e96648
     or http://127.0.0.1:8888/?token=43ed3a669bd4da587fa6febf75f3e38b0f7de64916e96648

Notizbuch erstellen

Es spielt keine Rolle, wie Sie es erstellen, aber wählen Sie oben links im Jupyter-Labor * Datei-> Neu-> Notizbuch *, um ein neues Notizbuch zu erstellen. Der ** Select Kernel **, der nach der Auswahl angezeigt wird, kann als ** Python 3 ** belassen werden.

Im erstellten Notizbuch ist der Code in Zellen unterteilt, und Sie können für jede Zelle Code, Markdown und Raw auswählen. Wenn Sie die Zellen richtig teilen können, können Sie nur den erforderlichen Teil des Programms ausführen. Sie können jede Zelle ausführen, indem Sie Umschalt + Eingabetaste drücken.

Codeerstellung

Importieren Sie die erforderlichen Bibliotheken

Installieren Sie zunächst die erforderlichen Bibliotheken. Beschreiben Sie mit "Name der Importbibliothek" oder "Name der Importbibliothek als im Programm verwendeten Namen".

sample.ipynb

import numpy as np
import matplotlib.pyplot as plt
import os
import csv
from keras.models import Sequential
from keras.layers import Dense, Activation

Definition von Umgebungsvariablen

Hier werden die im Code verwendeten Variablen definiert. Diesmal handelt es sich um einen Kurzcode, aber insbesondere beim maschinellen Lernen gibt es viele Möglichkeiten, die Anzahl der Lernvorgänge und die angegebene Datei zu ändern. Wenn Sie ihn also sofort definieren und diese Zelle bearbeiten, können Sie ihn auf alles im Programm anwenden.

sample.ipynb

CSVFILE = 'data.csv'
GRIDFILE = 'grid.csv'
header = ['x', 'y', 'class']
body = [
    [0, 0, 0],
    [1, 0, 0],
    [0, 1, 0],
    [1, 1, 1]
]

Erstellen einer CSV-Datei

Wir werden die Add-Funktion, die später das Modell sein wird, in die CSV-Datei schreiben. Außerdem wird eine CSV-Datei erstellt, um das Raster zu erstellen, das zum Zeichnen des trainierten Diagramms erforderlich ist. Es ist kein wesentlicher Teil, daher ist es in Ordnung, ihn zu überspringen. Da Sie nur eine CSV-Datei erstellen müssen, können Sie diese Zelle grundsätzlich nur einmal ausführen.

sample.ipynb

#Löschen Sie alle CSV-Dateien mit dem Namen CSVFILE
if os.path.exists(CSVFILE):
    os.unlink(CSVFILE)
if os.path.exists(GRIDFILE):
    os.unlink(GRIDFILE)

#In Datei schreiben
# with open(Dateiname, den Sie behandeln möchten,Modus(w:Schreiben))als Variablenname:
with open(CSVFILE, 'w') as v:
    writer = csv.writer(v)
    writer.writerow(header)
    writer.writerows(body)

with open(GRIDFILE, 'w') as v:
    x = float(0)
    y = float(0)
    writer = csv.writer(v)
    writer.writerow([x, y])
    pre_x = x
    pre_y = y
    for _ in range(0, 20):
        pre_y += 0.05
        writer.writerow([round(pre_x, 4), round(pre_y, 4)])
    for _ in range(0, 20):
        pre_y = y
        pre_x += 0.05 
        for _ in range(0, 21):
            writer.writerow([round(pre_x, 4), round(pre_y, 4)])
            pre_y += 0.05

CSV-Datei lesen

Extrahieren Sie die CSV-Datei mit den für das Training erforderlichen Daten. Extrahieren Sie mit Pythons einzigartigem ** Slice **. Zusätzlich zum Schneiden ist es auch möglich, mit ** Pandas ** als ** Datenflammentyp ** zu extrahieren. Diesmal benötigen wir jedoch den ndarray-Typ, sodass wir mit Slices extrahieren. Slices müssen noch mehr Elemente kennen. Weitere Informationen finden Sie unter hier.

sample.ipynb

#Überspringen Sie die erste Zeile von CSVFILE,','Getrennt durch, in variablen Daten als ndarray-Typ gespeichert
data = np.loadtxt(CSVFILE, delimiter=',', skiprows=1)

#Extrahieren Sie andere Daten als die letzte Spalte
ip_train = data[:, :-1]
# [[0. 0.]
#  [1. 0.]
#  [0. 1.]
#  [1. 1.]]

#Extrahieren Sie die letzte Datenspalte
class_train = data[:, -1]
# [0. 0. 0. 1.]

Ausführung des Lernens

Wenn Sie eine Warnung erhalten, ist daran nichts auszusetzen, aber versuchen Sie es erneut.

• Sequential()

Generieren Sie einen Konstruktor zum Lernen. Daher können Sie Ebenen mit der Variablen .add (...) hinzufügen, die Sequential () speichert. Natürlich können Sie auch Ebenen gleichzeitig schreiben, z. B. "Sequential ([Dense (...), Activation (...)])".

• add(Dense(...))

Wie bereits erwähnt, werden wir dem Konstruktor Ebenen zum Lernen hinzufügen. Diesmal ist die Aktivierungsfunktion sigmoid, die Anzahl der Neuronen ist 1 und der Eingabewert ist 2. In diesem Fall bestimmt die Aktivierungsfunktion, wie * N₁ × W₁ + N₂ × W₂ + ... + Nx × Wx + θ * an die Ausgangsschicht übertragen wird. Andere sind ** softmax ** und ** relu **.

• compile(...)

Beim Kompilieren werden detaillierte Lerneinstellungen vorgenommen. Setzen Sie die Verlustfunktion, die Sie im Training minimieren möchten, auf ** binary_crossentropy **, die Bewertungsfunktion, die die Leistung unabhängig vom Training auf ** Genauigkeit ** bewertet, und die Optimierungsmethode auf ** sgd **.

• fit(...)

Hier wird gelernt. Geben Sie das Testmodell, die Anzahl der Epochen und die Chargengröße an.

sample.ipynb

#Generieren eines neuronalen Netzwerkkonstruktors
model = Sequential()

model.add(Dense(1, input_dim=2, activation='sigmoid')) # Dense(Anzahl der Neuronen in der Schicht,Anzahl der Eingangsdimensionen,Aktivierungsfunktion)

#Lerneinstellungen.compile(Verlustfunktion,Optimierungsmethode,Bewertungsfunktion)
model.compile(loss='binary_crossentropy',　optimizer='sgd', metrics=['accuracy'])

#Ausführung des Lernens
fg = model.fit(ip_train, class_train, epochs=1000, batch_size=1)
# Train on 4 samples
# Epoch 1/1000
# 4/4 [==============================] - 1s 137ms/sample - loss: 0.7022 - acc: 0.7500
# Epoch 2/1000
# 4/4 [==============================] - 0s 5ms/sample - loss: 0.7004 - acc: 0.7500
# Epoch 3/1000
# 4/4 [==============================] - 0s 5ms/sample - loss: 0.6987 - acc: 0.7500
#･ ･ ･
# Epoch 999/1000
# 4/4 [==============================] - 0s 4ms/sample - loss: 0.2649 - acc: 1.0000
# Epoch 1000/1000
# 4/4 [==============================] - 0s 3ms/sample - loss: 0.2647 - acc: 1.0000

Zeichnen eines Diagramms

Nachdem das Training abgeschlossen ist, möchte ich Predict () verwenden, um die Grenzen vorherzusagen, und Matplotlib verwenden, um die Ergebnisse anzuzeigen. Auch dieses Mal werden wir Slices verwenden, um die erforderlichen Daten zu extrahieren und anzuzeigen. Der Code enthält nichts anderes, was im Detail erklärt wird. Schauen Sie sich also den Code an.

sample.ipynb

t1 = ip_train[ class_train==1 ] 
t0 = ip_train[ class_train==0 ]

#Ein Array von x-Koordinaten von Punkten mit einem Lehrersignal von 1
t1_x = t1[:, 0] 
#Ein Array von y-Koordinaten von Punkten mit einem Lehrersignal von 1
t1_y = t1[:, 1] 
t0_x = t0[:, 0]
t0_y = t0[:, 1]

# ','Lesen Sie GRIDFILE getrennt durch
g = np.loadtxt(GRIDFILE, delimiter=',')

#Vorhersagen von Grenzen aus Lernergebnissen
pred_g = model.predict(g)[:, 0]

#Ein Array von Punkten mit einem vorhergesagten Wert von 1
g1 = g[ pred_g >= 0.5 ]
#Ein Array von Punkten mit einem vorhergesagten Wert von 0
g0 = g[ pred_g < 0.5 ]

#Ein Array von x-Koordinaten von Punkten mit einem vorhergesagten Wert von 1
g1_x = g1[:, 0]
#Ein Array von y-Koordinaten von Punkten mit einem vorhergesagten Wert von 1
g1_y = g1[:, 1]

g0_x = g0[:, 0]
g0_y = g0[:, 1]

plt.scatter(t1_x, t1_y, marker='o', facecolor='black', s=100)
plt.scatter(t0_x, t0_y, marker='o', facecolor='white', edgecolor='black', s=100)
plt.scatter(g1_x, g1_y, marker='o', facecolor='black', s=20)
plt.scatter(g0_x, g0_y, marker='o', facecolor='white', edgecolor='black', s=20)
plt.show()

Wenn ich es ausführe, kann ich die Zeilen nicht sehen, aber ich glaube, ich konnte sie wie erwartet klassifizieren. Schwarz 〇 ist der Teil, der als Ausgabeergebnis 1 betrachtet wird, und Weiß 〇 ist der Teil, der als Ausgabeergebnis 0 betrachtet wird. Dies ist das Ende einschließlich der Implementierung.

Schließlich

Ich habe ungefähr die Implementierung des grundlegendsten einfachen Perceptron durchlaufen. Auch in diesem Artikel geht es darum, ** eine grobe Vorstellung vom maschinellen Lernen zu bekommen und zu versuchen, ein einfaches Perzeptron zu implementieren **. Ich hoffe, es gibt Ihnen die Möglichkeit, mit dem maschinellen Lernen zu beginnen. Ich werde. Wenn es komplizierter wird, wird es möglich zu unterscheiden, was im Bild reflektiert wird, und die Audiodaten zu identifizieren. Bitte probieren Sie es aus und implementieren Sie es. Außerdem schreiben Senior Mentoren und Mitarbeiter im DMM WEBCAMP Adventskalender, an dem ich in dieser Zeit teilnehme, erstaunlichere Artikel. Wenn Sie interessiert sind, schauen Sie bitte.

Referenzseite

Maschinelles Lernen

Maschinelles Lernen von Grund auf neu (Überblick über maschinelles Lernen) [Unterschied zwischen überwachtem Lernen und unbeaufsichtigtem Lernen - KI-Technologie für künstliche Intelligenz](https://newtechnologylifestyle.net/%E6%95%99%E5%B8%AB%E3%81%82%E3%82% 8A% E5% AD% A6% E7% BF% 92% E3% 81% A8% E6% 95% 99% E5% B8% AB% E3% 81% AA% E3% 81% 97% E5% AD% A6% E7% BF% 92% E3% 81% AE% E9% 81% 95% E3% 81% 84% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /) Deep Learning - Drei Dinge, die Sie wissen sollten- [Clusteranalyse mit Scikit-Learn (K-Means-Methode) - Data Science mit Python](https://pythondatascience.plavox.info/scikit-learn/%E3%82%AF%E3%83%A9%E3%82] % B9% E3% 82% BF% E5% 88% 86% E6% 9E% 90-k-Mittel)

Python im Zusammenhang

So installieren Sie Python (Windows)

Miniconda verwandt

Miniconda-Verwendungshinweis - Lesehinweis v1.5dev - Fertighaus Installieren Sie Miniconda unter Windows (2018) - Qiita [Für Anfänger] Erstellen Sie eine virtuelle Umgebung mit Anaconda --Qiita Empfehlung von Jupyter Lab - Qiita

Perse Proton verwandt

[Über die einfachste einfache Perceptron-AI-Technologie für künstliche Intelligenz](https://newtechnologylifestyle.net/%E4%B8%80%E7%95%AA%E7%B0%A1%E5%8D%98%E3% 81% AA% E5% 8D% 98% E7% B4% 94% E3% 83% 91% E3% 83% BC% E3% 82% BB% E3% 83% 97% E3% 83% 88% E3% 83% AD% E3% 83% B3% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /) Einführung in Deep Learning ab Keras / Tensorflow - Qiita Implementierung von mehrschichtigem Perceptron-Python und maschinellem Lernen