Deep Learning avec Python: Guide du débutant sur le Deep Learning

Cet article vous fournira une connaissance complète et détaillée du Deep Learning avec Python et de son utilité dans la vie quotidienne.

est l'un des sujets les plus chauds de 2018-19 et pour une bonne raison. Il y a eu tellement de progrès dans l'industrie où le moment est venu où les machines ou les programmes informatiques remplacent réellement les humains. Cette Apprentissage profond avec Python Cet article vous aidera à comprendre ce qu'est exactement le Deep Learning et comment cette transition a été rendue possible. Je couvrirai les sujets suivants dans cet article:



La science des données et ses composants

Eh bien, la science des données est quelque chose qui existe depuis des lustres. Science des données est l'extraction de connaissances à partir de données en utilisant différentes techniques et algorithmes.



Chronologie de l

est une technique qui permet aux machines d'imiter le comportement humain. L'idée derrière l'IA est assez simple mais fascinante, qui consiste à créer des machines intelligentes capables de prendre des décisions par elles-mêmes. Pendant des années, on a pensé que les ordinateurs ne seraient jamais à la hauteur de la puissance du cerveau humain.



Eh bien, à l'époque, nous n'avions pas assez de données et de puissance de calcul, mais maintenant avec Big Data avec l'arrivée des GPU et avec l'avènement des GPU, l'Intelligence Artificielle est possible.

est un sous-ensemble de la technique d'IA qui utilise des méthodes statistiques pour permettre aux machines de s'améliorer avec l'expérience.



L'apprentissage en profondeur est un sous-ensemble de ML qui rend possible le calcul d'un réseau neuronal multicouche. Il utilise des réseaux de neurones pour simuler une prise de décision de type humain.

Le besoin de Deep Learning

Un pas vers l'intelligence artificielle est l'apprentissage automatique. L'apprentissage automatique est un sous-ensemble de l'IA et est basé sur l'idée que les machines devraient avoir accès aux données, et devraient être laissées pour apprendre et explorer par elles-mêmes. Il traite de l'extraction de modèles à partir de grands ensembles de données. La gestion de grands ensembles de données n'a pas posé de problème.

  • Algorithmes d'apprentissage automatique ne peut pas gérer les données haute dimension - où nous avons un grand nombre d'entrées et de sorties: environ des milliers de dimensions. La manipulation et le traitement de ce type de données deviennent très complexes et les ressources sont épuisantes. Ceci est appelé Malédiction de la dimensionnalité.

  • Un autre défi à relever était de spécifier le caractéristiques à extraire . Cela joue un rôle important dans la prédiction du résultat ainsi que dans l'obtention d'une meilleure précision. Par conséquent, sans extraction de caractéristiques, le défi pour le programmeur augmente car l'efficacité de l'algorithme dépend beaucoup de la perspicacité du programmeur.

Maintenant, c'est là que Deep Learning est venu à la rescousse. L'apprentissage profond est capable de gérer les données de grande dimension et est également efficace dans se concentrer sur les bonnes fonctionnalités seul.

Qu'est-ce que le Deep Learning?

Le Deep Learning est un sous-ensemble du Machine Learning dans lequel des algorithmes similaires de Machine Learning sont utilisés pour former afin d'obtenir une meilleure précision dans les cas où le premier ne fonctionnait pas à la hauteur de la marque. Fondamentalement, L'apprentissage profond imite le fonctionnement de notre cerveau c'est-à-dire qu'il apprend de l'expérience.

Comme tu le sais, notre cerveau est composé de milliards de neurones cela nous permet de faire des choses incroyables. Même le cerveau d'un petit enfant est capable de résoudre des problèmes complexes qui sont très difficiles à résoudre même en utilisant des super-ordinateurs. Alors, comment pouvons-nous obtenir la même fonctionnalité dans un programme? Maintenant, c'est là que nous comprenons Neurone artificiel (Perceptron) et Réseau neuronal artificiel.

Perceptron et réseaux de neurones artificiels

Le Deep Learning étudie l'unité de base d'un cerveau appelée cellule cérébrale ou neurone. Maintenant, comprenons la fonctionnalité des neurones biologiques et comment nous imitons cette fonctionnalité dans la perception ou un neurone artificiel.

  • Dendrite: Reçoit les signaux d'autres neurones
  • Corps cellulaire: Somme toutes les entrées
  • Axon: Il est utilisé pour transmettre des signaux aux autres cellules

Un neurone artificiel ou un Perceptron est un modèle linéaire utilisé pour la classification binaire. Il modélise un neurone qui a un ensemble d'entrées, dont chacune reçoit un poids spécifique. Le neurone calcule une fonction sur ces pondéré entrées et donne la sortie.

comment compiler du code java

Il reçoit n entrées (correspondant à chaque fonction). Il additionne ensuite ces entrées, applique une transformation et produit une sortie. Il a deux fonctions:

  • Addition
  • Transformation (activation)

Le poids montre l'efficacité d'un intrant particulier. Plus le poids de l'entrée, plus cela aura un impact sur le réseau de neurones . D'autre part, Biais est un paramètre supplémentaire dans le Perceptron qui est utilisé pour ajuster la sortie avec la somme pondérée des entrées du neurone, ce qui aide le modèle de manière à ce qu'il s'adapte le mieux aux données données.

Fonctions d'activation traduit les entrées en sorties. Il utilise un seuil pour produire une sortie. De nombreuses fonctions sont utilisées comme fonctions d'activation, telles que:

  • Linéaire ou identité
  • Unité ou étape binaire
  • Sigmoïde ou logistique
  • Tanh
  • ReLU
  • Softmax

Bien. si vous pensez que Perceptron résout le problème, vous vous trompez. Il y avait deux problèmes majeurs:

  • Perceptrons monocouche impossible de classer des points de données séparables de manière non linéaire .
  • Des problèmes complexes, qui impliquent beaucoup de paramètres ne peut pas être résolu par les Perceptrons à une seule couche.

Prenons l'exemple ici et la complexité des paramètres impliqués pour prendre une décision par l'équipe marketing.

Un neurone ne peut pas recevoir autant d'entrées et c'est pourquoi plus d'un neurone serait utilisé pour résoudre ce problème. Le réseau neuronal n'est en réalité qu'un composition de Perceptrons, connectés de différentes manières et fonctionnant sur différentes fonctions d'activation.

  • Noeuds d'entrée fournissent des informations du monde extérieur au réseau et sont désignées ensemble sous le nom de «couche d'entrée».
  • Nœuds masqués effectuer des calculs et transférer des informations des nœuds d'entrée vers les nœuds de sortie. Une collection de nœuds cachés forme une «couche cachée».
  • Noeuds de sortie sont collectivement appelées «couche de sortie» et sont responsables des calculs et du transfert des informations du réseau vers le monde extérieur.

Maintenant que vous avez une idée du comportement d'un perceptron, des différents paramètres impliqués et des différentes couches d'un réseau neuronal, continuons ce blog Deep Learning avec Python et voyons quelques applications intéressantes de Deep Learning.

Applications du Deep Learning

Il existe diverses applications du Deep Learning dans l'industrie, voici quelques-unes des applications importantes qui sont présentes dans nos tâches quotidiennes.

  • Reconnaissance de la parole

  • Traduction automatique

  • Reconnaissance faciale et marquage automatique

  • Assistants personnels virtuels

  • Voiture autonome

  • Chatbots

Pourquoi Python pour le Deep Learning?

  • est l'un de ces outils qui a un attribut unique, d'être un langage de programmation à usage général comme étant facile à utiliser en matière de calcul analytique et quantitatif.
  • C'est très facile à comprendre
  • Python est Typé dynamiquement
  • Énorme
  • Une vaste gamme de bibliothèques à des fins différentes comme Numpy, Seaborn, Matplotlib, Pandas et Scikit-learn

Maintenant assez de théorie, voyons comment nous pouvons démarrer le Deep Learning avec Python avec un exemple petit mais passionnant.

Apprentissage profond avec Python: exemple de Perceptron

Maintenant, je suis sûr que vous devez être familiarisé avec le fonctionnement du ' OU' porte. La sortie est un si l'une des entrées est également un.

marionnettiste et comparaison de sel

Par conséquent, un Perceptron peut être utilisé comme séparateur ou ligne de décision qui divise l'ensemble d'entrée de OR Gate, en deux classes:

Classe 1: Entrées dont la sortie est 0 qui se trouve sous la ligne de décision.
Classe 2: Entrées dont la sortie est 1 au-dessus de la ligne de décision ou du séparateur.

Jusqu'à présent, nous avons compris qu'un perceptron linéaire peut être utilisé pour classer l'ensemble de données d'entrée en deux classes. Mais comment classifie-t-il réellement les données?

Mathématiquement, un perceptron peut être considéré comme une équation de poids, d'entrées et de biais.

Étape 1: Importez toute la bibliothèque requise

Ici, je vais importer une seule bibliothèque, à savoir. TensorFlow

importer tensorflow en tant que tf

Étape 2: définir des variables vectorielles pour l'entrée et la sortie

Ensuite, nous devons créer des variables pour stocker l'entrée, la sortie et le biais du Perceptron.

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

Étape 3: définir la variable de poids

Ici, nous allons définir la variable tenseur de forme 3 × 1 pour nos poids et lui attribuer des valeurs aléatoires au départ.

w = tf.Variable (tf.random_normal ([3, 1], graine = 15))

Étape 4: définir des espaces réservés pour l'entrée et la sortie

Nous devons définir des espaces réservés afin qu'ils puissent accepter des entrées externes lors de l'exécution.

x = tf.placeholder (tf.float32, [None, 3]) y = tf.placeholder (tf.float32, [None, 1])

Étape 5: Calculer la fonction de sortie et d'activation

Comme discuté précédemment, l'entrée reçue par un perceptron est d'abord multipliée par les poids respectifs et ensuite, toutes ces entrées pondérées sont additionnées. Cette valeur additionnée est ensuite envoyée à l'activation pour obtenir le résultat final.

sortie = tf.nn.relu (tf.matmul (x, w))

Remarque: dans ce cas, j'ai utilisé relu comme ma fonction d'activation. Vous êtes libre d'utiliser l'une des fonctions d'activation selon vos besoins.

Étape 6: Calculez le coût ou l'erreur

Nous devons calculer le coût = erreur quadratique moyenne qui n'est rien d'autre que le carré de la différence entre la sortie du perceptron et la sortie souhaitée.

perte = tf.reduce_sum (tf.square (sortie - y))

Étape 7: minimiser l'erreur

Le but d'un perceptron est de minimiser la perte ou le coût ou l'erreur. Nous allons donc utiliser ici l'Optimiseur de descente de dégradé.

optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (perte)

Étape 8: Initialisez toutes les variables

Les variables ne sont définies qu'avec tf.Variable. Nous devons donc initialiser les variables définies.

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

Étape 9: Entraînement de Perceptron aux itérations

Nous devons former notre perceptron, c'est-à-dire mettre à jour les valeurs de poids et de biais dans l'itération successive pour minimiser l'erreur ou la perte. Ici, je formerai notre perceptron en 100 époques.

pour i dans la plage (100): sess.run (train, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - perte - ', coût)

Étape 10: sortie

……

……

comment utiliser Microsoft Visual Studio

Comme vous pouvez le voir ici, la perte a commencé à 2,07 et s'est terminé à 0,27

.

Deep Learning avec Python: création d'un réseau neuronal profond

Maintenant que nous avons réussi à créer un perceptron et à le former pour une porte OU. Continuons cet article et voyons comment créer notre propre réseau de neurones à partir de zéro, où nous allons créer une couche d'entrée, des couches cachées et une couche de sortie.

Nous allons utiliser l'ensemble de données MNIST. L'ensemble de données MNIST se compose de 60000 formations échantillons et 10 000 tests échantillons d'images numériques manuscrites. Les images sont de taille 28 × 28 pixels et la sortie peut se situer entre 0-9 .

La tâche ici est de former un modèle qui peut identifier avec précision le chiffre présent sur l'image

Tout d'abord, nous allons utiliser l'importation ci-dessous pour importer la fonction d'impression de Python 3 dans Python 2.6+. Les instructions __future__ doivent être vers le haut du fichier car elles changent des choses fondamentales sur le langage, et donc le compilateur doit les connaître dès le début

depuis __future__ import print_function

Voici le code avec des commentaires à chaque étape

# Importer des données MNIST depuis tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importer tensorflow as tf import matplotlib.pyplot as plt # Paramètres learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Paramètres de réseau n_hidden_1 = 256 # Nombre d'entités de la première couche n_hidden_2 = 256 # Nombre d'entités de la 2e couche n_input = 784 # Entrée de données MNIST (forme img: 28 * 28) n_classes = 10 # classes totales MNIST ( 0-9 chiffres) # tf Graph input x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Créer un modèle def multilayer_perceptron (x, weights , biais): # Couche cachée avec activation RELU layer_1 = tf.add (tf.matmul (x, weights ['h1']), biais ['b1']) layer_1 = tf.nn.relu (layer_1) # Couche cachée avec activation RELU layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biais ['b2']) layer_2 = tf.nn.relu (layer_2) # Couche de sortie avec activation linéaire out_layer = tf. matmul (couche _2, poids ['out']) + biais ['out'] return out_layer # Stocker le poids des calques et les poids biaisés = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biais = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # Construire le modèle pred = multilayer_perceptron (x, poids, biais) # Définir la perte et le coût de l'optimiseur = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Initialisation des variables init = tf.global_variables_initializer () #create une liste vide pour stocker l'historique des coûts et l'historique de précision cost_history = [] precision_history = [] # Lancez le graphe avec tf.Session () comme sess: sess.run (init ) # Cycle d'apprentissage pour l'époque dans l'intervalle (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Boucle sur tous les lots pour i dans la plage (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Exécuter l'optimisation op (backprop) et le coût op (pour obtenir la valeur de la perte) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Calculer la perte moyenne avg_cost + = c / total_batch # Afficher les journaux par étape d'époque si epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calculer la précision = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = precision.eval ({x: mnist.test.images, y: mnist.test.labels}) #append la précision à la liste precision_history.append (acu_temp) #append l'historique des coûts cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Précision =', acu_temp) print ('Optimisation terminée! ') #plot l'historique des coûts plt.plot (cost_history) plt.show () #plot l'historique de précision plt.plot (precision _history) plt.show () # Modèle de test correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calculer la précision de la précision = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Précision: ', precision.eval ({x: mnist.test.images, y: mnist.test.labels}))

Production:

Maintenant, avec cela, nous arrivons à la fin de cet article Deep Learning with Python. J'espère que vous avez compris les différents composants du Deep Learning, comment tout a commencé et comment en utilisant Python, nous pouvons créer un perceptron simple et un réseau de neurones profonds.

Edureka est organisé par des professionnels de l'industrie selon les exigences et les demandes de l'industrie. Vous maîtriserez les concepts tels que la fonction SoftMax, les réseaux de neurones Autoencoder, la machine Boltzmann restreinte (RBM) et travaillerez avec des bibliothèques telles que Keras et TFLearn. Le cours a été spécialement organisé par des experts de l'industrie avec des études de cas en temps réel.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de «Deep Learning avec Python» et nous vous répondrons.