Exemples de réseaux de neurones en Python

Python a toujours été largement utilisé et apprécié pour sa syntaxe simple et flexible, son écosystème et ses bibliothèques puissants, y compris dans des domaines tels que le calcul scientifique et l'apprentissage automatique. Les réseaux de neurones jouent un rôle essentiel dans le domaine de l'apprentissage automatique et peuvent être utilisés dans de nombreux domaines tels que la vision par ordinateur, le traitement du langage naturel et les systèmes de recommandation. Cet article présentera les réseaux de neurones en Python et donnera quelques exemples.

Qu'est-ce qu'un réseau de neurones ?

Le réseau de neurones est un modèle d'apprentissage profond qui a pour caractéristiques de simuler le système nerveux des animaux. Un réseau de neurones est composé de plusieurs neurones. Chaque neurone équivaut à une fonction. Son entrée est la sortie d'autres neurones, qui est traitée par une fonction d'activation pour générer une sortie. Les réseaux de neurones utilisent l'algorithme de rétropropagation pour ajuster en permanence les poids et les biais, permettant ainsi au modèle de mieux s'adapter aux données et d'effectuer des prédictions ou des classifications.

TensorFlow

TensorFlow est un framework d'apprentissage en profondeur populaire lancé par Google pour créer des réseaux de neurones et d'autres algorithmes d'apprentissage automatique. Développé à l'origine pour les chercheurs internes de Google, TensorFlow est rapidement devenu l'un des frameworks d'apprentissage profond les plus populaires après avoir été open source.

Dans TensorFlow, nous pouvons utiliser les étapes suivantes pour créer un réseau de neurones :

1. Préparer l'ensemble de données : L'ensemble de données doit être divisé en deux parties : l'ensemble d'entraînement et l'ensemble de test. L'ensemble d'entraînement est utilisé pour entraîner le modèle, tandis que l'ensemble de test est utilisé pour tester l'exactitude du modèle.
2. Créer un réseau de neurones : vous pouvez utiliser Python pour écrire et implémenter des réseaux de neurones. Des modèles de réseaux neuronaux peuvent être créés à l'aide de l'API TensorFlow.
3. Entraînez le modèle : entraînez le modèle de réseau neuronal pour prédire le résultat de nouvelles données. Cela peut être fait en utilisant l'algorithme de descente de gradient stochastique et en effectuant une rétropropagation, mettant continuellement à jour les poids et les biais du modèle.
4. Testez le modèle : testez le modèle à l'aide de l'ensemble de test pour déterminer sa précision. Différentes métriques peuvent être utilisées pour évaluer les performances du modèle, telles que la précision, le rappel et le score F1.

Maintenant, nous allons présenter deux exemples de réseaux de neurones implémentés à l'aide de TensorFlow.

Exemple de réseau neuronal 1 : reconnaissance de chiffres manuscrits

La reconnaissance de chiffres manuscrits est un problème important dans le domaine de la vision par ordinateur, et les réseaux de neurones ont obtenu de bons résultats sur ce problème. Dans TensorFlow, vous pouvez entraîner un réseau neuronal à l'aide de l'ensemble de données MNIST, qui contient 60 000 images en niveaux de gris 28 x 28 et les étiquettes correspondantes.

Tout d'abord, nous devons installer les bibliothèques TensorFlow et NumPy. Vous trouverez ci-dessous le code complet pour la reconnaissance des chiffres manuscrits :

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}))

Dans cet exemple, nous avons d'abord préparé l'ensemble de données MNIST, puis créé un modèle de réseau neuronal simple avec 784 entrées et 10 sorties. Ensuite, nous avons défini la fonction de perte et l'optimiseur et introduit les données de formation dans le modèle de formation. Enfin, nous avons effectué une évaluation des tests sur les données de test et obtenu une précision de 92,3 %.

Exemple de réseau neuronal 2 : filtre anti-spam

Presque tout le monde utilise le système de messagerie maintenant, mais tout le monde est confronté au problème du spam. Un filtre anti-spam est un programme qui vérifie si un e-mail est du spam. Voyons comment utiliser les réseaux de neurones pour créer un filtre anti-spam.

Tout d'abord, nous devons préparer un ensemble de données de spam, comprenant les e-mails marqués comme spam et non-spam. Veuillez noter que lors de la création d'un filtre anti-spam, il y aura deux catégories de messages : les non-spam et les spams.

Voici le code complet du filtre anti-spam :

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()))

Dans cet exemple, nous utilisons la méthode train_test_split() de sklearn pour diviser l'ensemble de données, puis utilisons l'outil de prétraitement de texte de la bibliothèque Keras pour transformer l'ensemble de données en une matrice (encodage one-hot). Ensuite, nous utilisons Sequential pour déclarer le neurone et définir ses paramètres. Enfin, nous avons utilisé le modèle entraîné pour prédire les données de test et les avons évaluées pour obtenir une précision de 98,02 %.

Conclusion

Les réseaux de neurones en Python sont une technique puissante qui peut être utilisée dans diverses applications telles que la reconnaissance d'images, les filtres anti-spam, etc. Grâce à TensorFlow, nous pouvons facilement créer, entraîner et tester des modèles de réseaux neuronaux et obtenir des résultats satisfaisants. À mesure que la demande d’apprentissage automatique augmente, la technologie des réseaux neuronaux deviendra un outil plus important et sera plus largement utilisée dans les futurs scénarios d’application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!