Beispiele für neuronale Netzwerke in Python

Python wurde schon immer wegen seiner einfachen, flexiblen Syntax und seines leistungsstarken Ökosystems und seiner Bibliotheken häufig verwendet und geliebt, auch in Bereichen wie wissenschaftliches Rechnen und maschinelles Lernen. Neuronale Netze spielen eine wichtige Rolle im Bereich des maschinellen Lernens und können in vielen Bereichen wie Computer Vision, Verarbeitung natürlicher Sprache und Empfehlungssystemen eingesetzt werden. In diesem Artikel werden neuronale Netze in Python vorgestellt und einige Beispiele gegeben.

Was ist ein neuronales Netzwerk?

Neuronales Netzwerk ist ein Deep-Learning-Modell, das die Eigenschaften hat, das Nervensystem von Tieren zu simulieren. Ein neuronales Netzwerk besteht aus mehreren Neuronen. Seine Eingabe ist die Ausgabe anderer Neuronen, die von einer Aktivierungsfunktion verarbeitet wird, um eine Ausgabe zu erzeugen. Neuronale Netze nutzen den Backpropagation-Algorithmus, um Gewichtungen und Verzerrungen kontinuierlich anzupassen, sodass das Modell die Daten besser anpassen und Vorhersagen oder Klassifizierungen treffen kann.

TensorFlow

TensorFlow ist ein beliebtes Deep-Learning-Framework von Google zum Aufbau neuronaler Netze und anderer Algorithmen für maschinelles Lernen. TensorFlow wurde ursprünglich für interne Google-Forscher entwickelt und entwickelte sich nach seiner Einführung als Open Source schnell zu einem der beliebtesten Deep-Learning-Frameworks.

In TensorFlow können wir die folgenden Schritte verwenden, um ein neuronales Netzwerk zu erstellen:

1. Vorbereiten des Datensatzes: Der Datensatz muss in zwei Teile unterteilt werden: Trainingssatz und Testsatz. Der Trainingssatz wird zum Trainieren des Modells verwendet, während der Testsatz zum Testen der Genauigkeit des Modells verwendet wird.
2. Neuronales Netzwerk erstellen: Mit Python können Sie neuronale Netzwerke schreiben und implementieren. Neuronale Netzwerkmodelle können mit der TensorFlow-API erstellt werden.
3. Trainieren Sie das Modell: Trainieren Sie das neuronale Netzwerkmodell, um die Ausgabe neuer Daten vorherzusagen. Dies kann durch die Verwendung des stochastischen Gradientenabstiegsalgorithmus und die Durchführung einer Backpropagation erreicht werden, wobei die Gewichte und Verzerrungen des Modells kontinuierlich aktualisiert werden.
4. Testen Sie das Modell: Testen Sie das Modell mit dem Testset, um seine Genauigkeit zu bestimmen. Zur Bewertung der Leistung des Modells können verschiedene Metriken verwendet werden, z. B. Präzision, Rückruf und F1-Score.

Jetzt stellen wir zwei Beispiele für neuronale Netze vor, die mit TensorFlow implementiert wurden.

Neuronales Netzwerk Beispiel 1: Handschriftliche Ziffernerkennung

Die handschriftliche Ziffernerkennung ist ein wichtiges Problem im Bereich Computer Vision, und neuronale Netzwerke haben bei diesem Problem gute Ergebnisse erzielt. In TensorFlow können Sie ein neuronales Netzwerk mithilfe des MNIST-Datensatzes trainieren, der 60.000 28x28-Graustufenbilder und entsprechende Beschriftungen enthält.

Zuerst müssen wir die Bibliotheken TensorFlow und NumPy installieren. Unten finden Sie den vollständigen Code für die handschriftliche Ziffernerkennung:

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#创建模型
x = tf.placeholder(tf.float32, [None, 784])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(x, W) + b)

#定义损失函数和优化器
y_actual = tf.placeholder(tf.float32, [None, 10])
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_actual, logits=y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#训练模型
sess = tf.Session()
sess.run(init)
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_actual: batch_ys})

#评估模型
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_actual,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_actual: mnist.test.labels}))

In diesem Beispiel haben wir zuerst den Datensatz MNIST vorbereitet und dann ein einfaches neuronales Netzwerkmodell mit 784 Eingaben und 10 Ausgaben erstellt. Als nächstes haben wir die Verlustfunktion und den Optimierer definiert und die Trainingsdaten zum Training in das Modell eingespeist. Abschließend führten wir eine Testauswertung der Testdaten durch und erreichten eine Genauigkeit von 92,3 %.

Neuronales Netzwerk Beispiel 2: Spam-Filter

Heutzutage nutzt fast jeder das Mailsystem, aber jeder steht vor dem Spam-Problem. Ein Spamfilter ist ein Programm, das prüft, ob eine E-Mail Spam ist. Sehen wir uns an, wie man mithilfe neuronaler Netze einen Spam-Filter erstellt.

Zuerst müssen wir einen Spam-Datensatz vorbereiten, der E-Mails enthält, die als Spam und Nicht-Spam markiert wurden. Bitte beachten Sie, dass es beim Erstellen eines Spamfilters zwei Kategorien von Nachrichten gibt: Nicht-Spam und Spam.

Das Folgende ist der vollständige Code des Spam-Filters:

import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

#读取数据集
data = pd.read_csv('spam.csv')
data = data.drop(['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'], axis=1)

#转换标签
data['v1'] = data['v1'].map({'ham': 0, 'spam': 1})

#划分数据集
X_train, X_test, y_train, y_test = train_test_split(data['v2'], data['v1'], test_size=0.33, random_state=42)

#创建神经网络模型
max_words = 1000
tokenize = tf.keras.preprocessing.text.Tokenizer(num_words=max_words, char_level=False)
tokenize.fit_on_texts(X_train)

x_train = tokenize.texts_to_matrix(X_train)
x_test = tokenize.texts_to_matrix(X_test)

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(512, input_shape=(max_words,), activation='relu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(256, activation='sigmoid'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

#训练模型
model.fit(x_train, y_train,
          batch_size=32,
          epochs=5,
          validation_data=(x_test, y_test))

#评估模型
y_predict = model.predict(x_test)
print("Accuracy:", accuracy_score(y_test, y_predict.round()))

In diesem Beispiel verwenden wir die train_test_split()-Methode von sklearn, um den Datensatz zu teilen, und verwenden dann das Textvorverarbeitungstool in der Keras-Bibliothek, um den Datensatz zu transformieren eine Matrix (One-Hot-Codierung). Als nächstes verwenden wir Sequential, um das Neuron zu deklarieren und seine Parameter festzulegen. Schließlich nutzten wir das trainierte Modell zur Vorhersage der Testdaten und werteten sie aus, um eine Genauigkeit von 98,02 % zu erreichen.

Fazit

Neuronale Netze in Python sind eine leistungsstarke Technik, die in einer Vielzahl von Anwendungen wie Bilderkennung, Spamfiltern usw. eingesetzt werden kann. Mit TensorFlow können wir problemlos neuronale Netzwerkmodelle erstellen, trainieren und testen und zufriedenstellende Ergebnisse erzielen. Da die Nachfrage der Menschen nach maschinellem Lernen wächst, wird die neuronale Netzwerktechnologie zu einem immer wichtigeren Werkzeug und wird in zukünftigen Anwendungsszenarien häufiger eingesetzt.

Das obige ist der detaillierte Inhalt vonBeispiele für neuronale Netzwerke in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!