Exemples d'applications pratiques de la combinaison de fonctionnalités peu profondes et de fonctionnalités profondes

L'apprentissage en profondeur a connu un grand succès dans le domaine de la vision par ordinateur, et l'une des avancées importantes est l'utilisation de réseaux de neurones convolutifs profonds (CNN) pour la classification d'images. Cependant, les CNN profonds nécessitent généralement de grandes quantités de données étiquetées et de ressources informatiques. Afin de réduire la demande en ressources informatiques et en données étiquetées, les chercheurs ont commencé à étudier comment fusionner des caractéristiques superficielles et des caractéristiques profondes pour améliorer les performances de classification des images. Cette méthode de fusion peut tirer parti de la grande efficacité de calcul des entités superficielles et de la forte capacité de représentation des entités profondes. En combinant les deux, les coûts de calcul et les exigences d’étiquetage des données peuvent être réduits tout en conservant une grande précision de classification. Cette méthode est particulièrement importante pour les scénarios d’application dans lesquels la quantité de données est faible ou les ressources informatiques limitées. Grâce à une étude approfondie de la méthode de fusion des caractéristiques peu profondes et des caractéristiques profondes, nous pouvons améliorer encore les performances des algorithmes de classification d'images et apporter davantage de percées dans la recherche et les applications dans le domaine de la vision par ordinateur.

Une méthode courante consiste à utiliser des modèles CNN en cascade. Le premier modèle CNN est utilisé pour extraire des caractéristiques superficielles, le deuxième modèle CNN est utilisé pour extraire des caractéristiques profondes, et enfin les sorties des deux modèles sont connectées pour améliorer la qualité. précision des résultats de la classification.

Ceci est un exemple d'utilisation d'un modèle CNN en cascade pour reconnaître des chiffres manuscrits. Le modèle utilise l'ensemble de données MNIST, qui comprend 60 000 images d'entraînement et 10 000 images de test, chaque taille d'image étant de 28 × 28 pixels.

Tout d'abord, nous définissons l'architecture du modèle. Nous utilisons deux modèles CNN pour extraire les fonctionnalités. Le premier modèle CNN contient deux couches convolutives et une couche de pooling maximale pour extraire les entités peu profondes. Le deuxième modèle CNN contient trois couches convolutives et une couche de pooling maximale pour extraire des fonctionnalités profondes. Ensuite, nous concaténons les sorties des deux modèles et ajoutons deux couches entièrement connectées pour la classification. Une telle architecture peut extraire des fonctionnalités riches et effectuer de meilleures tâches de classification.

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Concatenate

# Define shallow CNN model
shallow_input = Input(shape=(28, 28, 1))
shallow_conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(shallow_input)
shallow_pool1 = MaxPooling2D((2, 2))(shallow_conv1)
shallow_conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(shallow_pool1)
shallow_pool2 = MaxPooling2D((2, 2))(shallow_conv2)
shallow_flat = Flatten()(shallow_pool2)
shallow_output = Dense(128, activation='relu')(shallow_flat)

# Define deep CNN model
deep_input = Input(shape=(28, 28, 1))
deep_conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(deep_input)
deep_pool1 = MaxPooling2D((2, 2))(deep_conv1)
deep_conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(deep_pool1)
deep_pool2 = MaxPooling2D((2, 2))(deep_conv2)
deep_conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(deep_pool2)
deep_pool3 = MaxPooling2D((2, 2))(deep_conv3)
deep_flat = Flatten()(deep_pool3)
deep_output = Dense(256, activation='relu')(deep_flat)

# Concatenate shallow and deep models
concatenate = Concatenate()([shallow_output, deep_output])
output = Dense(10, activation='softmax')(concatenate)

# Define the model
model = tf.keras.Model(inputs=[shallow_input, deep_input], outputs=output)

Le modèle est ensuite compilé et entraîné. Étant donné que l'ensemble de données MNIST est un problème de classification multi-classes, la fonction de perte d'entropie croisée et l'optimiseur Adam sont utilisés pour compiler le modèle. Le modèle est formé sur l'ensemble de formation pour 100 époques, en utilisant 128 lots pour chaque époque.

# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train the model
model.fit([x_train, x_train], y_train, batch_size=128, epochs=100, verbose=1, validation_data=([x_test, x_test], y_test))

Enfin, évaluez les performances du modèle sur l'ensemble de test. Dans cet exemple, la précision du test du modèle CNN en cascade est de 99,2 %, soit environ 0,5 % de plus que la précision du test entraîné avec un seul modèle CNN, ce qui indique que la fusion de caractéristiques superficielles et de caractéristiques profondes peut en effet améliorer les performances de l'image. classification.

En bref, la fusion de caractéristiques superficielles et de caractéristiques profondes est une méthode efficace pour améliorer les performances de classification d'images. Cet exemple montre comment utiliser des modèles CNN en cascade pour reconnaître des chiffres manuscrits, où le premier modèle CNN extrait les caractéristiques superficielles, le deuxième modèle CNN extrait les caractéristiques profondes, puis les sorties des deux modèles sont concaténées pour la classification. Cette méthode est également largement utilisée dans de nombreuses autres tâches de classification d’images.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!