cours
Tutoriel sur les réseaux neuronaux convolutifs (CNN) avec TensorFlow
Imaginez que vous vous trouviez dans un zoo et que vous essayiez de reconnaître si un animal donné est un guépard ou un léopard. En tant qu'être humain, votre cerveau peut analyser sans effort les caractéristiques du corps et du visage pour parvenir à une conclusion valable. De la même manière, les réseaux neuronaux convolutifs (CNN) peuvent être entraînés à effectuer la même tâche de reconnaissance, quelle que soit la complexité des motifs. Cela leur confère une grande puissance dans le domaine de la vision par ordinateur.
Ce tutoriel sur les CNN conceptuels commencera par donner un aperçu de ce que sont les CNN et de leur importance dans l'apprentissage automatique. Ensuite, il vous guidera pas à pas dans l'implémentation de CNN dans TensorFlow Framework 2.
Qu'est-ce qu'un CNN ?
Un réseau neuronal convolutif (CNN ou ConvNet) est un algorithme d'apprentissage profond spécialement conçu pour toute tâche où la reconnaissance d'objets est cruciale, comme la classification, la détection et la segmentation d'images. De nombreuses applications réelles, telles que les voitures autonomes, les caméras de surveillance et autres, utilisent les CNN.
L'importance des CNN
Plusieurs raisons expliquent l'importance des CNN, comme indiqué ci-dessous :
- Contrairement aux modèles traditionnels d'apprentissage automatique tels que les SVM et les arbres de décision qui nécessitent des extractions manuelles de caractéristiques, les CNN peuvent effectuer des extractions automatiques de caractéristiques à grande échelle, ce qui les rend efficaces.
- Les couches de convolutions rendent les CNN invariants par rapport à la traduction, ce qui signifie qu'ils peuvent reconnaître des modèles à partir de données et extraire des caractéristiques quelle que soit leur position, que l'image soit tournée, mise à l'échelle ou décalée.
- Plusieurs modèles CNN pré-entraînés tels que VGG-16, ResNet50, Inceptionv3 et EfficientNet ont obtenu des résultats de pointe et peuvent être affinés sur des tâches d'actualité en utilisant une quantité relativement faible de données.
- Les CNN peuvent également être utilisés pour des problèmes de classification non liés à l'image et ne sont pas limités au traitement du langage naturel, à l'analyse des séries temporelles et à la reconnaissance vocale.
Architecture d'un CNN
L'architecture des CNN tente d'imiter la structure des neurones du système visuel humain, composée de plusieurs couches, où chacune est responsable de la détection d'une caractéristique spécifique dans les données. Comme l'illustre l'image ci-dessous, le CNN typique est constitué d'une combinaison de quatre couches principales :
- Couches convolutives
- Unité linéaire rectifiée (ReLU)
- Mise en commun des couches
- Couches entièrement connectées
Comprenons le fonctionnement de chacune de ces couches à l'aide de l'exemple suivant de classification d'un chiffre manuscrit.
Couches de convolution
C'est le premier élément constitutif d'un CNN. Comme son nom l'indique, la principale tâche mathématique effectuée s'appelle la convolution, qui consiste à appliquer une fonction de fenêtre coulissante à une matrice de pixels représentant une image. La fonction de glissement appliquée à la matrice est appelée noyau ou filtre, les deux pouvant être utilisés de manière interchangeable.
Dans la couche de convolution, plusieurs filtres de taille égale sont appliqués, et chaque filtre est utilisé pour reconnaître un motif spécifique de l'image, comme la courbure des chiffres, les bords, la forme entière des chiffres, etc.
Considérons cette image 32x32 en niveaux de gris d'un chiffre écrit à la main. Les valeurs de la matrice sont données à titre d'illustration.
Considérons également le noyau utilisé pour la convolution. Il s'agit d'une matrice de dimension 3x3. Les poids de chaque élément du noyau sont représentés dans la grille. Les poids nuls sont représentés dans les grilles noires et les poids un dans les grilles blanches.
Devons-nous trouver manuellement ces poids ?
Dans la réalité, les poids des noyaux sont déterminés au cours du processus d'apprentissage du réseau neuronal.
En utilisant ces deux matrices, nous pouvons effectuer l'opération de convolution en appliquant le produit de point, et travailler comme suit :
- Appliquez la matrice du noyau du coin supérieur gauche vers la droite.
- Effectuez une multiplication par éléments.
- Additionnez les valeurs des produits.
- La valeur obtenue correspond à la première valeur (coin supérieur gauche) de la matrice convoluée.
- Déplacez le noyau vers le bas par rapport à la taille de la fenêtre coulissante.
- Répétez les étapes 1 à 5 jusqu'à ce que la matrice d'image soit entièrement recouverte.
La dimension de la matrice convoluée dépend de la taille de la fenêtre coulissante. Plus la fenêtre coulissante est grande, plus la dimension est petite.
Un autre nom associé au noyau dans la littérature est celui de détecteur de caractéristiques, car les poids peuvent être ajustés avec précision pour détecter des caractéristiques spécifiques dans l'image d'entrée.
Par exemple :
- La moyenne du noyau des pixels voisins peut être utilisée pour rendre l'image d'entrée floue.
- La soustraction des noyaux voisins est utilisée pour la détection des contours.
Plus le réseau comporte de couches de convolution, meilleure est la capacité de la couche à détecter des caractéristiques plus abstraites.
Fonction d'activation
Une fonction d'activation ReLU est appliquée après chaque opération de convolution. Cette fonction aide le réseau à apprendre les relations non linéaires entre les caractéristiques de l'image, ce qui rend le réseau plus robuste pour l'identification de différents modèles. Elle permet également d'atténuer les problèmes de gradient de fuite.
Couche de mise en commun
L'objectif de la couche de mise en commun est d'extraire les caractéristiques les plus significatives de la matrice convoluée. Cela se fait en appliquant certaines opérations d'agrégation, qui réduisent la dimension de la carte des caractéristiques (matrice convoluée), réduisant ainsi la mémoire utilisée lors de l'entraînement du réseau. La mise en commun permet également d'atténuer l'ajustement excessif.
Les fonctions d'agrégation les plus courantes qui peuvent être appliquées sont les suivantes :
- Mise en commun maximale qui est la valeur maximale de la carte des caractéristiques
- La mise en commun de la somme correspond à la somme de toutes les valeurs de la carte des caractéristiques.
- La mise en commun moyenne est la moyenne de toutes les valeurs.
Vous trouverez ci-dessous une illustration de chacun des exemples précédents :
En outre, la dimension de la carte de caractéristiques diminue au fur et à mesure de l'application de la fonction de sondage.
La dernière couche de mise en commun aplatit sa carte de caractéristiques afin qu'elle puisse être traitée par la couche entièrement connectée.
Couches entièrement connectées
Ces couches se trouvent dans la dernière couche du réseau neuronal convolutif et leurs entrées correspondent à la matrice unidimensionnelle aplatie générée par la dernière couche de mise en commun. Les fonctions d'activation ReLU leur sont appliquées pour assurer la non-linéarité.
Enfin, une couche de prédiction softmax est utilisée pour générer des valeurs de probabilité pour chacune des étiquettes de sortie possibles, et l'étiquette finale prédite est celle qui présente le score de probabilité le plus élevé.
Abandon
L'exclusion est une technique de régularisation appliquée pour améliorer la capacité de généralisation des réseaux neuronaux avec un grand nombre de paramètres. Elle consiste à supprimer aléatoirement certains neurones au cours du processus de formation, ce qui oblige les neurones restants à apprendre de nouvelles caractéristiques à partir des données d'entrée.
Étant donné que la mise en œuvre technique sera effectuée à l'aide de TensorFlow 2, la section suivante vise à fournir une vue d'ensemble complète des différents composants de ce cadre pour construire efficacement des modèles d'apprentissage profond.
Qu'est-ce que le framework TensorFlow ?
Google a développé TensorFlow en novembre 2015. Ils le définissent comme un cadre d'apprentissage machine open-source pour tout le monde, et ce pour plusieurs raisons.
- Open-source: publié sous la licence open-source Apache 2.0. Cela permet aux chercheurs, aux organisations et aux développeurs d'apporter leur contribution à la bibliothèque en s'appuyant sur elle sans aucune restriction.
- Cadre d'apprentissage automatiqueLe cadre d'apprentissage automatique (Machine Learning Framework) est un ensemble de bibliothèques et d'outils qui soutiennent le processus de construction de modèles d'apprentissage automatique.
- Pour tous: L'utilisation de TensorFlow facilite la mise en œuvre de modèles d'apprentissage automatique grâce à des langages de programmation courants comme Python. En outre, les bibliothèques intégrées telles que Keras facilitent encore la création de modèles d'apprentissage profond robustes.
Toutes ces fonctionnalités font de Tensorflow un bon candidat pour la construction de réseaux neuronaux.
Par ailleurs, l'installation de Tensorflow 2 est simple et peut être réalisée comme suit à l'aide du gestionnaire de paquets Python. pip comme expliqué dans la documentation officielle.
Après l'installation, nous pouvons voir que la version utilisée est la 2.9.1.
import tensorflow as tf
print("TensorFlow version:", tf.__version__)
Explorons maintenant plus en détail les principaux éléments permettant de créer ces réseaux.
Qu'est-ce qu'un tenseur ?
Nous traitons principalement des données à haute dimension lorsque nous construisons des modèles d'apprentissage automatique et d'apprentissage profond. Les tenseurs sont des tableaux multidimensionnels d'un type uniforme utilisés pour représenter différentes caractéristiques des données.
Vous trouverez ci-dessous la représentation graphique des différents types de dimensions des tenseurs.
- Un tenseur à 0 dimension contient une seule valeur.
- Un tenseur à une dimension, également connu sous le nom de tenseur de "rang 1", est une liste de valeurs.
- Un tenseur à 2 dimensions est un tenseur de "rang 2".
- Enfin, nous pouvons avoir un tenseur à N dimensions, où N représente le nombre de dimensions dans le tenseur. Dans les cas précédents, N est respectivement 0, 1 et 2.
Vous trouverez ci-dessous une illustration du passage d'un zéro à un tenseur tridimensionnel. Chaque tenseur est créé à l'aide de la fonction constant() de TensorFlow.
# Zero dimensional tensor
zero_dim_tensor = tf.constant(20)
print(zero_dim_tensor)
# One dimensional tensor
one_dim_tensor = tf.constant([12, 20, 53, 26, 11, 56])
print(one_dim_tensor)
# Two dimensional tensor
two_dim_array = [[3, 6, 7, 5],
[9, 2, 3, 4],
[7, 1, 10,6],
[0, 8, 11,2]]
two_dim_tensor = tf.constant(two_dim_array)
print(two_dim_tensor)
Une exécution réussie du code précédent devrait générer les résultats ci-dessous, et nous pouvons remarquer le mot-clé "tf.Tensor" pour signifier que le résultat est un tenseur. Il comporte trois paramètres :
- La valeur réelle du tenseur.
- La méthode forme() du tenseur, qui est 0, 6 par 1, et 4 par 4, respectivement pour les premier, deuxième et troisième tenseurs.
- Le type de données représenté par le champ dtype et tous les tenseurs sont des int32.
Notre tutoriel Tensorflow pour les débutants fournit une vue d'ensemble complète de TensorFlow et enseigne comment construire et former des modèles.
Tenseurs et matrices : Différences
De nombreuses personnes confondent les tenseurs avec les matrices. Même si ces deux objets se ressemblent, ils ont des propriétés complètement différentes. Cette section permet de mieux comprendre la différence entre les matrices et les tenseurs.
- Nous pouvons considérer une matrice comme un tenseur à deux dimensions seulement.
- Les tenseurs, en revanche, sont un format plus général qui peut avoir n'importe quel nombre de dimensions.
Contrairement aux matrices, les tenseurs sont mieux adaptés aux problèmes d'apprentissage profond pour les raisons suivantes :
- Ils peuvent traiter un nombre illimité de dimensions, ce qui les rend mieux adaptés aux données multidimensionnelles.
- La compatibilité des tenseurs avec un large éventail de types de données, de formes et de dimensions les rend plus polyvalents que les matrices.
- Tensorflow prend en charge les GPU et TPU pour accélérer les calculs. Grâce aux tenseurs, les ingénieurs en apprentissage automatique peuvent automatiquement tirer parti de ces avantages.
- Les tenseurs supportent nativement la diffusion, qui consiste à effectuer des opérations arithmétiques entre des tenseurs de formes différentes, ce qui n'est pas toujours possible avec les matrices.
TensorFlow : Constantes, variables et espaces réservés
Les constantes ne sont pas les seuls types de tenseurs. Il existe également des variables et des espaces réservés, qui sont autant d'éléments constitutifs d'un graphe de calcul.
Un graphique de calcul est essentiellement une représentation d'une séquence d'opérations et du flux de données entre elles.
Comprenons maintenant la différence entre ces types de tenseurs.
Constantes
Les constantes sont des tenseurs dont les valeurs ne changent pas pendant l'exécution du graphique de calcul. Ils sont créés à l'aide de la fonction tf.constant() et sont principalement utilisés pour stocker des paramètres fixes qui ne nécessitent aucune modification au cours de l'apprentissage du modèle.
Variables
Les variables sont des tenseurs dont la valeur peut être modifiée au cours de l'exécution du graphique de calcul. Elles sont créées à l'aide de la fonctiontf.Variable(). Par exemple, dans le cas des réseaux neuronaux, les poids et les biais peuvent être définis comme des variables puisqu'ils doivent être mis à jour au cours du processus de formation.
Placeholders
Ils ont été utilisés dans la première version de Tensorflow comme des conteneurs vides qui n'ont pas de valeurs spécifiques. Ils ne servent qu'à inverser un point pour les données qui seront utilisées à l'avenir. Cela donne aux utilisateurs la liberté d'utiliser différents ensembles de données et différentes tailles de lots lors de l'apprentissage et de la validation des modèles.
Dans la version 2 de Tensorflow, les placeholders ont été remplacés par la fonction tf.function() qui constitue une approche plus Python et plus dynamique de l'alimentation des données dans le graphe de calcul.
Mise en œuvre du CNN étape par étape
Mettons en pratique tout ce que nous avons appris précédemment. Cette section illustre la mise en œuvre de bout en bout d'un réseau neuronal convolutif dans TensorFlow appliqué à l'ensemble de données CIFAR-10, qui est un ensemble de données intégré présentant les propriétés suivantes :
- Il contient 60 000 images en couleur 32 x 32.
- L'ensemble de données comprend 10 classes différentes
- Chaque classe comporte 6000 images
- Il y a en tout 50 000 images d'entraînement
- Et au total, 10 000 images d'essai
Le code source de l'article est disponible sur l 'espace de travail de DataCamp
Architecture du réseau
Avant d'aborder la mise en œuvre technique, il convient de comprendre l'architecture globale du réseau mis en place.
- L'entrée du modèle est un tenseur 32x32x3, respectivement pour la largeur, la hauteur et les canaux.
- Nous aurons deux couches convolutives. La première couche applique 32 filtres de taille 3x3 chacun et une fonction d'activation ReLU. La seconde applique 64 filtres de taille 3x3.
- La première couche de mise en commun appliquera une mise en commun maximale de 2 x 2.
- La deuxième couche de mise en commun appliquera également une mise en commun maximale de 2 x 2.
- La couche entièrement connectée comporte 128 unités et une fonction d'activation ReLU.
- Enfin, la sortie sera constituée de 10 unités correspondant aux 10 classes, et la fonction d'activation est une softmax pour générer les distributions de probabilité.
Charger l'ensemble de données
Le jeu de données intégré est chargé à partir de keras.datasets() comme suit :
(train_images, train_labels), (test_images, test_labels) = cf10.load_data()
Analyse exploratoire des données
Dans cette section, nous nous concentrerons uniquement sur la présentation de quelques exemples d'images puisque nous connaissons déjà la proportion de chaque classe dans les données d'apprentissage et de test.
La fonction d'aide show_images() affiche un total de 12 images par défaut et prend trois paramètres principaux :
- Les images d'apprentissage
- Les noms des classes
- Et les étiquettes de formation.
import matplotlib.pyplot as plt
def show_images(train_images,
class_names,
train_labels,
nb_samples = 12, nb_row = 4):
plt.figure(figsize=(12, 12))
for i in range(nb_samples):
plt.subplot(nb_row, nb_row, i + 1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i][0]])
plt.show()
Nous pouvons maintenant appeler la fonction avec les paramètres requis.
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']
show_images(train_images, class_names, train_labels)
Une exécution réussie du code précédent génère les images ci-dessous.
Prétraitement des données
Avant d'entraîner le modèle, nous devons normaliser les valeurs des pixels des données dans la même plage (par exemple, 0 à 1). Il s'agit d'une étape de prétraitement courante lorsqu'il s'agit d'images, afin de garantir l'invariance d'échelle et une convergence plus rapide lors de l'apprentissage.
max_pixel_value = 255
train_images = train_images / max_pixel_value
test_images = test_images / max_pixel_value
Nous remarquons également que les étiquettes sont représentées sous forme de catégories telles que chat, cheval, oiseau, etc. Nous devons les convertir en format numérique afin qu'ils puissent être facilement traités par le réseau neuronal.
from tensorflow.keras.utils import to_categorical
train_labels = to_categorical(train_labels, len(class_names))
test_labels = to_categorical(test_labels, len(class_names))
Mise en œuvre de l'architecture du modèle
L'étape suivante consiste à mettre en œuvre l'architecture du réseau sur la base de la description précédente.
Tout d'abord, nous définissons le modèle à l'aide de la méthode Séquentielle() et chaque couche est ajoutée au modèle avec la méthode add() pour ajouter chaque couche au modèle.
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
# Variables
INPUT_SHAPE = (32, 32, 3)
FILTER1_SIZE = 32
FILTER2_SIZE = 64
FILTER_SHAPE = (3, 3)
POOL_SHAPE = (2, 2)
FULLY_CONNECT_NUM = 128
NUM_CLASSES = len(class_names)
# Model architecture implementation
model = Sequential()
model.add(Conv2D(FILTER1_SIZE, FILTER_SHAPE, activation='relu', input_shape=INPUT_SHAPE))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Conv2D(FILTER2_SIZE, FILTER_SHAPE, activation='relu'))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Flatten())
model.add(Dense(FULLY_CONNECT_NUM, activation='relu'))
model.add(Dense(NUM_CLASSES, activation='softmax'))
Après avoir appliqué la fonction summary() au modèle, nous obtenons un résumé complet de l'architecture du modèle avec des informations sur chaque couche, son type, sa forme de sortie et le nombre total de paramètres entraînables.
Modèle de formation
Toutes les ressources sont enfin disponibles pour configurer et déclencher l'entraînement du modèle. Cela se fait respectivement avec les fonctions compile() et fit() qui prennent les paramètres suivants :
- L'optimiseur est chargé de mettre à jour les poids et les biais du modèle. Dans notre cas, nous utilisons l'optimiseur Adam.
- La fonction de perte est utilisée pour mesurer les erreurs de classification, et nous utilisons la fonction Crosentropy().
- Enfin, les métriques sont utilisées pour mesurer la performance du modèle, et l'exactitude, la précision et le rappel seront affichés dans notre cas d'utilisation.
from tensorflow.keras.metrics import Precision, Recall
BATCH_SIZE = 32
EPOCHS = 30
METRICS = metrics=['accuracy',
Precision(name='precision'),
Recall(name='recall')]
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics = METRICS)
# Train the model
training_history = model.fit(train_images, train_labels,
epochs=EPOCHS, batch_size=BATCH_SIZE,
validation_data=(test_images, test_labels))
Évaluation du modèle
Après l'apprentissage du modèle, nous pouvons comparer ses performances sur les ensembles de données d'apprentissage et de test en traçant les métriques ci-dessus à l'aide de la fonction show_performance_curve() en deux dimensions.
- L'axe horizontal (x) représente le nombre d'époques.
- La partie verticale (y) est la performance sous-jacente du modèle.
- La courbe représente la valeur des mesures à une époque donnée.
Pour une meilleure visualisation, une ligne verticale rouge est tracée à l'intersection des valeurs de performance d'entraînement et de validation, ainsi que de la valeur optimale.
def show_performance_curve(training_result, metric, metric_label):
train_perf = training_result.history[str(metric)]
validation_perf = training_result.history['val_'+str(metric)]
intersection_idx = np.argwhere(np.isclose(train_perf,
validation_perf, atol=1e-2)).flatten()[0]
intersection_value = train_perf[intersection_idx]
plt.plot(train_perf, label=metric_label)
plt.plot(validation_perf, label = 'val_'+str(metric))
plt.axvline(x=intersection_idx, color='r', linestyle='--', label='Intersection')
plt.annotate(f'Optimal Value: {intersection_value:.4f}',
xy=(intersection_idx, intersection_value),
xycoords='data',
fontsize=10,
color='green')
plt.xlabel('Epoch')
plt.ylabel(metric_label)
plt.legend(loc='lower right')
Ensuite, la fonction est appliquée à la fois pour l'exactitude et la précision du modèle.
show_performance_curve(training_history, 'accuracy', 'accuracy')
show_performance_curve(training_history, 'precision', 'precision')
Après avoir entraîné le modèle sans aucun réglage fin ni prétraitement, nous obtenons le résultat suivant :
- Un score de précision de 67,09 %, ce qui signifie que le modèle classe correctement 67 % des échantillons sur 100.
- Et une précision de 76,55 %, ce qui signifie que sur 100 prédictions positives, près de 77 sont de vrais positifs, les 23 restants étant des faux positifs.
- Ces scores sont obtenus respectivement à la troisième et à la deuxième époque pour la précision et l'exactitude.
Ces deux mesures permettent une compréhension globale du comportement du modèle.
Et si nous voulions savoir, pour chaque classe, quelles sont celles que le modèle prédit bien et celles pour lesquelles il a des difficultés ?
Cela est possible grâce à la matrice de confusion, qui indique pour chaque classe le nombre de prédictions correctes et erronées. La mise en œuvre est présentée ci-dessous. Nous commençons par faire des prédictions sur les données de test, puis nous calculons la matrice de confusion et montrons le résultat final.
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
test_predictions = model.predict(test_images)
test_predicted_labels = np.argmax(test_predictions, axis=1)
test_true_labels = np.argmax(test_labels, axis=1)
cm = confusion_matrix(test_true_labels, test_predicted_labels)
cmd = ConfusionMatrixDisplay(confusion_matrix=cm)
cmd.plot(include_values=True, cmap='viridis', ax=None, xticks_rotation='horizontal')
plt.show()
- Les classes 0, 1, 6, 7, 8, 9, respectivement, pour l'avion, l'automobile, la grenouille, le cheval, le bateau et le camion ont les valeurs les plus élevées à la diagonale. Cela signifie que le modèle prédit mieux ces classes.
- En revanche, il semble avoir des difficultés avec les autres classes :
- Les classes dont les valeurs hors diagonale sont les plus élevées sont celles avec lesquelles le modèle confond les bonnes classes. Par exemple, il confond oiseaux (classe 2) avec un avion, et automobile avec des camions (classe 9).
Pour en savoir plus sur les matrices de confusion, consultez notre tutoriel Comprendre les matrices de confusion en Rqui reprend le matériel du cours Machine Learning toolbox de DataCamp.
Ce modèle peut être amélioré par des tâches supplémentaires telles que :
- Augmentation de l'image
- Apprentissage par transfert à l'aide de modèles préformés tels que ResNet, MobileNet ou VGG. Notre Tutoriel sur l'apprentissage par transfert explique ce qu'est l'apprentissage par transfert et certaines de ses applications dans la vie réelle.
- Application de différentes techniques de régularisation telles que L1, L2 ou dropout.
- Affiner les différents hyperparamètres tels que le taux d'apprentissage, la taille du lot, le nombre de couches dans le réseau.
Conclusion
Cet article présente une vue d'ensemble des CNN dans TensorFlow, en détaillant chaque couche de l'architecture des CNN. Il a également présenté brièvement TensorFlow et la manière dont il aide les ingénieurs et les chercheurs en apprentissage automatique à construire des réseaux neuronaux sophistiqués.
Nous avons appliqué tous ces ensembles de compétences à un scénario réel lié à une tâche de classification multiclasse.
Notre guide d'initiation à la détection d'objets pourrait constituer une excellente étape pour approfondir votre apprentissage de la vision par ordinateur. Il explore les composants clés de la détection d'objets et explique comment les mettre en œuvre dans SSD et Faster RCNN disponible dans Tensorflow.
Cours de Python
cours
Intermediate Python
cours
Introduction to Deep Learning in Python
blog
2022-2023 Rapport annuel DataCamp Classrooms
blog
Les 32 meilleures questions d'entretien sur AWS et leurs réponses pour 2024
blog
Les 20 meilleures questions d'entretien pour les flocons de neige, à tous les niveaux

Nisha Arya Ahmed
20 min
blog
Q2 2023 DataCamp Donates Digest
blog
Nous avons fait don de bourses DataCamp Premium à un million de personnes, et ce n'est pas fini.
blog
Célébration de Saghar Hazinyar : Une boursière de DataCamp Donates et une diplômée de Code to Inspire

Fereshteh Forough
4 min