L'intelligence artificielle (IA) a gagné en popularité ces dernières années.
Si vous êtes un ingénieur logiciel, un informaticien ou un passionné de science des données en général, vous êtes probablement intrigué par les applications étonnantes de traitement d'image, de reconnaissance de formes et de détection d'objets fournies par ce domaine.
Le sous-domaine le plus important de l'IA dont vous avez probablement entendu parler est le Deep Learning. Ce domaine se concentre sur des algorithmes puissants (instructions de programme informatique) modélisés d'après la fonctionnalité du cerveau humain connue sous le nom de Les réseaux de neurones.
Dans cet article, nous allons passer en revue le concept de réseaux de neurones et comment construire, compiler, ajuster et évaluer ces modèles en utilisant Python.
Les réseaux de neurones
Les réseaux de neurones, ou NN, sont une série d'algorithmes modélisés d'après l'activité biologique du cerveau humain. Les réseaux de neurones sont constitués de nœuds, également appelés neurones.
Une collection de nœuds verticaux est connue sous le nom de couches. Le modèle se compose d'une entrée, d'une sortie et d'un certain nombre de couches cachées. Chaque couche est constituée de nœuds, également appelés neurones, où se déroulent les calculs.
Dans le diagramme suivant, les cercles représentent les nœuds et la collection verticale de nœuds représente les couches. Il y a trois couches dans ce modèle.
Les nœuds d'une couche sont connectés à la couche suivante via des lignes de transmission, comme indiqué ci-dessous.
Notre jeu de données se compose de données étiquetées. Cela signifie qu'une certaine valeur de nom a été attribuée à chaque entité de données.
Ainsi, pour un ensemble de données de classification d'animaux, nous aurons des images de chats et de chiens comme données, avec "chat" et "chien" comme étiquettes.
Il est important de noter que les étiquettes doivent être converties en valeurs numériques pour que notre modèle leur donne un sens, de sorte que nos étiquettes d'animaux deviennent '0' pour chat et '1' pour chien. Les données et les étiquettes sont transmises à travers le modèle.
Formations
Les données sont introduites dans le modèle une entité à la fois. Ces données sont décomposées en morceaux et transmises à chaque nœud du modèle. Les nœuds effectuent des opérations mathématiques sur ces morceaux.
Vous n'avez pas besoin de connaître les fonctions mathématiques ou les calculs pour ce didacticiel, mais il est important d'avoir une idée générale du fonctionnement de ces modèles. Après une série de calculs dans une couche, les données sont transmises à la couche suivante et ainsi de suite.
Une fois terminé, notre modèle prédit l'étiquette de données au niveau de la couche de sortie (par exemple, dans un problème de classification d'animaux, nous obtenons une prédiction « 0 » pour un chat).
Le modèle procède ensuite à la comparaison de cette valeur prédite avec celle de la valeur réelle de l'étiquette.
Si les valeurs correspondent, notre modèle prendra l'entrée suivante, mais si les valeurs diffèrent, le modèle calculera la différence entre les deux valeurs, appelée perte, et ajustera les calculs des nœuds pour produire des étiquettes correspondantes la prochaine fois.
Cadres d'apprentissage en profondeur
Pour construire des réseaux de neurones dans le code, nous devons importer Cadres d'apprentissage en profondeur connus sous le nom de bibliothèques utilisant notre environnement de développement intégré (IDE).
Ces frameworks sont une collection de fonctions pré-écrites qui nous aideront dans ce tutoriel. Nous utiliserons le framework Keras pour construire notre modèle.
Keras est une bibliothèque Python qui utilise un backend d'apprentissage en profondeur et d'intelligence artificielle appelé Tensorflow pour créer facilement des NN sous la forme de modèles séquentiels simples.
Keras est également livré avec ses propres modèles préexistants qui pourraient également être utilisés. Pour ce didacticiel, nous allons créer notre propre modèle à l'aide de Keras.
Vous pouvez en savoir plus sur ce cadre d'apprentissage en profondeur à partir du Site Web de Kéras.
Construire un réseau de neurones (tutoriel)
Passons à la construction d'un réseau de neurones à l'aide de Python.
Énoncé du problème
Les réseaux de neurones sont un type de solution aux problèmes basés sur l'IA. Pour ce didacticiel, nous allons passer en revue les données sur le diabète des Indiens Pima, qui sont disponibles ici.
UCI Machine Learning a compilé cet ensemble de données et contient un dossier médical de patients indiens. Notre modèle doit prédire si le patient a un début de diabète dans les 5 ans ou non.
Chargement de l'ensemble de données
Notre ensemble de données est un fichier CSV unique appelé "diabetes.csv" qui peut être facilement manipulé à l'aide de Microsoft Excel.
Avant de créer notre modèle, nous devons importer notre jeu de données. En utilisant le code suivant, vous pouvez le faire :
importer des pandas en tant que pd
données = pd.read_csv('diabète.csv')
x = data.drop("Résultat")
y = données["Résultat"]
Ici, nous utilisons le Pandas bibliothèque pour pouvoir manipuler les données de notre fichier CSV, read_csv() est une fonction intégrée de Pandas qui nous permet de stocker les valeurs de notre fichier dans une variable appelée 'data'.
La variable x contient notre ensemble de données sans les données de résultat (étiquettes). Nous y parvenons avec la fonction data.drop() qui supprime les étiquettes pour x, tandis que y ne contient que les données de résultat (étiquette).
Construire un modèle séquentiel
Étape 1 : Importation de bibliothèques
Tout d'abord, nous devons importer TensorFlow et Keras, ainsi que certains paramètres requis pour notre modèle. Le code suivant nous permet de faire cela :
importer tensorflow en tant que tf
à partir de keras d'importation tensorflow
depuis tensorflow.keras.models import séquentiel
depuis tensorflow.keras.layers import Activation, Dense
depuis tensorflow.keras.optimizers importer Adam
depuis tensorflow.keras.metrics importer categorical_crossentropy
Pour notre modèle, nous importons des couches denses. Ce sont des couches entièrement connectées ; c'est-à-dire que chaque nœud d'une couche est entièrement connecté à un autre nœud de la couche suivante.
Nous importons également un activation fonction nécessaire pour mettre à l'échelle les données envoyées aux nœuds. Optimiseurs ont également été importés pour minimiser les pertes.
Adam est un optimiseur renommé qui rend nos calculs de nœuds de mise à jour de modèle plus efficaces, ainsi que categorical_crossentropy qui est le type de fonction de perte (calcule la différence entre les valeurs d'étiquette réelles et prévues) que nous utiliserons.
Étape 2 : Concevoir notre modèle
Le modèle que je crée a une entrée (avec 16 unités), une couche cachée (avec 32 unités) et une sortie (avec 2 unités). Ces chiffres ne sont pas fixes et dépendront entièrement du problème posé.
Définir le bon nombre d'unités et de couches est un processus qui peut être amélioré au fil du temps par la pratique. L'activation correspond au type de mise à l'échelle que nous allons effectuer sur nos données avant de les faire passer par un nœud.
Relu et Softmax sont des fonctions d'activation renommées pour cette tâche.
modèle = Séquentiel([
Dense(unités = 16, input_shape = (1,), activation = 'relu'),
Dense(unités = 32, activation = 'relu'),
Dense(unités = 2, activation = 'softmax')
])
Voici à quoi devrait ressembler le résumé du modèle :
Entraîner le modèle
Notre modèle sera formé en deux étapes, la première étant la compilation du modèle (assemblage du modèle) et la suivante étant l'ajustement du modèle sur un ensemble de données donné.
Cela peut être fait en utilisant la fonction model.compile() suivie de la fonction model.fit().
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['accuracy'])
model.fit(x, y, époques = 30, batch_size = 10)
Spécifier la métrique "précision" nous permet d'observer la précision de notre modèle pendant la formation.
Étant donné que nos étiquettes sont sous la forme de 1 et de 0, nous utiliserons une fonction de perte binaire pour calculer la différence entre les étiquettes réelles et prédites.
L'ensemble de données est également divisé en lots de 10 (batch_size) et sera passé 30 fois dans le modèle (epochs). Pour un ensemble de données donné, x seraient les données et y seraient les étiquettes correspondant aux données.
Modèle de test à l'aide de prédictions
Pour évaluer notre modèle, nous faisons des prédictions sur les données de test en utilisant la fonction predict().
prédictions = model.predict(x)
Et c'est tout!
Vous devriez maintenant avoir une bonne compréhension de la L'apprentissage en profondeur application, les réseaux de neurones, comment ils fonctionnent en général et comment construire, former et tester un modèle en code Python.
J'espère que ce didacticiel vous donnera le coup de pouce pour créer et déployer vos propres modèles d'apprentissage en profondeur.
Faites-nous savoir dans les commentaires si l'article vous a été utile.
Soyez sympa! Laissez un commentaire