Comment construire votre premier réseau de neurones pour prédire les prix de l'immobilier avec Keras

Guide pas-à-pas complet pour débutants expliquant comment construire votre premier réseau de neurones en quelques lignes de code, comme un pro de Deep Learning!

Écrire votre premier réseau de neurones peut être fait avec seulement quelques lignes de code! Dans cet article, nous allons explorer comment utiliser un package appelé Keras pour construire notre premier réseau de neurones afin de prédire si les prix des logements sont supérieurs ou inférieurs à la valeur médiane. En particulier, nous allons parcourir l'intégralité du pipeline Deep Learning, à partir de:

  • Exploration et traitement des données
  • Construire et former notre réseau de neurones
  • Visualiser la perte et la précision
  • Ajout de régularisation à notre réseau de neurones

En seulement 20 à 30 minutes, vous aurez codé votre propre réseau de neurones, comme le ferait un praticien d'apprentissage en profondeur!

Conditions préalables:

Cet article suppose que vous avez installé le cahier Jupyter dans un environnement dans lequel les packages keras, tensorflow, pandas, scikit-learn et matplotlib sont installés. Si vous ne l'avez pas encore fait, suivez les instructions du didacticiel ci-dessous:

  • Premiers pas avec Python for Deep Learning et Data Science

Il s’agit d’un codage complémentaire à l’apprentissage en profondeur intuitif, partie 1. En tant que tel, nous supposons que vous avez une compréhension intuitive des réseaux de neurones et de leur fonctionnement, y compris certains détails de base, tels que ce qui est excessif et les stratégies pour y remédier. leur. Si vous avez besoin d'un rappel, veuillez lire ces introductions intuitives:

  • Apprentissage approfondi intuitif Partie 1a: Introduction aux réseaux de neurones
  • Apprentissage approfondi intuitif Partie 1b: Introduction aux réseaux de neurones

Ressources dont vous avez besoin:

L’ensemble de données que nous utiliserons aujourd’hui est adapté des données de compétition de Zillow’s Home Value Prediction Kaggle. Nous avons réduit le nombre d'entités en entrée et modifié la tâche en permettant de prédire si le prix du logement est supérieur ou inférieur à la valeur médiane. Veuillez visiter le lien ci-dessous pour télécharger l'ensemble de données modifié ci-dessous et le placer dans le même répertoire que votre ordinateur portable. L'icône de téléchargement devrait être en haut à droite.

Télécharger le jeu de données

Vous pouvez également télécharger un cahier Jupyter annoté contenant tout le code décrit dans ce message: Jupyter Notebook.

Notez que pour télécharger ce bloc-notes depuis Github, vous devez vous rendre sur la page d'accueil et télécharger ZIP pour télécharger tous les fichiers:

Et maintenant, commençons!

Exploration et traitement des données

Avant de coder un algorithme ML, la première chose à faire est de placer nos données dans un format que l’algorithme voudra. En particulier, nous devons:

  • Lisez le fichier CSV (valeurs séparées par des virgules) et convertissez-les en tableaux. Les tableaux sont un format de données que notre algorithme peut traiter.
  • Divisez notre ensemble de données entre les entités en entrée (que nous appelons x) et le libellé (que nous appelons y).
  • Mettez à l'échelle les données (nous appelons cette normalisation) afin que les entités en entrée aient des ordres de grandeur similaires.
  • Divisez notre ensemble de données dans l'ensemble de formation, l'ensemble de validation et l'ensemble de test. Si vous avez besoin d'un rappel sur les raisons pour lesquelles nous avons besoin de ces trois jeux de données, veuillez vous reporter à Intuitive Deep Learning, partie 1b.

Alors commençons! Dans le tutoriel Premiers pas avec Python for Deep Learning et Data Science, vous devriez avoir téléchargé le paquet pandas dans votre environnement. Nous devrons dire à notre bloc-notes que nous utiliserons ce paquet en l'important. Tapez le code suivant et appuyez sur Alt-Entrée sur votre clavier:

importer des pandas en tant que pd

Cela signifie simplement que si je veux parler de code dans le paquet «pandas», je le nommerai pd. Nous lisons ensuite dans le fichier CSV en exécutant cette ligne de code:

df = pd.read_csv ('housepricedata.csv')

Cette ligne de code signifie que nous lirons le fichier csv «housepricedata.csv» (qui devrait se trouver dans le même répertoire que votre cahier) et le stockerons dans la variable «df». Si nous voulons savoir ce qui est dans df, tapez simplement df dans la case grise et cliquez sur Alt-Entrée:

df

Votre cahier devrait ressembler à quelque chose comme ça:

Ici, vous pouvez explorer un peu les données. Nous avons nos fonctionnalités d'entrée dans les dix premières colonnes:

  • Superficie du terrain (en pieds carrés)
  • Qualité globale (échelle de 1 à 10)
  • État général (échelle de 1 à 10)
  • Surface totale du sous-sol (en pieds carrés)
  • Nombre de salles de bain complètes
  • Nombre de salles d'eau
  • Nombre de chambres hors sol
  • Nombre total de pièces hors sol
  • Nombre de cheminées
  • Zone de garage (en pieds carrés)

Dans notre dernière colonne, nous avons la fonctionnalité que nous aimerions prédire:

  • Le prix de l'immobilier est-il supérieur à la médiane ou non? (1 pour oui et 0 pour non)

Maintenant que nous avons vu à quoi ressemblent nos données, nous souhaitons les convertir en matrices pour que notre machine puisse les traiter:

dataset = df.values

Pour convertir notre dataframe en un tableau, nous stockons simplement les valeurs de df (en accédant à df.values) dans la variable ‘dataset’. Pour voir le contenu de cette variable "dataset", tapez simplement "dataset" dans une zone grise de votre cahier et exécutez la cellule (Alt-Entrée):

base de données

Comme vous pouvez le constater, tout cela est maintenant stocké dans un tableau:

Conversion de notre dataframe en tableau

Nous divisons maintenant notre ensemble de données en entités en entrée (X) et en entités que nous souhaitons prédire (Y). Pour faire cette scission, nous affectons simplement les 10 premières colonnes de notre tableau à une variable appelée X et la dernière colonne de notre tableau à une variable appelée Y. Le code pour effectuer la première affectation est le suivant:

X = ensemble de données [:, 0:10]

Cela peut paraître un peu bizarre, mais laissez-moi vous expliquer ce qui est entre crochets. Tout ce qui précède la virgule fait référence aux lignes du tableau et tout ce qui suit la virgule fait référence aux colonnes des tableaux.

Comme nous ne scindons pas les lignes, nous plaçons ":" avant la virgule. Cela signifie prendre toutes les lignes d'un jeu de données et le mettre dans X.

Nous voulons extraire les 10 premières colonnes, et donc le "0:10" après la virgule signifie prendre les colonnes 0 à 9 et les mettre dans X (nous n’incluons pas la colonne 10). Nos colonnes commencent à l’indice 0, les 10 premières colonnes sont donc vraiment les colonnes 0 à 9.

Nous assignons ensuite la dernière colonne de notre tableau à Y:

Y = ensemble de données [:, 10]

Ok, nous avons maintenant divisé notre jeu de données en entités en entrée (X) et en libellé de ce que nous voulons prédire (Y).

La prochaine étape de notre traitement consiste à nous assurer que l’échelle des entités en entrée est similaire. À l'heure actuelle, les caractéristiques telles que la superficie des lots sont de l'ordre de milliers, la qualité globale varie de 1 à 10, et le nombre de foyers a tendance à être de 0, 1 ou 2.

Cela rend difficile l'initialisation du réseau de neurones, ce qui pose certains problèmes pratiques. Une façon de redimensionner les données consiste à utiliser un paquet existant de scikit-learn (que nous avons installé dans la publication Getting Started).

Nous devons d'abord importer le code que nous voulons utiliser:

du pré-traitement d'importation sklearn

Cela signifie que je souhaite utiliser le code lors du ‘prétraitement’ dans le package sklearn. Ensuite, nous utilisons une fonction appelée le scaler min-max, qui redimensionne l'ensemble de données de sorte que toutes les entités en entrée soient comprises entre 0 et 1 inclus:

min_max_scaler = pré-traitement.MinMaxScaler ()
X_scale = min_max_scaler.fit_transform (X)

Notez que nous avons choisi 0 et 1 intentionnellement pour faciliter la formation de notre réseau de neurones. Nous ne ferons pas la théorie derrière cela. Maintenant, notre jeu de données mis à l’échelle est stocké dans le tableau ‘X_scale’. Si vous souhaitez voir à quoi ressemble X_scale, exécutez simplement la cellule:

X_scale

Votre carnet Jupyter devrait maintenant ressembler un peu à ceci:

Nous en sommes maintenant à la dernière étape du traitement des données, qui consiste à scinder notre ensemble de données en un ensemble d’apprentissage, un ensemble de validation et un ensemble d’essais.

Nous allons utiliser le code de scikit-learn appelé ‘train_test_split’ qui, comme son nom l’indique, divise notre ensemble de données en un ensemble d’apprentissage et un ensemble d’essais. Nous importons d'abord le code dont nous avons besoin:

from sklearn.model_selection import train_test_split

Ensuite, divisez votre jeu de données comme ceci:

X_train, X_val_and_test, Y_train, Y_val_and_test = train_test_split (X_scale, Y, test_size = 0.3)

Cela indique à scikit-learn que votre taille de val_and_test sera de 30% de l'ensemble de données global. Le code stockera les données fractionnées dans les quatre premières variables à gauche du signe égal, comme le suggèrent les noms de variables.

Malheureusement, cette fonction nous aide uniquement à diviser notre ensemble de données en deux. Puisque nous voulons un ensemble de validation et un ensemble de test distincts, nous pouvons utiliser la même fonction pour refaire le fractionnement sur val_and_test:

X_val, X_test, Y_val, Y_test = train_test_split (X_val_and_test, Y_val_and_test, test_size = 0.5)

Le code ci-dessus divise la taille de val_and_test en parts égales entre le jeu de validation et le jeu de tests.

En résumé, nous avons maintenant un total de six variables pour nos ensembles de données que nous allons utiliser:

  • X_train (10 entités en entrée, 70% de l'ensemble de données complet)
  • X_val (10 entités en entrée, 15% de l'ensemble de données complet)
  • X_test (10 entités en entrée, 15% de l'ensemble de données complet)
  • Y_train (1 label, 70% du jeu de données complet)
  • Y_val (1 étiquette, 15% de l'ensemble de données complet)
  • Y_test (1 label, 15% du jeu de données complet)

Si vous voulez voir comment se présentent les tableaux pour chacun d’entre eux (c.-à-d. Quelles dimensions ils sont), lancez simplement

print (X_train.shape, X_val.shape, X_test.shape, Y_train.shape, Y_val.shape, Y_test.shape)

Voici à quoi devrait ressembler votre carnet Jupyter:

Comme vous pouvez le constater, le jeu d’apprentissage contient 1022 points de données, tandis que le jeu de validation et de test compte 219 points de données. Les variables X ont 10 entités en entrée, tandis que les variables Y ne peuvent en prédire qu'une.

Et maintenant, nos données sont enfin prêtes! Phew!

Résumé: Lors du traitement des données, nous avons:

  • Lisez le fichier CSV (valeurs séparées par des virgules) et convertissez-les en tableaux.
  • Fractionner notre jeu de données entre les entités en entrée et l'étiquette.
  • Mettez à l'échelle les données pour que les entités en entrée aient des ordres de grandeur similaires.
  • Divisez notre ensemble de données dans l'ensemble de formation, l'ensemble de validation et l'ensemble de test.

Construire et former notre premier réseau de neurones

Dans Intuitive Deep Learning Partie 1a, nous avons expliqué que l’apprentissage automatique se compose de deux étapes. La première étape consiste à spécifier un modèle (une architecture) et la seconde consiste à rechercher les meilleurs nombres à partir des données pour renseigner ce modèle. Notre code à partir de maintenant suivra également ces deux étapes.

Première étape: configuration de l'architecture

La première chose à faire est de mettre en place l’architecture. Voyons d’abord quel type d’architecture de réseau neuronal nous voulons. Supposons que nous voulions ce réseau de neurones:

Architecture de réseau de neurones que nous utiliserons pour résoudre notre problème

En mots, nous voulons avoir ces couches:

  • Couche cachée 1: 32 neurones, activation ReLU
  • Couche cachée 2: 32 neurones, activation ReLU
  • Couche de sortie: 1 neurone, activation Sigmoïde

Maintenant, nous devons décrire cette architecture à Keras. Nous allons utiliser le modèle séquentiel, ce qui signifie que nous devons simplement décrire les couches ci-dessus dans l'ordre.

Commençons par importer le code nécessaire depuis Keras:

depuis keras.models import Sequential
de keras.layers import Dense

Ensuite, nous spécifions cela dans notre modèle séquentiel de Keras comme ceci:

modèle = séquentiel ([
    Dense (32, activation = 'relu', input_shape = (10,)),
    Dense (32, activation = 'relu'),
    Dense (1, activation = 'sigmoïde'),
])

Et juste comme ça, l'extrait de code ci-dessus a défini notre architecture! Le code ci-dessus peut être interprété comme ceci:

modèle = séquentiel ([...])

Cela signifie que nous allons stocker notre modèle dans la variable ‘modèle’ et que nous allons le décrire séquentiellement (couche par couche) entre les crochets.

Dense (32, activation = 'relu', input_shape = (10,)),

Nous avons notre première couche sous forme de couche dense avec 32 neurones, l’activation ReLU et la forme en entrée est 10 puisque nous avons 10 entités en entrée. Notez que «dense» fait référence à une couche entièrement connectée, ce que nous allons utiliser.

Dense (32, activation = 'relu'),

Notre deuxième couche est également une couche dense avec 32 neurones, l'activation de ReLU. Notez que nous n'avons pas à décrire la forme en entrée car Keras peut déduire de la sortie de notre premier calque.

Dense (1, activation = 'sigmoïde'),

Notre troisième couche est une couche dense avec 1 neurone, activation sigmoïde.

Et juste comme ça, nous avons écrit notre architecture de modèle (template) en code!

Deuxième étape: remplir les meilleurs chiffres

Maintenant que notre architecture est spécifiée, nous devons trouver les meilleurs nombres pour cette dernière. Avant de commencer notre formation, nous devons configurer le modèle en

  • Lui dire quel algorithme vous voulez utiliser pour faire l'optimisation
  • Lui dire quelle fonction de perte utiliser
  • Indiquez-lui les autres métriques que vous souhaitez suivre en dehors de la fonction de perte

La configuration du modèle avec ces paramètres nécessite l’appel de la fonction model.compile, comme suit:

model.compile (optimizer = 'sgd',
              perte = 'binary_crossentropy',
              métriques = ['précision'])

Nous plaçons les paramètres suivants entre crochets après model.compile:

optimiseur = 'sgd'

«Sgd» fait référence à la descente de gradient stochastique (ici, à la descente de gradient en mini-batch), ce que nous avons vu dans Intuitive Deep Learning Partie 1b.

perte = 'binary_crossentropy'

La fonction de perte pour les sorties prenant les valeurs 1 ou 0 est appelée entropie croisée binaire.

métriques = ['précision']

Enfin, nous voulons suivre la précision au-dessus de la fonction de perte. Maintenant que cette cellule est utilisée, nous sommes prêts à nous entraîner!

La formation sur les données est assez simple et nous oblige à écrire une ligne de code:

hist = model.fit (X_train, Y_train,
          batch_size = 32, epochs = 100,
          validation_data = (X_val, Y_val))

La fonction s’appelle «fit» car nous ajustons les paramètres aux données. Nous devons spécifier les données sur lesquelles nous nous entraînons, à savoir X_train et Y_train. Ensuite, nous spécifions la taille de notre mini-lot et combien de temps nous voulons le former (époques). Enfin, nous spécifions en quoi consistent nos données de validation afin que le modèle nous dise comment nous nous en tirons pour les données de validation à chaque point. Cette fonction produira un historique que nous sauvegardons sous la variable hist. Nous utiliserons cette variable un peu plus tard lorsque nous arriverons à la visualisation.

Maintenant, lancez la cellule et regardez-la s'entraîner! Votre carnet Jupyter devrait ressembler à ceci:

Vous pouvez maintenant voir que le modèle est en formation! En regardant les chiffres, vous devriez pouvoir voir la perte diminuer et la précision augmenter avec le temps. À ce stade, vous pouvez expérimenter les hyper-paramètres et l'architecture de réseau neuronal. Exécutez à nouveau les cellules pour voir comment votre entraînement a changé lorsque vous avez peaufiné vos hyperparamètres.

Une fois que vous êtes satisfait de votre modèle final, nous pouvons l’évaluer sur le jeu de tests. Pour trouver la précision sur notre ensemble de tests, exécutez cet extrait de code:

model.evaluate (X_test, Y_test) [1]

La raison pour laquelle nous avons l'index 1 après la fonction model.evaluate est que la fonction renvoie la perte en tant que premier élément et la précision en tant que second élément. Pour ne générer que la précision, accédez simplement au deuxième élément (qui est indexé par 1, car le premier élément commence son indexation à partir de 0).

En raison de la nature aléatoire de la manière dont nous avons divisé le jeu de données et de l’initialisation des poids, les nombres et le graphique seront légèrement différents chaque fois que nous aurons exécuté notre cahier. Néanmoins, vous devriez obtenir une précision de test comprise entre 80% et 95% si vous avez suivi l’architecture que j’ai spécifiée ci-dessus!

Evaluer sur le test

Et voilà, vous avez codé votre tout premier réseau de neurones et vous l’avez formé! Toutes nos félicitations!

Résumé: La programmation de notre premier réseau de neurones n'a nécessité que quelques lignes de code:

  • Nous spécifions l'architecture avec le modèle séquentiel Keras.
  • Nous spécifions certains de nos paramètres (optimiseur, fonction de perte, métriques à suivre) avec model.compile
  • Nous formons notre modèle (trouver les meilleurs paramètres pour notre architecture) avec les données d'apprentissage avec model.fit
  • Nous évaluons notre modèle sur l'ensemble de tests avec model.evaluate

Visualiser la perte et la précision

Dans Intuitive Deep Learning Partie 1b, nous avons parlé de surapprentissage et de techniques de régularisation. Comment savons-nous si notre modèle est actuellement sur-équipé?

Ce que nous pourrions vouloir faire, c’est tracer la perte d’entraînement et la perte de valeur sur le nombre d’époques écoulées. Pour afficher de beaux graphiques, nous allons utiliser le paquetage matplotlib. Comme d'habitude, nous devons importer le code que nous souhaitons utiliser:

importer matplotlib.pyplot en tant que plt

Ensuite, nous voulons visualiser la perte d’entraînement et la perte de validation. Pour ce faire, exécutez cet extrait de code:

plt.plot (hist.history ['loss'])
plt.plot (hist.history ['val_loss'])
plt.title ('Model loss')
plt.ylabel ('Loss')
plt.xlabel ('Epoch')
plt.legend (['Train', 'Val'], loc = 'en haut à droite')
plt.show ()

Nous allons expliquer chaque ligne de l'extrait de code ci-dessus. Les deux premières lignes indiquent que nous voulons tracer la perte et le val_loss. La troisième ligne spécifie le titre de ce graphique, "Model Loss". Les quatrième et cinquième lignes nous indiquent ce que les axes y et x doivent être étiquetés, respectivement. La sixième ligne comprend une légende pour notre graphique et l'emplacement de la légende sera situé dans le coin supérieur droit. Et la septième ligne indique au bloc-notes Jupyter d'afficher le graphique.

Votre carnet Jupyter devrait ressembler à ceci:

Un graphique de la perte de modèle que vous devriez voir dans votre cahier Jupyter

Nous pouvons faire de même pour tracer la précision de notre entraînement et la précision de la validation avec le code ci-dessous:

plt.plot (hist.history ['acc'])
plt.plot (hist.history ['val_acc'])
plt.title ('Précision du modèle')
plt.ylabel ('Précision')
plt.xlabel ('Epoch')
plt.legend (['Train', 'Val'], loc = 'en bas à droite')
plt.show ()

Vous devriez obtenir un graphique qui ressemble un peu à ceci:

Tracé de la précision du modèle pour l'ensemble de formation et de validation

Étant donné que les améliorations apportées à notre modèle d’ensemble d’apprentissage semblent concorder avec les améliorations apportées à l’ensemble de validation, il ne semble pas que la suréquipement soit un énorme problème dans notre modèle.

Résumé: nous utilisons matplotlib pour visualiser la formation et la perte / précision de validation dans le temps afin de déterminer s’il existe une sur-adaptation dans notre modèle.

Ajout de régularisation à notre réseau de neurones

Dans l’intérêt d’introduire une régularisation dans notre réseau de neurones, formulons-le avec un réseau de neurones qui entraînera une sur-adaptation de notre système d’entraînement. Nous appellerons ce modèle 2.

model_2 = séquentiel ([
    Dense (1000, activation = 'relu', input_shape = (10,)),
    Dense (1000, activation = 'relu'),
    Dense (1000, activation = 'relu'),
    Dense (1000, activation = 'relu'),
    Dense (1, activation = 'sigmoïde'),
])
model_2.compile (optimizer = 'adam',
              perte = 'binary_crossentropy',
              métriques = ['précision'])
hist_2 = model_2.fit (X_train, Y_train,
          batch_size = 32, epochs = 100,
          validation_data = (X_val, Y_val))

Ici, nous avons créé un modèle beaucoup plus grand et nous utilisons l’optimiseur Adam. Adam est l’un des optimiseurs les plus couramment utilisés, ce qui ajoute quelques améliorations à la descente de gradient stochastique, de sorte qu’il atteint plus rapidement la fonction de perte inférieure. Si nous exécutons ce code et traçons les graphiques de perte pour hist_2 en utilisant le code ci-dessous (notez que le code est le même, sauf que nous utilisons ‘hist_2’ au lieu de ‘hist’):

plt.plot (hist_2.history ['loss']])
plt.plot (hist_2.history ['val_loss'])
plt.title ('Model loss')
plt.ylabel ('Loss')
plt.xlabel ('Epoch')
plt.legend (['Train', 'Val'], loc = 'en haut à droite')
plt.show ()

Nous obtenons un complot comme celui-ci:

Courbes de perte pour le modèle en surplomb

Ceci est un signe clair de sur-ajustement. La perte d'entraînement est en diminution, mais la perte de validation est bien supérieure à la perte d'entraînement et augmente (au-delà du point d'inflexion de l'époque 20). Si nous traçons la précision en utilisant le code ci-dessous:

plt.plot (hist_2.history ['acc'])
plt.plot (hist_2.history ['val_acc'])
plt.title ('Précision du modèle')
plt.ylabel ('Précision')
plt.xlabel ('Epoch')
plt.legend (['Train', 'Val'], loc = 'en bas à droite')
plt.show ()

Nous pouvons voir une divergence plus nette entre la précision du train et celle de la validation:

Précision de la formation et de la validation pour notre modèle de surajustement

Essayons maintenant quelques-unes de nos stratégies visant à réduire les sur-ajustements (mis à part le fait de remettre notre architecture sur notre premier modèle). Rappelez-vous de Intuitive Deep Learning Partie 1b que nous avons introduit trois stratégies pour réduire les sur-ajustements.

Parmi les trois, nous allons incorporer la régularisation et l'abandon L2 ici. La raison pour laquelle nous n’ajoutons pas d’arrêt précoce ici est qu’après avoir utilisé les deux premières stratégies, la perte de validation n’a pas la forme en U que nous voyons ci-dessus et un arrêt précoce ne sera donc pas aussi efficace.

Tout d’abord, importons le code nécessaire à la régularisation et à l’abandon de la langue seconde:

de keras.layers importation Dropout
de régularisations d'importation Keras

Nous spécifions ensuite notre troisième modèle comme ceci:

model_3 = séquentiel ([
    Dense (1000, activation = 'relu', kernel_regularizer = regularizers.l2 (0.01), input_shape = (10,)),
    Abandon scolaire (0,3),
    Dense (1000, activation = 'relu', kernel_regularizer = regularizers.l2 (0.01)),
    Abandon scolaire (0,3),
    Dense (1000, activation = 'relu', kernel_regularizer = regularizers.l2 (0.01)),
    Abandon scolaire (0,3),
    Dense (1000, activation = 'relu', kernel_regularizer = regularizers.l2 (0.01)),
    Abandon scolaire (0,3),
    Dense (1, activation = 'sigmoid', kernel_regularizer = regularizers.l2 (0.01)),
])

Pouvez-vous repérer les différences entre le modèle 3 et le modèle 2? Il y a deux différences principales:

Différence 1: pour ajouter la régularisation N2, notez que nous avons ajouté un peu de code supplémentaire dans chacune de nos couches denses, comme ceci:

kernel_regularizer = regularizers.l2 (0.01)

Cela indique à Keras d'inclure les valeurs au carré de ces paramètres dans notre fonction de perte globale et de les pondérer de 0,01 dans la fonction de perte.

Différence 2: pour ajouter la suppression, nous avons ajouté un nouveau calque comme celui-ci:

Abandon scolaire (0,3),

Cela signifie que les neurones de la couche précédente ont une probabilité de 0,3 en décrochage pendant l’entraînement. Compilons-le et exécutons-le avec les mêmes paramètres que notre modèle 2 (le surapprentissage):

model_3.compile (optimizer = 'adam',
              perte = 'binary_crossentropy',
              métriques = ['précision'])
hist_3 = model_3.fit (X_train, Y_train,
          batch_size = 32, epochs = 100,
          validation_data = (X_val, Y_val))

Et maintenant, décrivons les graphiques de perte et de précision. Vous remarquerez que la perte est beaucoup plus importante au début, et ce, parce que nous avons modifié notre fonction de perte. Pour tracer de manière à ce que la fenêtre soit agrandie entre 0 et 1,2, nous ajoutons une ligne de code supplémentaire (plt.ylim) lors du traçage:

plt.plot (hist_3.history ['loss']])
plt.plot (hist_3.history ['val_loss'])
plt.title ('Model loss')
plt.ylabel ('Loss')
plt.xlabel ('Epoch')
plt.legend (['Train', 'Val'], loc = 'en haut à droite')
plt.ylim (haut = 1.2, bas = 0)
plt.show ()

Nous aurons un graphique de perte qui ressemble à ceci:

Vous pouvez voir que la perte de validation correspond beaucoup plus étroitement à notre perte d’entraînement. Voyons l’exactitude avec un extrait de code similaire:

plt.plot (hist_3.history ['acc'])
plt.plot (hist_3.history ['val_acc'])
plt.title ('Précision du modèle')
plt.ylabel ('Précision')
plt.xlabel ('Epoch')
plt.legend (['Train', 'Val'], loc = 'en bas à droite')
plt.show ()

Et nous aurons un complot comme celui-ci:

Par rapport à notre modèle du modèle 2, nous avons considérablement réduit le surajustement! Et c’est ainsi que nous appliquons nos techniques de régularisation afin de réduire les surajustements à l’entraînement.

Résumé: Pour faire face à la suralimentation, nous pouvons coder les stratégies suivantes dans notre modèle, chacune avec environ une ligne de code:

  • Régularisation L2
  • Abandonner

Si nous visualisons la perte et la précision de l'entraînement / validation, nous pouvons voir que ces ajouts ont aidé à traiter le surajustement!

Résumé consolidé:

Dans cet article, nous avons écrit du code Python pour:

  • Explorer et traiter les données
  • Construire et former notre réseau de neurones
  • Visualiser la perte et la précision
  • Ajouter la régularisation à notre réseau de neurones

Nous avons traversé beaucoup de choses, mais nous n’avons pas écrit trop de lignes de code! Construire et former notre réseau de neurones n'a pris que 4 à 5 lignes de code environ, et expérimenter avec différentes architectures de modèles consiste simplement à permuter dans différentes couches ou à modifier différents hyperparamètres. Keras a en effet beaucoup facilité la construction de nos réseaux de neurones et nous continuerons à l’utiliser pour des applications plus avancées de la vision par ordinateur et du traitement du langage naturel.

Prochaine étape: dans notre prochaine partie de codage, nous étudierons comment coder nos propres réseaux de neurones convolutionnels (CNN) afin de faire de la reconnaissance d’image!

Assurez-vous d’abord d’avoir une compréhension intuitive des CNN ici: Apprentissage approfondi intuitif, partie 2: Les CNN pour la vision par ordinateur

A propos de l'auteur:

Bonjour, je suis Joseph! Je suis récemment diplômé de l'Université Stanford, où j'ai travaillé avec Andrew Ng au sein du Stanford Machine Learning Group. Je souhaite rendre les concepts de Deep Learning aussi intuitifs et compréhensibles que possible par tous, ce qui a motivé ma publication: Intuitive Deep Learning.