Grundlegendes Neuronales Netzwerk in Python, um Vorhersagen zu treffen

Ein neuronales Netzwerk ist ein Netzwerk komplexer miteinander verbundener Verarbeitungselemente, die zusammenarbeiten, um Probleme zu lösen. Es ist ein großartiges Beispiel für paralleles Rechnen und ein Beispiel für eine Nicht-von-Neumann-Architektur. In diesem Artikel erstellen wir ein neuronales Feed-Forward-Netzwerk und betrachten die verschiedenen Aspekte neuronaler Netzwerke und verwenden Backpropagation, um seine Ergebnisse vorherzusagen.

Dieser Artikel wird in einem Unterrichtsstil des Fachs präsentiert und jedes Thema wird mit einer Erklärung verbunden. Dieser Artikel wird auch versuchen, einige der eher technischen Aspekte neuronaler Netze in einfachen Worten zu erklären.

Was ist ein neuronales Feed-Forward-Netzwerk?

Die Feed-Forward Neural Networks (FFNNs) waren die erste und einfachste Art von künstlichen neuronalen Netzwerken, die entwickelt wurden. Diese Art von neuronalem Netzwerk ist von der hierarchischen Organisation des menschlichen Gehirns inspiriert. Es besteht aus einer einzigen Schicht von Knoten, im Gegensatz zu den drei Schichten von Knoten, die im Perzeptron vorhanden sind. Es besteht aus einer Eingabeschicht, einer oder mehreren verborgenen Schichten und einer Ausgabeschicht. Jedem Neuron ist eine Gewichtung zugeordnet, und es leitet ein Signal an die nächste Schicht weiter, indem es die Eingabe mit seiner Gewichtung multipliziert. Die Idee von neuronalen Feedforward-Netzen besteht darin, diese Neuronengewichte so zu trainieren, dass sie die Eingabe verwenden, um die Ausgabe vorherzusagen.

Der Backpropagation-Algorithmus ist ein Lernalgorithmus, der die Neuronengewichte anpasst, um die Differenz zwischen der Ausgabe und dem Ziel zu minimieren. Ein mit Backpropagation trainiertes neuronales Netzwerk versucht, mithilfe von Eingaben die Ausgabe vorherzusagen. Und das werden wir hier versuchen.

Planung unseres neuronalen Netzwerks

Als erstes müssen wir das Trainingsset vorbereiten, das wir verwenden werden. Wir werden das System mit vier separaten Beispielen des Problems (Situationen 1 bis 4) versorgen, in denen wir bereits die Lösung berechnet haben. Die ersten vier Situationen werden als Trainingssatz bezeichnet.

In der unten gezeigten Tabelle sind die Trainingssätze die Situationen 1 bis 4. Sie enthalten Eingabewerte und ihre tatsächliche Ausgabe. Was wir tun wollen, ist, eine neue Situation (eine Reihe von Eingaben) zu schaffen und zu versuchen, ihre Ausgabe vorherzusagen.

Sie haben es vielleicht schon bemerkt, aber wenn wir uns die Eingabe auf der linken Seite ansehen, sehen wir, dass die Ausgabe uns immer denselben Wert liefert. Daher wäre unsere Antwort 1.

Voraussetzungen

Das einzige, was wir für dieses Projekt brauchen, ist NumPy. NumPy ist das grundlegende Paket für wissenschaftliches Rechnen in Python, das einfach mit pip installiert werden kann:

pip install numpy

der Code

Jetzt, mit den oben genannten Informationen und einem Endziel vor Augen, können wir mit dem Codieren beginnen. Zuerst sollten wir einen Ordner zum Speichern unserer Dateien erstellen, nennen wir ihn ffnn tutorial und erstellen eine Datei namens main.py.

Ich habe dem folgenden Code Kommentare hinzugefügt, um alles zu beschreiben, was auf hoher Ebene vor sich ging. Außerdem habe ich einige der größten Funktionen in kleinere, leichter verständliche Teile umstrukturiert. Hier ist ein vollständiges Python-Codebeispiel, wie Sie dies erstellen könnten:

#main.py

import numpy as np

class NeuralNetwork():  #create the one and only class we'll need
   
    def __init__(self):
        np.random.seed(1)  #seed the random number generator

        self.synaptic_weights = 2 * np.random.random((3, 1)) - 1  #make your own custom 3 x 1 matrix and assign random weights to it with values ranging from -1 to 1 and 0 mean

    def sigmoid(self, x): #takes in each individually weighted input's sum of the inputs and transforms them between 0 and 1 through the sigmoid function
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):  #the derivative of the sigmoid function used to calculate necessary weight adjustments
        return x * (1 - x)

    def train(self, training_inputs, training_outputs, training_iterations):  #We train the model through trial and error, adjusting the synaptic weights each time to get a better result

        for iteration in range(training_iterations):
            output = self.think(training_inputs)  #pass training set through the neural network
            error = training_outputs - output  #calculate the error rate
            adjustments = np.dot(training_inputs.T, error * self.sigmoid_derivative(output))  #multiply error by input and gradient of the sigmoid function, less confident weights are adjusted more through the nature of the function
            self.synaptic_weights += adjustments  #adjust synaptic weights

    def think(self, inputs):  #pass inputs through the neural network to get output
        inputs = inputs.astype(float)
        output = self.sigmoid(np.dot(inputs, self.synaptic_weights))
        return output


if __name__ == "__main__":  #initialize the single neuron neural network
    neural_network = NeuralNetwork()
    print("Random starting synaptic weights: ")
    print(neural_network.synaptic_weights)

    training_inputs = np.array([[0,0,1],  #the training set, with 4 examples consisting of 3 input values and 1 output value 
                                [1,1,1],
                                [1,0,1],
                                [0,1,1]])

    training_outputs = np.array([[0,1,1,0]]).T

    neural_network.train(training_inputs, training_outputs, 10000)  #train the neural network
    print("Synaptic weights after training: ")
    print(neural_network.synaptic_weights)

    A = str(input("Input 1: ")) #these are the three inputs it will take, as show in the table above
    B = str(input("Input 2: "))
    C = str(input("Input 3: "))
   
    print("New situation: input data = ", A, B, C)
    print("Output data: ")
    print(neural_network.think(np.array([A, B, C])))

Und das haben wir geschafft!

Ausgabe

Um nun tatsächlich zu testen, ob es überhaupt funktioniert, können Sie den Code ausführen, indem Sie einfach „python“ eingeben, gefolgt vom Namen der Datei, in der wir den Code geschrieben haben (in unserem Fall main.py). Öffnen Sie einfach das Terminal in dem von uns erstellten Ordner ffnn_tutorial und führen Sie den Befehl aus:

python main.py  #Windows
python3 main.py  #Linux/Mac

Wenn der Code erfolgreich ausgeführt wurde, sollten Sie eine Antwort wie diese erhalten:

Werfen wir nun einen Blick auf die Ausgabe des neuronalen Netzes; Hier im ersten Abschnitt können Sie das neuronale Netzwerk sehen, das sich im Startabschnitt „Zufällige synaptische Startgewichte:“ zufällige Gewichtungen zugewiesen hat, dann trainierte es sich selbst mit dem Trainingssatz und druckte die Ergebnisse in „Synaptische Gewichte nach dem Training:“ Sektion.

Danach können Sie sehen, dass es nach Eingaben fragt, genau so haben wir es im Code und am Anfang des Artikels definiert. Wir können es einzeln bis zu insgesamt drei eingeben, und wir sollten unsere Ergebnisse erhalten.

Und nachdem Sie die zuvor im Artikel vorgeschlagenen Werte eingegeben haben, können Sie oben sehen, dass wir die Ausgabe von 0,99993704 erhalten, was nicht genau die richtige Antwort (1) ist, aber immer noch sehr nah dran ist!

der Abschluss

Herkömmliche Computerprogramme sind normalerweise nicht lernfähig. Sie tun einfach das, wozu sie programmiert sind, um Menschen dabei zu helfen, ihre Arbeit zu erledigen. Ähnlich wie ein Taschenrechner Ihnen bei der Mathematik hilft, sich aber nicht selbst beibringen kann, wie man Zahlen multipliziert, weil er nicht aus Erfahrung lernt, können wir uns nicht auf traditionelle Programme verlassen, um die Irrungen und Wirrungen der realen Welt zu lösen sich. Das Erstaunliche an neuronalen Netzen ist, dass sie kreativ sein können! Sie können lernen und sich anpassen. Genau wie der menschliche Verstand. Es gibt endlose Möglichkeiten, wenn es um neuronale Netze geht, und ebenso interessant, etwas Großartiges zu schaffen oder einfach nur zu lernen und damit herumzuspielen.

Hier sind einige nützliche Tutorials, die Sie lesen können:

• Echtzeit-Zwischenflussschätzung für die Videoframe-Interpolation mit Python
• Pandas Spickzettel
• Extrahieren Sie gespeicherte Chrome-Passwörter und entschlüsseln Sie sie mit Python
• Vergleichen Sie zwei Bilder und markieren Sie Unterschiede mit Python
• Generieren von QR-Codes und Barcodes in Python
• Emotionserkennung mit Python
• Wie führe ich mein Python-Skript auf Docker aus?
• Wetterinformationen mit Python abrufen
• Erstellen Sie eine News-Aggregator-Site mit Python