Réseau de neurones pour la classification avec Tensorflow

Cet article a été publié dans le cadre du Blogathon sur la science des données

Dans cet article, je vais créer des modèles de réseaux de neurones avec TensorFlow pour résoudre un problème de classification. Explorons ensemble comment aborder un problème de classification dans Tensorflow. Mais tout d’abord, je voudrais m’assurer que nous sommes en mesure de répondre à ces questions :

'est-ce qu'un réseau neuronal ?

L'objectif principal d'un réseau de neurones est d'essayer de trouver la relation entre les caractéristiques d'un ensemble de données., et il consiste en un ensemble d'algorithmes qui imitent le travail du cerveau humain. Un « neurone » dans un réseau de neurones est une fonction mathématique qui collecte et classe des informations selon une architecture spécifique.

Qu'est-ce que le classement ?

Le problème de classification consiste à prédire si quelque chose appartient ou non à une classe. En d’autres termes, en le faisant, nous essayons de voir que quelque chose est une chose ou une autre.

Types de classement

• Supposons que vous vouliez prédire si une personne souffre de diabète ou non. Si vous êtes confronté à ce genre de situation, il y a deux possibilités, n'est-ce pas ? Que l'on appelle Classement binaire.
• Supposons que vous souhaitiez identifier si une photo représente un jouet, une personne ou un chat, n'est-ce pas ? c'est appelé Classification multi-classes car il y a plus de deux options.
• Supposons que vous souhaitiez décider quelles catégories doivent être attribuées à un article. Si c'est le cas, on l'appelle Classification multi-label, car un article peut avoir plusieurs catégories attribuées. Reprenons notre explication à travers cet article. Nous pouvons attribuer des catégories telles que « Deep Learning, TensorFlow, Classification », etc. à cet article

Nous pouvons désormais avancer car nous avons une compréhension commune du problème sur lequel nous allons travailler. Il est donc temps de coder. J'espère que vous les écrivez avec moi car la seule façon de s'améliorer et de faire moins d'erreurs est d'écrire plus de code.

Nous commençons par importer les bibliothèques que nous utiliserons :

importer numpy en tant que np importer des pandas en tant que pd importer matplotlib.pyplot en tant que plt importer tensorflow en tant que tf print(tf.__version__)

Créer un jeu de données

Il est temps de créer un ensemble de données sur lequel travailler :

à partir de sklearn.datasets importer des échantillons make_circles = 1000 X, y = make_circles (échantillons, bruit = 0.03, random_state = 42)

print(X >>[[ 0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [ 0.67036156 -0.76750154 0.28105665] [ 0.96382443 XNUMX]]

imprimer(y) >> [1 1 1 1 0 1 1 1 1 0]

D'accord, nous avons vu notre ensemble de données plus en détail, mais nous n'en savons toujours rien, n'est-ce pas ? C’est pourquoi une étape importante consiste à ne faire qu’un avec les données, et la visualisation est le meilleur moyen d’y parvenir.

cercle = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'label' : y}) circle.head()

Ici, une question se pose : de quel type d’étiquettes avons-nous affaire ?

circle.label.value_counts() >> 1 500 0 500 Nom : label, type : int64

On dirait que nous avons affaire à un problème de classification binaire, car nous avons 2 étiquettes (0 et 1).

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Comme je l'ai mentionné ci-dessus, le meilleur moyen d'en obtenir un avec les données est la visualisation. Maintenant, l'intrigue dit elle-même quel type de modèle nous devons construire. Nous allons construire un modèle capable de distinguer les points bleus des points rouges.

Avant de créer un modèle de réseau neuronal, nous devons vérifier les formes de nos fonctionnalités d'entrée et de sortie. ils doivent être pareils !

print(X.shape, y.shape) print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

Nous avons le même nombre de valeurs pour chaque entité, mais la forme de X est différente ? Pourquoi? Regardons ça.

X[0], y[0] >> (tableau([0.75424625, 0.23148074]), 1)

D'accord, nous avons 2 X fonctionnalités pour 1 an. Nous pouvons donc avancer sans problème.

Étapes de la modélisation d'un réseau neuronal pour la classification avec Tensorflow

Dans TensorFlow, il existe des étapes fixes pour créer un modèle :

• Créer un modèle – reconstituer les couches d’un réseau de neurones à l’aide de l’API fonctionnelle ou séquentielle
• Compilation d'un modèle – définir comment mesurer les performances d'un modèle et comment les améliorer (fonction de perte et optimiseur)
• Ajuster un model – laisser un modèle trouver des modèles dans les données

Nous utiliserons l'API séquentielle. Alors, commençons

tf.random.set_seed(42)

model_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 optimiseur = tf.keras.optimizers.SGD(), #SGD signifie métriques de descente de gradient stochastique = ['précision']) model_1.fit(X, y, époques = 5)

>> Époque 1/5 32/32 [==============================] - 1s 1ms/pas - perte : 2.8544 - précision : 0.4600 Epoch 2/5 32/32 [==============================] - 0s 2ms/pas - perte : 0.7131 - précision : 0.5430 Époque 3/5 32/32 [==============================] - 0s 2ms/pas - perte : 0.6973 - précision : 0.5090 Époque 4/5 32/32 [==============================] - 0s 2ms /pas - perte : 0.6950 - précision : 0.5010 Époque 5/5 32/32 [===============================] - 0s 1ms/pas - perte : 0.6942 - précision : 0.4830

La précision du modèle est d'environ 50 %, ce qui signifie essentiellement que le modèle ne fait que deviner, essayons de l'entraîner plus longtemps.

model_1.fit(X, y, epochs = 200, verbose = 0) #nous définissons verbose = 0 pour supprimer la procédure de formation) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/pas - perte : 0.6935 - précision : 0.5000 [0.6934829950332642, 0.5]

Même après 200 époques, il fonctionne toujours comme s'il le devinait. La prochaine étape consiste à ajouter plus de couches et à s'entraîner plus longtemps.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimiseur = tf.keras.optimizers.SGD(), metrics = ['précision']) model_2.fit(X, y, époques = 100, détaillé = 0)

 model_2.evaluate(X,y)

>> 32/32 [==============================] - 0s 1ms/pas - perte : 0.6933 - précision : 0.5000 [0.6933314800262451, 0.5]

Pourtant, il n’y a même pas un petit changement, il semble que quelque chose ne va pas.

Amélioration du modèle de réseau neuronal pour la classification avec Tensorflow

Il existe différentes manières d’améliorer un modèle à différentes étapes :

• Création d'un modèle – ajoutez plus de couches, augmentez le nombre d'unités cachées (neurones), modifiez les fonctions d'activation de chaque couche
• Compilation d'un modèle - essayez différentes fonctions d'optimisation, par exemple utilisez Adam() au lieu de SGD().
• Ajuster un modèle – nous pourrions augmenter le nombre d'époques

Essayons de ajouter plus de neurones et essayer Adam optimiseur

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # ajoute 100 neurones denses tf.keras.layers.Dense(10), # ajoute une autre couche avec 10 neurones tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimiseur=tf.keras.optimizers.Adam(), metrics=['accuracy']) model_3.fit(X, y, époques =100, verbeux=0)

model_3.evaluate(X,y) >> 32/32 [===============================] - 0s 1ms/pas - perte : 0.6980 - précision : 0.5080 [0.6980254650115967, 0.5080000162124634]

Ça ne s'améliore toujours pas ! Visualisons les données pour voir ce qui ne va pas.

Visualisez le modèle de réseau neuronal

Pour visualiser les prédictions de notre modèle nous allons créer une fonction plot_decision_boundary() qui :

• Prend en compte un modèle entraîné, des fonctionnalités et des étiquettes
• Créez une grille de maillage des différentes valeurs X.
• Fait des prédictions sur la grille maillée.
• Trace les prédictions avec une ligne.

Remarque:  Cette fonction a été adaptée à partir de deux ressources :

CS231n Fabriqué avec les bases du ML 

def plot_decision_boundary(model, X, y): # Définir les limites des axes du tracé et créer une grille de maillage x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # Créer des valeurs X (nous allons prédire sur toutes ces valeurs) x_in = np.c_[xx.ravel(), yy.ravel()] # Faire des prédictions en utilisant les personnes formées model y_pred = model.predict(x_in) # Vérifier la multi-classe

 if len(y_pred[0]) > 1: print("doing multiclass classification...") # Nous devons remodeler nos prédictions pour les préparer au traçage y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("faire une classification binaire...") y_pred = np.round(y_pred).reshape(xx.shape) # Tracer la limite de décision plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

C'est ici! Encore une fois, la visualisation nous montre ce qui ne va pas et que faire ? Notre modèle tente de tracer une ligne droite à travers les données, mais nos données ne sont pas séparables par une ligne droite. Il manque quelque chose à notre problème de classification ? Ce que c'est?

C'est de la non-linéarité ! Nous avons besoin de lignes non linéaires. Vous pourriez être confus maintenant, si vous pensez que vous n'avez pas vu ce genre de fonction auparavant, vous vous trompez, car c'est le cas. Voyons-les visuellement. La visualisation fonctionne toujours mieux !

Il existe certaines fonctions d'activation dans Neural Network que nous pouvons utiliser, comme ReLu, Sigmoïde. Créons un peu tenseur de jouet et vérifiez ces fonctions dessus.

Fonctions d'activation pour les réseaux de neurones

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], forme = (24,), dtype=float32)

Voyons à quoi ressemble notre tenseur jouet ?

plt.plot(A)

Cela ressemble à ça, une ligne droite ! 

Recréons maintenant les fonctions d'activation pour voir ce qu'elles font à notre tenseur ?

Sigmoïde :

def sigmoid(x) : return 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

Une ligne non droite !

ReLu :

def relu(x) : return tf.maximum(0,x) plt.plot(relu(A))

Encore une ligne non droite !

Maintenant que vous avez vu les fonctions d'activation non linéaires, et c'est ce qui fonctionnera pour nous, le modèle ne peut rien apprendre sur un ensemble de données non linéaires avec des fonctions d'activation linéaires ! Si vous avez appris cela, il est temps de diviser nos données en ensembles de formation et de test et de créer des modèles solides.

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2 ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, activation = 'relu'), #nous pouvons également corriger "tf.keras.activations.relu" tf.keras.layers.Dense(4 , activation = 'relu'), tf.keras.layers.Dense(1, activation = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, optimiseur = tf.keras.optimizers.Adam( lr = 0.01), métriques = ['précision']) model_4.fit(X_train, y_train, époques = 25, verbeux = 0)

Évaluer le modèle

perte, précision = model_4.evaluate(X_test, y_test) print(f' Perte du modèle sur l'ensemble de test : {loss}') print(f' Précision du modèle sur l'ensemble de test : {100*précision}')

>> 7/7 [==============================] - 0s 2ms/pas - perte : 0.1247 - précision : 1.0000 Perte de modèle sur l'ensemble de test : 0.1246885135769844 Précision du modèle sur l'ensemble de test : 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Train") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Test") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

Jetons un bref aperçu de ce dont nous parlons dans cet article. Ensemble, nous avons examiné comment aborder une tâche de classification dans le réseau neuronal avec TensorFlow. Nous avons créé 3 modèles de la première manière qui nous est venue à l'esprit, et avec l'aide de la visualisation, nous avons réalisé où nous nous trompions, nous avons exploré la linéarité, la non-linéarité et enfin, nous avons réussi à construire un modèle généralisé. Ce que j'essayais de montrer avec tous ces codes et les étapes que je suivais, c'est que rien n'est précis ou fixe à 100 %, tout continue de changer chaque jour. Pour deviner quel problème vous êtes susceptible de rencontrer dans quel type de données et pour voir quelles combinaisons conduisent à un meilleur résultat, il vous suffit d'écrire beaucoup plus de code et d'acquérir de l'expérience.

J'espère que l'article vous a été un peu utile et a apporté quelques contributions.

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur

Services Connexes

Source : https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/