AI avec Python - Deep Learning

Artificial Neural Network (ANN) c'est un système informatique efficace, dont le thème central est emprunté à l'analogie des réseaux de neurones biologiques. Les réseaux de neurones sont un type de modèle pour l'apprentissage automatique. Au milieu des années 80 et au début des années 90, de nombreuses avancées architecturales importantes ont été réalisées dans les réseaux de neurones. Dans ce chapitre, vous en apprendrez plus sur le Deep Learning, une approche de l'IA.

L'apprentissage en profondeur est né de la croissance informatique explosive d'une décennie en tant que candidat sérieux dans le domaine. Ainsi, l'apprentissage en profondeur est un type particulier d'apprentissage automatique dont les algorithmes sont inspirés de la structure et de la fonction du cerveau humain.

Machine Learning v / s Deep Learning

L'apprentissage en profondeur est la technique d'apprentissage automatique la plus puissante de nos jours. Il est si puissant parce qu'ils apprennent la meilleure façon de représenter le problème tout en apprenant à le résoudre. Une comparaison entre l'apprentissage profond et l'apprentissage automatique est donnée ci-dessous -

Dépendance des données

Le premier point de différence est basé sur les performances de DL et ML lorsque l'échelle des données augmente. Lorsque les données sont volumineuses, les algorithmes d'apprentissage en profondeur fonctionnent très bien.

Dépendance de la machine

Les algorithmes d'apprentissage profond ont besoin de machines haut de gamme pour fonctionner parfaitement. D'un autre côté, les algorithmes d'apprentissage automatique peuvent également fonctionner sur des machines bas de gamme.

Extraction de caractéristiques

Les algorithmes d'apprentissage en profondeur peuvent extraire des fonctionnalités de haut niveau et essayer d'en tirer également des leçons. D'autre part, un expert est tenu d'identifier la plupart des fonctionnalités extraites par l'apprentissage automatique.

Temps d'exécution

Le temps d'exécution dépend des nombreux paramètres utilisés dans un algorithme. L'apprentissage en profondeur a plus de paramètres que les algorithmes d'apprentissage automatique. Par conséquent, le temps d'exécution des algorithmes DL, en particulier le temps d'apprentissage, est bien plus que les algorithmes ML. Mais le temps de test des algorithmes DL est inférieur à celui des algorithmes ML.

Approche de la résolution de problèmes

L'apprentissage profond résout le problème de bout en bout tandis que l'apprentissage automatique utilise la méthode traditionnelle de résolution du problème, c'est-à-dire en le décomposant en plusieurs parties.

Réseau neuronal convolutif (CNN)

Les réseaux de neurones convolutifs sont les mêmes que les réseaux de neurones ordinaires car ils sont également constitués de neurones qui ont des poids et des biais apprenables. Les réseaux de neurones ordinaires ignorent la structure des données d'entrée et toutes les données sont converties en tableau 1-D avant de les alimenter dans le réseau. Ce processus convient aux données normales, mais si les données contiennent des images, le processus peut être fastidieux.

CNN résout ce problème facilement. Il prend en compte la structure 2D des images lors de leur traitement, ce qui leur permet d'extraire les propriétés propres aux images. De cette manière, l'objectif principal des CNN est de passer des données d'image brutes dans la couche d'entrée à la classe correcte dans la couche de sortie. La seule différence entre un NN ordinaire et un CNN réside dans le traitement des données d'entrée et dans le type de couches.

Vue d'ensemble de l'architecture des CNN

Sur le plan architectural, les réseaux de neurones ordinaires reçoivent une entrée et la transforment à travers une série de couches cachées. Chaque couche est connectée à l'autre couche à l'aide de neurones. Le principal inconvénient des réseaux de neurones ordinaires est qu'ils ne s'adaptent pas bien aux images complètes.

L'architecture des CNN a des neurones disposés en 3 dimensions appelées largeur, hauteur et profondeur. Chaque neurone de la couche actuelle est connecté à un petit patch de la sortie de la couche précédente. C'est similaire à la superposition d'un×filtre sur l'image d'entrée. Il utiliseMfiltres pour être sûr d'obtenir tous les détails. Celles-ciM Les filtres sont des extracteurs de caractéristiques qui extraient des caractéristiques telles que les bords, les coins, etc.

Couches utilisées pour construire des CNN

Les couches suivantes sont utilisées pour construire des CNN -

  • Input Layer - Il prend les données d'image brutes telles quelles.

  • Convolutional Layer- Cette couche est le bloc de construction de base des CNN qui effectue la plupart des calculs. Cette couche calcule les convolutions entre les neurones et les différents patchs en entrée.

  • Rectified Linear Unit Layer- Il applique une fonction d'activation à la sortie de la couche précédente. Il ajoute de la non-linéarité au réseau afin qu'il puisse bien se généraliser à tout type de fonction.

  • Pooling Layer- La mise en commun nous aide à ne conserver que les parties importantes au fur et à mesure que nous progressons dans le réseau. La couche de regroupement fonctionne indépendamment sur chaque tranche de profondeur de l'entrée et la redimensionne spatialement. Il utilise la fonction MAX.

  • Fully Connected layer/Output layer - Cette couche calcule les scores de sortie dans la dernière couche. La sortie résultante est de la taille×× , où L est le nombre de classes d'ensemble de données d'entraînement.

Installer des packages Python utiles

Vous pouvez utiliser Keras, qui est une API de réseaux de neurones de haut niveau, écrite en Python et capable de s'exécuter au-dessus de TensorFlow, CNTK ou Theno. Il est compatible avec Python 2.7-3.6. Vous pouvez en savoir plus surhttps://keras.io/.

Utilisez les commandes suivantes pour installer keras -

pip install keras

Sur conda environnement, vous pouvez utiliser la commande suivante -

conda install –c conda-forge keras

Construire un régresseur linéaire avec ANN

Dans cette section, vous apprendrez à créer un régresseur linéaire à l'aide de réseaux de neurones artificiels. Vous pouvez utiliserKerasRegressorpour y parvenir. Dans cet exemple, nous utilisons l'ensemble de données sur les prix des logements de Boston avec 13 valeurs numériques pour les propriétés à Boston. Le code Python pour le même est montré ici -

Importez tous les packages requis comme indiqué -

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

Maintenant, chargez notre jeu de données qui est enregistré dans le répertoire local.

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values

Maintenant, divisez les données en variables d'entrée et de sortie, c'est-à-dire X et Y -

X = dataset[:,0:13]
Y = dataset[:,13]

Puisque nous utilisons des réseaux de neurones de base, définissez le modèle -

def baseline_model():

Maintenant, créez le modèle comme suit -

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal', 
   activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))

Ensuite, compilez le modèle -

model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor

Maintenant, corrigez la graine aléatoire pour la reproductibilité comme suit -

seed = 7
numpy.random.seed(seed)

Objet wrapper Keras à utiliser dans scikit-learn comme un estimateur de régression est appelé KerasRegressor. Dans cette section, nous évaluerons ce modèle avec un jeu de données normalisé.

estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))

La sortie du code ci-dessus serait l'estimation de la performance du modèle sur le problème pour les données invisibles. Ce sera l'erreur quadratique moyenne, y compris la moyenne et l'écart type sur les 10 fois de l'évaluation de validation croisée.

Classificateur d'images: une application d'apprentissage en profondeur

Les réseaux de neurones convolutifs (CNN) résolvent un problème de classification d'image, c'est-à-dire à quelle classe appartient l'image d'entrée. Vous pouvez utiliser la bibliothèque d'apprentissage en profondeur Keras. Notez que nous utilisons l'ensemble de données d'entraînement et de test d'images de chats et de chiens à partir du lien suivanthttps://www.kaggle.com/c/dogs-vs-cats/data.

Importez les bibliothèques et les packages keras importants comme indiqué -

Le package suivant appelé séquentiel initialisera les réseaux de neurones en tant que réseau séquentiel.

from keras.models import Sequential

Le package suivant appelé Conv2D est utilisé pour effectuer l'opération de convolution, la première étape de CNN.

from keras.layers import Conv2D

Le package suivant appelé MaxPoling2D est utilisé pour effectuer l'opération de mise en commun, la deuxième étape de CNN.

from keras.layers import MaxPooling2D

Le package suivant appelé Flatten est le processus de conversion de tous les tableaux 2D résultants en un seul vecteur linéaire long et continu.

from keras.layers import Flatten

Le package suivant appelé Dense est utilisé pour effectuer la connexion complète du réseau neuronal, la quatrième étape de CNN.

from keras.layers import Dense

Maintenant, créez un objet de la classe séquentielle.

S_classifier = Sequential()

Maintenant, l'étape suivante consiste à coder la partie convolution.

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))

Ici relu est la fonction du redresseur.

Maintenant, l'étape suivante de CNN est l'opération de mise en commun sur les cartes de caractéristiques résultantes après la partie convolution.

S-classifier.add(MaxPooling2D(pool_size = (2, 2)))

Maintenant, convertissez toutes les images regroupées en un vecteur continu en utilisant flatteur -

S_classifier.add(Flatten())

Ensuite, créez une couche entièrement connectée.

S_classifier.add(Dense(units = 128, activation = 'relu'))

Ici, 128 est le nombre d'unités cachées. Il est courant de définir le nombre d'unités cachées comme la puissance de 2.

Maintenant, initialisez la couche de sortie comme suit -

S_classifier.add(Dense(units = 1, activation = 'sigmoid'))

Maintenant, compilez le CNN, nous avons construit -

S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

Ici, le paramètre d'optimisation consiste à choisir l'algorithme de descente de gradient stochastique, le paramètre de perte consiste à choisir la fonction de perte et le paramètre de métrique à choisir la métrique de performance.

Maintenant, effectuez des augmentations d'image, puis adaptez les images aux réseaux de neurones -

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

test_set = 
   test_datagen.flow_from_directory('test_set',target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

Maintenant, adaptez les données au modèle que nous avons créé -

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,validation_data = test_set,validation_steps = 2000)

Ici, steps_per_epoch contient le nombre d'images d'entraînement.

Maintenant que le modèle a été formé, nous pouvons l'utiliser pour la prédiction comme suit -

from keras.preprocessing import image

test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
   prediction = 'cat'