Qu'est-ce que le réseau neuronal convolutif?
Le réseau de neurones convolutifs, également connu sous le nom de convnets ou CNN, est une méthode bien connue dans les applications de vision par ordinateur. Ce type d'architecture est dominant pour reconnaître des objets à partir d'une image ou d'une vidéo.
Dans ce didacticiel, vous apprendrez à créer un réseau convnet et à utiliser TensorFlow pour résoudre l'ensemble de données manuscrites.
Dans ce tutoriel, vous apprendrez
- Réseau neuronal convolutif
- Architecture d'un réseau neuronal convolutif
- Composants de Convnets
- Entraînez CNN avec TensorFlow
- Étape 1: télécharger l'ensemble de données
- Étape 2: couche d'entrée
- Étape 3: couche convolutionnelle
- Étape 4: couche de mise en commun
- Étape 5: Deuxième couche convolutionnelle et couche de regroupement
- Étape 6: couche dense
- Étape 7: couche Logit
Architecture d'un réseau neuronal convolutif
Pensez à Facebook il y a quelques années, après avoir téléchargé une photo sur votre profil, on vous a demandé d'ajouter un nom au visage sur la photo manuellement. De nos jours, Facebook utilise convnet pour marquer automatiquement votre ami sur l'image.
Un réseau de neurones convolutifs n'est pas très difficile à comprendre. Une image d'entrée est traitée pendant la phase de convolution et attribuée ultérieurement à une étiquette.
Une architecture convnet typique peut être résumée dans l'image ci-dessous. Tout d'abord, une image est poussée vers le réseau; c'est ce qu'on appelle l'image d'entrée. Ensuite, l'image d'entrée passe par un nombre infini d'étapes; c'est la partie convolutive du réseau. Enfin, le réseau neuronal peut prédire le chiffre sur l'image.
Une image est composée d'un tableau de pixels de hauteur et de largeur. Une image en niveaux de gris n'a qu'un seul canal tandis que l'image couleur a trois canaux (chacun pour le rouge, le vert et le bleu). Un canal est empilé les uns sur les autres. Dans ce didacticiel, vous utiliserez une image en niveaux de gris avec un seul canal. Chaque pixel a une valeur de 0 à 255 pour refléter l'intensité de la couleur. Par exemple, un pixel égal à 0 affichera une couleur blanche tandis qu'un pixel avec une valeur proche de 255 sera plus sombre.
Jetons un coup d'œil à une image stockée dans le jeu de données MNIST. L'image ci-dessous montre comment représenter l'image de gauche dans un format matriciel. Notez que la matrice d'origine a été normalisée pour être comprise entre 0 et 1. Pour les couleurs plus foncées, la valeur de la matrice est d'environ 0,9 tandis que les pixels blancs ont une valeur de 0.
Fonctionnement par convolution
Le composant le plus critique du modèle est la couche convolutive. Cette partie vise à réduire la taille de l'image pour des calculs plus rapides des poids et à améliorer sa généralisation.
Pendant la partie convolutive, le réseau conserve les caractéristiques essentielles de l'image et exclut les bruits non pertinents. Par exemple, le modèle apprend à reconnaître un éléphant à partir d'une image avec une montagne en arrière-plan. Si vous utilisez un réseau de neurones traditionnel, le modèle attribuera un poids à tous les pixels, y compris ceux de la montagne, ce qui n'est pas indispensable et peut induire le réseau en erreur.
Au lieu de cela, un réseau de neurones convolutifs utilisera une technique mathématique pour extraire uniquement les pixels les plus pertinents. Cette opération mathématique est appelée convolution. Cette technique permet au réseau d'apprendre des caractéristiques de plus en plus complexes à chaque couche. La convolution divise la matrice en petits morceaux pour apprendre les éléments les plus essentiels de chaque morceau.
Composants de Convnets
Il y a quatre composants d'un Convnets
- Convolution
- Non linéarité (ReLU)
- Mise en commun ou sous-échantillonnage
- Classification (couche entièrement connectée)
- Convolution
Le but de la convolution est d'extraire localement les caractéristiques de l'objet sur l'image. Cela signifie que le réseau apprendra des modèles spécifiques dans l'image et pourra les reconnaître partout dans l'image.
La convolution est une multiplication élémentaire. Le concept est facile à comprendre. L'ordinateur scanne une partie de l'image, généralement avec une dimension de 3x3 et la multiplie en un filtre. La sortie de la multiplication par élément est appelée une carte de caractéristiques. Cette étape est répétée jusqu'à ce que toute l'image soit numérisée. Notez qu'après la convolution, la taille de l'image est réduite.
Ci-dessous, il y a une URL pour voir en action comment fonctionne la convolution.
Il existe de nombreuses chaînes disponibles. Ci-dessous, nous avons répertorié certaines des chaînes. Vous pouvez voir que chaque filtre a un objectif spécifique. Remarque, dans l'image ci-dessous; le noyau est synonyme du filtre.
La source
Arithmétique derrière la convolution
La phase convolutive appliquera le filtre sur un petit tableau de pixels dans l'image. Le filtre se déplacera le long de l'image d'entrée avec une forme générale de 3x3 ou 5x5. Cela signifie que le réseau fera glisser ces fenêtres sur toute l'image d'entrée et calculera la convolution. L'image ci-dessous montre comment la convolution fonctionne. La taille du patch est de 3x3 et la matrice de sortie est le résultat de l'opération élément par élément entre la matrice d'image et le filtre.
La source
Vous remarquez que la largeur et la hauteur de la sortie peuvent être différentes de la largeur et de la hauteur de l'entrée. Cela se produit à cause de l'effet de frontière.
Effet de bordure
L'image a une carte des caractéristiques 5x5 et un filtre 3x3. Il n'y a qu'une seule fenêtre au centre où le filtre peut filtrer une grille 3x3. La carte des entités en sortie sera réduite de deux tuiles avec une dimension 3x3.
Pour obtenir la même dimension de sortie que la dimension d'entrée, vous devez ajouter un remplissage. Le remplissage consiste à ajouter le bon nombre de lignes et de colonnes de chaque côté de la matrice. Cela permettra à la convolution de s'ajuster au centre de chaque tuile d'entrée. Dans l'image ci-dessous, la matrice d'entrée / sortie a la même dimension 5x5
Lorsque vous définissez le réseau, les entités convoluées sont contrôlées par trois paramètres:
- Profondeur: il définit le nombre de filtres à appliquer lors de la convolution. Dans l'exemple précédent, vous avez vu une profondeur de 1, ce qui signifie qu'un seul filtre est utilisé. Dans la plupart des cas, il existe plusieurs filtres. L'image ci-dessous montre les opérations effectuées dans une situation avec trois filtres
- Stride: Il définit le nombre de "sauts de pixels" entre deux tranches. Si la foulée est égale à 1, les fenêtres se déplaceront avec un écart de pixel d'un. Si la foulée est égale à deux, les fenêtres sauteront de 2 pixels. Si vous augmentez la foulée, vous aurez des cartes de caractéristiques plus petites.
Exemple de foulée 1
Foulée d'image 2
- Zéro-remplissage: un remplissage est une opération d'ajout d'un nombre correspondant de lignes et de colonnes de chaque côté des cartes d'entités en entrée. Dans ce cas, la sortie a la même dimension que l'entrée.
- Non linéarité (ReLU)
A la fin de l'opération de convolution, la sortie est soumise à une fonction d'activation pour permettre la non-linéarité. La fonction d'activation habituelle pour convnet est le Relu. Tous les pixels avec une valeur négative seront remplacés par zéro.
- Opération de mise en commun maximale
Cette étape est facile à comprendre. Le but de la mise en commun est de réduire la dimensionnalité de l'image d'entrée. Les étapes sont effectuées pour réduire la complexité de calcul de l'opération. En diminuant la dimensionnalité, le réseau a des poids inférieurs à calculer, ce qui évite le surajustement.
Dans cette étape, vous devez définir la taille et la foulée. Une manière standard de regrouper l'image d'entrée consiste à utiliser la valeur maximale de la carte des caractéristiques. Regardez l'image ci-dessous. La "mise en commun" affichera une quatre sous-matrice de la carte des caractéristiques 4x4 et retournera la valeur maximale. Le regroupement prend la valeur maximale d'un tableau 2x2 et déplace ensuite cette fenêtre de deux pixels. Par exemple, la première sous-matrice est [3,1,3,2], la mise en commun renverra le maximum, qui est de 3.
Il existe une autre opération de mise en commun telle que la moyenne.
Cette opération réduit de manière agressive la taille de la carte des caractéristiques
- Couches entièrement connectées
La dernière étape consiste à créer un réseau de neurones artificiels traditionnel comme vous l'avez fait dans le didacticiel précédent. Vous connectez tous les neurones de la couche précédente à la couche suivante. Vous utilisez une fonction d'activation softmax pour classer le nombre sur l'image d'entrée.
Résumer:
Le réseau de neurones convolutifs compile différentes couches avant de faire une prédiction. Un réseau de neurones a:
- Une couche convolutive
- Fonction d'activation Relu
- Couche de mise en commun
- Couche densément connectée
Les couches convolutives appliquent différents filtres sur une sous-région de l'image. La fonction d'activation Relu ajoute la non-linéarité et les couches de regroupement réduisent la dimensionnalité des cartes d'entités.
Toutes ces couches extraient les informations essentielles des images. Enfin, la carte des caractéristiques est transmise à une couche principale entièrement connectée avec une fonction softmax pour effectuer une prédiction.
Entraînez CNN avec TensorFlow
Maintenant que vous êtes familiarisé avec le bloc de construction d'un convnets, vous êtes prêt à en créer un avec TensorFlow. Nous utiliserons le jeu de données MNIST pour la classification des images.
La préparation des données est la même que dans le didacticiel précédent. Vous pouvez exécuter les codes et passer directement à l'architecture du CNN.
Vous suivrez les étapes ci-dessous:
Étape 1: télécharger l'ensemble de données
Étape 2: couche d'entrée
Étape 3: couche convolutionnelle
Étape 4: couche de mise en commun
Étape 5: Deuxième couche convolutionnelle et couche de regroupement
Étape 6: couche dense
Étape 7: couche Logit
Étape 1: télécharger l'ensemble de données
L'ensemble de données MNIST est disponible avec scikit pour apprendre à cette URL. Veuillez le télécharger et le stocker dans Téléchargements. Vous pouvez le télécharger avec fetch_mldata ('MNIST original').
Créer un train / ensemble de test
Vous devez diviser l'ensemble de données avec train_test_split
Mettre à l'échelle les fonctionnalités
Enfin, vous pouvez mettre à l'échelle la fonctionnalité avec MinMaxScaler
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)y_train = y_train.astype(int)y_test = y_test.astype(int)batch_size =len(X_train)print(X_train.shape, y_train.shape,y_test.shape )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_test_scaled = scaler.fit_transform(X_test.astype(np.float64))feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]X_train_scaled.shape[1:]
Définir le CNN
Un CNN utilise des filtres sur le pixel brut d'une image pour apprendre le modèle de détails par rapport au modèle global avec un réseau neuronal traditionnel. Pour construire un CNN, vous devez définir:
- Une couche convolutive: appliquez n nombre de filtres à la carte d'entités. Après la convolution, vous devez utiliser une fonction d'activation Relu pour ajouter une non-linéarité au réseau.
- Couche de regroupement: l'étape suivante après la convolution consiste à sous-échantillonner la fonction max. Le but est de réduire la dimensionnalité de la carte des caractéristiques pour éviter le surajustement et améliorer la vitesse de calcul. La mise en commun maximale est la technique conventionnelle, qui divise les cartes d'entités en sous-régions (généralement avec une taille 2x2) et ne conserve que les valeurs maximales.
- Couches entièrement connectées: tous les neurones des couches précédentes sont connectés aux couches suivantes. Le CNN classera l'étiquette en fonction des caractéristiques des couches convolutives et réduites avec la couche de regroupement.
Architecture CNN
- Couche convolutive: applique 14 filtres 5x5 (extraction de sous-régions 5x5 pixels), avec fonction d'activation ReLU
- Couche de mise en commun: effectue une mise en commun maximale avec un filtre 2x2 et une foulée de 2 (qui spécifie que les régions regroupées ne se chevauchent pas)
- Couche convolutive: applique 36 filtres 5x5, avec fonction d'activation ReLU
- Pooling Layer # 2: Encore une fois, effectue une mise en commun maximale avec un filtre 2x2 et une foulée de 2
- 1764 neurones, avec un taux de régularisation d'abandon de 0,4 (probabilité de 0,4 qu'un élément donné soit abandonné pendant l'entraînement)
- Couche dense (couche logits): 10 neurones, un pour chaque classe cible de chiffres (0-9).
Il existe trois modules importants à utiliser pour créer un CNN:
- conv2d (). Construit une couche convolutive bidimensionnelle avec le nombre de filtres, la taille du noyau de filtre, le remplissage et la fonction d'activation comme arguments.
- max_ Covoiturage2d (). Construit une couche de pooling bidimensionnelle à l'aide de l'algorithme de pooling max.
- dense(). Construit une couche dense avec les couches et les unités cachées
Vous allez définir une fonction pour construire le CNN. Voyons en détail comment construire chaque bloc de construction avant de tout encapsuler dans la fonction.
Étape 2: couche d'entrée
def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Vous devez définir un tenseur avec la forme des données. Pour cela, vous pouvez utiliser le module tf.reshape. Dans ce module, vous devez déclarer le tenseur à remodeler et la forme du tenseur. Le premier argument concerne les caractéristiques des données, qui sont définies dans l'argument de la fonction.
Une image a une hauteur, une largeur et un canal. Le jeu de données MNIST est une image monochronique de taille 28x28. Nous définissons la taille du lot à -1 dans l'argument de forme afin qu'il prenne la forme des entités ["x"]. L'avantage est de rendre les hyperparamètres de taille de lot à régler. Si la taille du lot est définie sur 7, le tenseur fournira 5 488 valeurs (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
La première couche convolutive a 14 filtres avec une taille de noyau de 5x5 avec le même rembourrage. Le même remplissage signifie que le tenseur de sortie et le tenseur d'entrée doivent avoir la même hauteur et la même largeur. Tensorflow ajoutera des zéros aux lignes et aux colonnes pour garantir la même taille.
Vous utilisez la fonction d'activation Relu. La taille de sortie sera [28, 28, 14].
Étape 4: couche de mise en commun
La prochaine étape après la convolution est le calcul de mise en commun. Le calcul de mise en commun réduira la dimensionnalité des données. Vous pouvez utiliser le module max_ Covoiturage2d avec une taille de 2x2 et une foulée de 2. Vous utilisez la couche précédente comme entrée. La taille de sortie sera [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Étape 5: Deuxième couche convolutionnelle et couche de regroupement
La deuxième couche convolutive a 32 filtres, avec une taille de sortie de [batch_size, 14, 14, 32]. La couche de regroupement a la même taille qu'avant et la forme de sortie est [batch_size, 14, 14, 18].
conv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
Étape 6: couche dense
Ensuite, vous devez définir la couche entièrement connectée. La carte des caractéristiques doit être aplatie avant d'être connectée à la couche dense. Vous pouvez utiliser le module remodeler avec une taille de 7 * 7 * 36.
La couche dense reliera 1764 neurones. Vous ajoutez une fonction d'activation Relu. De plus, vous ajoutez un terme de régularisation d'abandon avec un taux de 0,3, ce qui signifie que 30 pour cent des poids seront mis à 0. Notez que l'abandon n'a lieu que pendant la phase d'entraînement. La fonction cnn_model_fn a un mode argument pour déclarer si le modèle doit être entraîné ou évalué.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Étape 7: couche Logit
Enfin, vous pouvez définir la dernière couche avec la prédiction du modèle. La forme de sortie est égale à la taille du lot et 10, le nombre total d'images.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Vous pouvez créer un dictionnaire contenant les classes et la probabilité de chaque classe. Le module tf.argmax () avec renvoie la valeur la plus élevée si les couches logit. La fonction softmax renvoie la probabilité de chaque classe.
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
Vous ne souhaitez renvoyer la prédiction du dictionnaire que lorsque le mode est défini sur prédiction. Vous ajoutez ces codes pour afficher les prédictions
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
L'étape suivante consiste à calculer la perte du modèle. Dans le dernier didacticiel, vous avez appris que la fonction de perte pour un modèle multiclasse est l'entropie croisée. La perte est facilement calculée avec le code suivant:
# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
La dernière étape consiste à optimiser le modèle, c'est-à-dire à trouver les meilleures valeurs des poids. Pour cela, vous utilisez un optimiseur de descente de gradient avec un taux d'apprentissage de 0,001. L'objectif est de minimiser la perte
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Vous avez terminé avec le CNN. Cependant, vous souhaitez afficher les mesures de performances pendant le mode d'évaluation. Les mesures de performance pour un modèle multiclasse sont les mesures de précision. Tensorflow est équipé d'un module de précision avec deux arguments, les libellés et les valeurs prédites.
eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
C'est tout. Vous avez créé votre premier CNN et vous êtes prêt à tout envelopper dans une fonction afin de l'utiliser pour entraîner et évaluer le modèle.
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)# Dense Layerpool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)predictions = {# Generate predictions (for PREDICT and EVAL mode)"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor")}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)# Calculate Lossloss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)# Configure the Training Op (for TRAIN mode)if mode == tf.estimator.ModeKeys.TRAIN:optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)# Add evaluation metrics Evaluation modeeval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Les étapes ci-dessous sont les mêmes que celles des didacticiels précédents.
Tout d'abord, vous définissez un estimateur avec le modèle CNN.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
Un CNN prend plusieurs fois à s'entraîner, par conséquent, vous créez un hook Logging pour stocker les valeurs des couches softmax toutes les 50 itérations.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Vous êtes prêt à estimer le modèle. Vous définissez une taille de lot de 100 et mélangez les données. Notez que nous avons défini des étapes d'entraînement de 16.000, cela peut prendre beaucoup de temps pour s'entraîner. Sois patient.
# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_train_scaled},y=y_train,batch_size=100,num_epochs=None,shuffle=True)mnist_classifier.train(input_fn=train_input_fn,steps=16000,hooks=[logging_hook])
Maintenant que le modèle est train, vous pouvez l'évaluer et imprimer les résultats
# Evaluate the model and print resultseval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_test_scaled},y=y_test,num_epochs=1,shuffle=False)eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)print(eval_results)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}
Avec l'architecture actuelle, vous obtenez une précision de 97%. Vous pouvez modifier l'architecture, la taille du lot et le nombre d'itérations pour améliorer la précision. Le réseau de neurones CNN a bien mieux fonctionné que l'ANN ou la régression logistique. Dans le tutoriel sur le réseau de neurones artificiels, vous aviez une précision de 96%, ce qui est inférieur au CNN. Les performances du CNN sont impressionnantes avec une image plus grande série , à la fois en terme de calcul de la vitesse et la précision.
Résumé
Un réseau de neurones convolutifs fonctionne très bien pour évaluer l'image. Ce type d'architecture est dominant pour reconnaître des objets à partir d'une image ou d'une vidéo.
Pour créer un CNN, vous devez suivre six étapes:
Étape 1: couche d'entrée:
Cette étape remodèle les données. La forme est égale à la racine carrée du nombre de pixels. Par exemple, si une image a 156 pixels, alors la forme est 26x26. Vous devez spécifier si l'image est colorée ou non. Si oui, alors vous aviez 3 à la forme - 3 pour RVB-, sinon 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Étape 2: couche convolutionnelle
Ensuite, vous devez créer les couches convolutives. Vous appliquez différents filtres pour permettre au réseau d'apprendre des fonctionnalités importantes. Vous spécifiez la taille du noyau et la quantité de filtres.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Étape 3: couche de mise en commun
Dans la troisième étape, vous ajoutez une couche de regroupement. Cette couche diminue la taille de l'entrée. Pour ce faire, il prend la valeur maximale de la sous-matrice a. Par exemple, si la sous-matrice est [3,1,3,2], la mise en commun renverra le maximum, qui est 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Étape 4: Ajouter une couche convolutionnelle et une couche de regroupement
Dans cette étape, vous pouvez ajouter autant que vous le souhaitez des couches de convection et des couches de regroupement. Google utilise une architecture avec plus de 20 couches de conv.
Étape 5: couche dense
L'étape 5 aplatir la précédente pour créer des couches entièrement connectées. Dans cette étape, vous pouvez utiliser différentes fonctions d'activation et ajouter un effet d'abandon.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Étape 6: couche Logit
La dernière étape est la prédiction.
logits = tf.layers.dense(inputs=dropout, units=10)