l'apprentissage en profondeur devient rapidement un outil essentiel des applications d'intelligence artificielle. Par exemple, dans la vision informatique, traitement du langage naturel et la reconnaissance vocale et d'autres domaines, l'apprentissage en profondeur a accompli des réalisations remarquables. Par conséquent, la profondeur d'intérêt pour l'apprentissage de plus en plus intense.
Une étude en profondeur le problème le plus important est la classification d'image. Une image de la classification est de classer les images en fonction des catégories spécifiques de potentiel. Un exemple classique de classification d'image est d'identifier un ensemble d'images chez les chats et les chiens.
Du point de vue de l'apprentissage en profondeur de vue, problème de classification des images peut être résolu par l'étude des migrations. En fait, plusieurs des derniers résultats de la recherche dans la classification des images sont basées sur des programmes d'apprentissage de transfert dérivé.
Cet article décrit comment mettre en uvre des solutions d'apprentissage migrent dans les problèmes de classification des images. Sur la base des modes de réalisation fournis ici en utilisant le langage de programmation Python Keras (2015 CHOLLET). En mettant en uvre ce programme, vous serez en mesure de résoudre tous les problèmes rapidement et facilement la classification d'images.
1. L'apprentissage de transfert
2. réseau de neurones convolutionnel
3. réutilisation modèle de pré-formation
4. Transfert processus d'apprentissage
5. La profondeur du classifieur neuronal convolutif sur le réseau
6. Exemples
7. Résumé
l'apprentissage de transfert est l'apprentissage vision par ordinateur d'un populaire, par l'apprentissage de transfert, nous pouvons construire un modèle précis sur la base du gain de temps. Lors de la migration d'apprendre, vous pouvez rencontrer un modèle connu différent de résolution de problèmes a commencé à apprendre sans avoir besoin de repartir à zéro. De cette façon, vous pouvez utiliser les connaissances acquises précédemment, afin d'éviter à partir de zéro. Transfert apprentissage Chartres ladite version considéré étude approfondie de « debout sur les épaules de géants » de.
Dans la vision informatique, l'apprentissage de transfert est habituellement réalisée grâce à l'utilisation du modèle de pré-formation. modèle de pré-formation fait référence aux problèmes sur les grands ensembles de données pour résoudre la formation du modèle de référence, et un problème de problèmes similaires pour la formation et nous voulons vraiment résoudre. En raison de la faible formation de tels modèles de calcul et coût de calcul, les applications les plus courantes consiste à importer et à l'utilisation de ces modèles dans la littérature publiée.
Plusieurs modèle de pré-formation pour l'étude de la migration sont basées sur le réseau de neurones convolutionnel à grande échelle (CNN) est. Dans l'ensemble, CNN dans diverses tâches de vision par ordinateur des performances exceptionnelles. Avec sa haute performance et la facilité de formation sont les deux principaux facteurs de ces dernières années, le populaire CNN.
Un CNN type se compose de deux parties:
1. La convolution du substrat, l'empilement de couches et la convolution des couches de cellules. Le but principal est de générer un groupe de convolution d'une fonction d'image.
2. classificateurs, se compose généralement d'une couche connectée complètement. Le rôle principal du classificateur est classé en fonction de la détection de caractéristiques d'image. La couche se réfère à toutes les couches entièrement connectées les neurones activent dans la couche précédente entièrement connecté.
. La figure 1 est un modèle de structure sur la base du CNN. Notez que ceci est une version simplifiée, il répond à l'objectif de cet article. Dans la pratique, ce type de structure du modèle que nous avons énumérés ici est plus compliquée.
Une caractéristique importante de ces modèles est la profondeur de l'apprentissage qu'ils peuvent apprendre automatiquement la représentation hiérarchique. Cela signifie que la caractéristique calculée par la première couche est générique et peut être utilisée à nouveau dans un domaine de problème différent, calculé par la couche finale, dans laquelle spécifique, et dépend de l'ensemble de données et la tâche sélectionnée. Certains experts croient :. « Si la première couche est une caractéristique commune, et la dernière est une fonction particulière, quelque part dans le réseau doit être caractérisé par le passage du général aux caractéristiques spécifiques de »
Ainsi, les groupes convolution CNN, en particulier sa couche inférieure (plus proche de la couche d'entrée), se réfère à la caractéristique générale, l'article classé, et une certaine couche supérieure du groupe de convolution CNN se réfère à une caractéristique particulière.
Lorsque vous réutilisez modèle pré-formation en fonction de vos besoins, vous devez d'abord supprimer la classification d'origine, puis ajouter une nouvelle classification en fonction de vos besoins, et enfin avoir à affiner le modèle selon l'une des trois stratégies suivantes:
1. formation de l'ensemble du modèle. Dans ce cas, vous devez utiliser le modèle d'architecture de pré-formation et la formation en fonction de vos données les définir. Parce que vous apprendrez le modèle à partir de zéro, vous avez donc besoin d'un grand ensemble de données (et beaucoup de puissance de calcul).
2. couche partielle de formation, d'autres couches restent congelés. Comme mentionné précédemment, la couche inférieure se réfère aux caractéristiques générales (indépendamment du problème), mais un niveau plus élevé se réfère à une caractéristique particulière (et questions connexes). Ici, nous devons adapter le réseau en poids (couches congelées ne changent pas pendant la formation) pour réaliser cette dichotomie. Habituellement, si vous avez un petit ensemble de données et un grand nombre de paramètres, vous devez laisser plus de la couche gelée afin d'éviter surajustement. A l'inverse, si l'ensemble de données est grande, un petit nombre de paramètres, vous pouvez couche en mission de formation plus nouvelle pour améliorer le modèle, parce que ce cas ne semble pas trop ajusté.
3. Gel à convolution. Cette situation est un cas extrême de la formation ou congelés pèsent compromis, respectivement. L'idée principale est de maintenir sa forme de base convolutionnel d'origine, puis fournit sa sortie au classificateur. Lorsque vous mécanisme d'extraction de modèle de pré-formation comme un élément fixe, si vous manque la puissance de calcul, l'ensemble de données est faible, et / ou d'un modèle pré-formation pour résoudre le problème que vous voulez résoudre, cette méthode est utile.
La figure 2 est un organigramme des trois stratégies:
3 diffère de l'opération de la stratégie directe, en utilisant des tactiques et des stratégies 2:001, vous devez faire attention au taux d'apprentissage utilisé dans la section de convolution. Est un paramètre de vitesse d'apprentissage super qui contrôle le degré vous réglez les poids du réseau. Lorsque vous utilisez un modèle de pré-formation basée sur CNN, il est préférable de maintenir un faible taux d'apprentissage, en raison du taux élevé d'apprentissage augmente le risque de perte de connaissances déjà acquises. modèle de pré-formation suppose que, après une bonne formation (cette hypothèse est tout à fait raisonnable), le maintien d'un faible taux d'apprentissage vous permettra de ne pas prématurément et le poids CNN trop tordu.
D'un point de vue pratique, l'ensemble du processus de migration peut se résumer comme suit:
1. Sélectionnez un modèle de pré-formation. Vous pouvez choisir un modèle adapté à votre disposition à partir d'une variété de modèle de pré-formation. Par exemple, si vous utilisez Keras, vous pouvez accéder comme VGG, InceptionV3 et ResNet5 ces modèles immédiatement.
La taille - à la matrice Classifier des problèmes. Figure 3 « matrice » affecte votre choix. Cette matrice de classer les problèmes de vision par ordinateur de similarité et la taille de l'ensemble de données et l'ensemble des données de formation est un modèle pré-formation utilisé dans le. La règle générale, si un ensemble de données pour chaque classe dans l'image inférieure à 1000, on considère que l'ensemble de données est faible. Et similitude peut être jugée en fonction de la connaissance de l'ensemble de données. Par exemple, si votre tâche est d'identifier les chats et les chiens, la IMAGEnet est un ensemble similaire de données, car elle reconnaît l'image des chats et des chiens. Toutefois, si votre tâche est d'identifier les cellules cancéreuses, il ne peut pas être considéré comme IMAGEnet ensembles de données similaires.
3. affiner le modèle. Ici, vous pouvez utiliser la taille - une sélection assistée par matrice de similarité, et les trois options référence sur le modèle pré-formation réutilisation mentionnées plus haut. La figure 4 est un résumé du texte de l'image.
quadrant 1: de grands ensembles de données, mais avec le modèle de pré-formation des différents ensembles de données. Dans ce cas, la nécessité d'une politique 1. Puisque vous avez un grand nombre de données, afin que vous puissiez commencer à partir du modèle de formation de zéro, et faire tout ce que vous voulez. Bien que les ensembles de données varient, mais dans la pratique, grâce à l'utilisation de l'architecture et poids méthode d'initialisation d'un modèle de pré-formation est toujours utile.
quadrant 2 : Les grands ensembles de données et ensemble de données similaire au modèle de pré-formation. Toutes les options sont disponibles à ce moment, mais probablement la stratégie la plus efficace est de sélectionner 2. En raison des grandes quantités de données, et ne seront donc pas surajustement, donc nous voulons savoir combien l'école. Cependant, parce que l'ensemble de données est similaire, nous pouvons économiser beaucoup d'PROFITEZ de travail des connaissances antérieures. Par conséquent, nous ne devons former classificateur de niveau supérieur et assez à convolution.
quadrant 3 : Données et petit ensemble l'ensemble de données est différent du modèle de pré-formation. Ces ensembles de données vont inévitablement conduire à des problèmes de vision par ordinateur. Tout est contre vous. A ce stade, il n'y a pas d'utilisation se plaindre, le seul espoir est de choisir la stratégie 2. Il est difficile d'équilibrer le besoin de formation et des couches glacées. Si vous regardez trop profond, votre modèle pourrait être phénomène surajustement, si vous restez dans le modèle peu profond, vous avez pas apprendre quelque chose d'utile. Peut-être, par rapport au quadrant 2, vous avez besoin d'aller plus loin et nécessitent l'utilisation de la technologie d'amélioration des données.
quadrant 4 : Les petits ensembles de données, mais l'ensemble de données est similaire au modèle pré-formation. Quand j'ai demandé Yoda voir sur ce point, et il m'a dit: « Pour ce type de collecte de données, la politique 3 est le meilleur choix. » Bien que je ne le connaissais pas, mais je ne vais pas le sous-estimer, « force ». , J'ai choisi Donc Stratégie 3. Il vous suffit de retirer la dernière couche connectée complètement (couche de sortie), comme modèle de formation fixe pré-extracteur de caractéristiques en cours d'exécution, et une fonction précédemment obtenu pour former de nouveaux classificateur.
Les figures 3 et 4 taille - matrice de similarité (à gauche) et un diagramme de décision de rognage modèle de pré-formé (à droite)
Comme décrit ci-dessus, le modèle de classification d'image généré sur la base d'un réseau neuronal pré-entraîné migration apprentissage convolutif se compose généralement de deux parties:
1. Groupe de convolution pour effectuer une extraction de caractéristiques.
2. La classification en fonction de la caractéristique de l'extrait à base de convolution classer l'image d'entrée.
Etant donné que dans cette section, nous nous concentrons sur la section de classification, donc d'abord il faut expliquer Il y a plusieurs façons de construire un classificateur, les plus courantes sont:
Une couche entièrement connecté. Le processus de classification de l'image, la meilleure méthode consiste à utiliser une couche d'empilement entièrement connecté, puis avec Softmax couche active. distribution de probabilité de sortie de la couche softmax sur chaque étiquette de classe possible, et nous avons juste besoin de classer les images en fonction de la classe la plus probable.
2. La moyenne mondiale mis en commun. Quelqu'un a proposé une méthode basée sur Pooled moyenne mondiale. En utilisant cette approche, on n'a pas besoin d'ajouter convolution entièrement sur la couche connectée la base, mais ajouter la couche cellulaire moyenne mondiale et sorties SOFTMAX alimenté directement à la couche active.
3. Machine à vecteurs de support linéaire. machine à vecteurs de support linéaire (SVM) est une autre méthode qui peut être utilisée pour construire le classificateur. Nous pouvons améliorer la précision de la classification à classer par la formation du SVM linéaire caractéristique de l'extrait à base de convolution. Cet article détailler les avantages et les inconvénients de la méthode SVM.
Dans cet exemple, nous allons explorer comment migrer chaque classificateur utilisé dans les solutions d'apprentissage de classification des images. « Comparer les performances des différents classificateurs ont besoin encore une étude plus dans le réseau de neurones de convolution de profondeur pour former une direction de recherche intéressante. » Par conséquent, observer chaque performance classificateur problèmes de classification des images standard sera très intéressant.
6.1 Préparer les donnéesDans cet exemple, nous utiliserons une version plus petite de l'ensemble de données d'origine. Cela nous aidera à exécuter le modèle plus rapide, et pour le calcul de la capacité limitée des personnes (comme moi), il est une bonne chose.
Pour construire une version plus petite d'un ensemble de données, nous pouvons nous adapter au code précédent, comme le code 1 indiqué dans:
# Créer plus petit ensemble de données pour chiens contre des chats
import os, shutil
original_dataset_dir = '/ Users / macbook / dogs_cats_dataset / train /'
base_dir = '/ Users / macbook / livre / dogs_cats / data'
sinon os.path.exists (Base_dir):
os.mkdir (base_dir)
# Créer des répertoires
train_dir = os.path.join (base_dir, 'train')
sinon os.path.exists (train_dir):
os.mkdir (train_dir)
validation_dir = os.path.join (base_dir, 'validation')
sinon os.path.exists (validation_dir):
os.mkdir (validation_dir)
test_dir = os.path.join (base_dir, 'test')
sinon os.path.exists (test_dir):
os.mkdir (test_dir)
train_cats_dir = os.path.join (train_dir, 'chats')
sinon os.path.exists (train_cats_dir):
os.mkdir (train_cats_dir)
train_dogs_dir = os.path.join (train_dir, 'chiens')
sinon os.path.exists (train_dogs_dir):
os.mkdir (train_dogs_dir)
validation_cats_dir = os.path.join (validation_dir, 'chats')
sinon os.path.exists (validation_cats_dir):
os.mkdir (validation_cats_dir)
validation_dogs_dir = os.path.join (validation_dir, 'chiens')
sinon os.path.exists (validation_dogs_dir):
os.mkdir (validation_dogs_dir)
test_cats_dir = os.path.join (test_dir, 'chats')
sinon os.path.exists (test_cats_dir):
os.mkdir (test_cats_dir)
test_dogs_dir = os.path.join (test_dir, 'chiens')
sinon os.path.exists (test_dogs_dir):
os.mkdir (test_dogs_dir)
# Copie 1000 premières images de chat à train_cats_dir
fnames =
pour FNAME en fnames:
src = os.path.join (original_dataset_dir, fname)
dst = os.path.join (train_cats_dir, fname)
shutil.copyfile (src, dst)
# Copier suivant 500 images de chat à validation_cats_dir
fnames =
pour FNAME en fnames:
src = os.path.join (original_dataset_dir, fname)
dst = os.path.join (validation_cats_dir, fname)
shutil.copyfile (src, dst)
# Copier suivant 500 images de chat à test_cats_dir
fnames =
pour FNAME en fnames:
src = os.path.join (original_dataset_dir, fname)
dst = os.path.join (test_cats_dir, fname)
shutil.copyfile (src, dst)
# Copie 1000 premiers images de chiens à train_dogs_dir
fnames =
pour FNAME en fnames:
src = os.path.join (original_dataset_dir, fname)
dst = os.path.join (train_dogs_dir, fname)
shutil.copyfile (src, dst)
# Copier suivante 500 images chien à validation_dogs_dir
fnames =
pour FNAME en fnames:
src = os.path.join (original_dataset_dir, fname)
dst = os.path.join (validation_dogs_dir, fname)
shutil.copyfile (src, dst)
# Copier suivante 500 images chien à test_dogs_dir
fnames =
pour FNAME en fnames:
src = os.path.join (original_dataset_dir, fname)
dst = os.path.join (test_dogs_dir, fname)
shutil.copyfile (src, dst)
# contrôles de santé d'esprit
print ( 'nombre total d'images de chat de formation:', len (os.listdir (train_cats_dir)))
print ( 'nombre total d'images de chien de formation:', len (os.listdir (train_dogs_dir)))
print ( 'validation totale des images de chat:', len (os.listdir (validation_cats_dir)))
print ( 'nombre total d'images de chien de validation:', len (os.listdir (validation_dogs_dir)))
print ( 'test basé sur les images de chat:', len (os.listdir (test_cats_dir)))
print ( 'nombre total d'images de chien de test:', len (os.listdir (test_dogs_dir)))
Construction d'un petit ensemble de données code 1 pour les chats et les chiens 6.2. Extraits caractéristiques du groupe de convolutiongroupe Convolution pour extraire la fonction. Ces caractéristiques seront entrées en nous voulons former classificateur, donc s'il y a un chien ou un chat, nous reconnaissons l'image.
De même, nous nous adaptons à nouveau le code. Voir les détails Code 2:
# Caractéristiques Extrait
import os, shutil
de ImageDataGenerator d'importation keras.preprocessing.image
DataGen = ImageDataGenerator (remise à l'échelle = 1/255)
batch_size = 32
def extract_features (annuaire, sample_count):
Caractéristiques = np.zeros (= forme (sample_count, 7, 7, 512)) # doit être égale à la sortie de la base de convolution
labels = np.zeros (= forme (sample_count))
# Données Prétraitement
Générateur = datagen.flow_from_directory (annuaire,
target_size = (img_width, img_height),
batch_size = batch_size,
class_mode = 'binaire')
# Données passent par la base convolutionnel
i = 0
pour inputs_batch, labels_batch en générateur:
features_batch = conv_base.predict (inputs_batch)
traits = Features_batch
étiquettes = Labels_batch
i + 1 =
si i * batch_size > = Sample_count:
pause
Fonctions de retour, étiquettes
train_features, train_labels = extract_features (train_dir, train_size) # D'accord avec notre petite taille du jeu de données
validation_features, validation_labels = extract_features (validation_dir, validation_size)
test_features, test_labels = extract_features (test_dir, test_size)
2 codes convolutionnels groupe caractéristique extraite 6.3. Classificateur6.3.1. Couche de connexion complète
La première solution que nous proposons est basée sur une couche connectée complètement. Le classificateur est ajouté un ensemble de couches entièrement connectées, qui assurent l'extraction à partir de la convolution des fonctions de base.
Par souci de simplicité (et rapide), nous utiliserons Chollet (2018) propose des solutions, et le modifier un peu.
3 le code est le code utilisé dans ce mode de réalisation,. La figure 5 et. La figure 6 est une courbe d'apprentissage.
# Définir modèle
des modèles d'importation KERAS
des couches d'importation KERAS
de optimiseurs d'importation KERAS
époques = 100
model = models.Sequential ()
model.add (layers.Flatten (input_shape = (7,7,512)))
model.add (layers.Dense (256, activation = 'Relu', input_dim = (7 * 7 * 512)))
model.add (layers.Dropout (0,5))
model.add (layers.Dense (1, activation = 'sigmoïde'))
model.summary ()
# Compile modèle
model.compile (optimiseur = optimizers.Adam (),
perte = 'binary_crossentropy',
métriques = )
# Modèle de train
histoire = model.fit (train_features, train_labels,
époques = époques,
batch_size = batch_size,
validation_data = (validation_features, validation_labels))
Code 3 de solution de couche entièrement connecté
Un bref aperçu des résultats:
1. Vérifier l'exactitude d'environ 0,85, en tenant compte de la taille de l'ensemble de données, ce résultat est assez bon.
2. Le overfitting modèle. Avec de grands écarts entre la courbe de profil de formation et de validation.
3. Étant donné que nous avons utilisé le niveau d'abandon scolaire, nous devons augmenter la taille de l'ensemble de données afin d'améliorer les résultats.
La moyenne mondiale 6.3.2 Pooling
Le cas précédent, sauf que, nous allons ajouter ici une couche cellulaire moyenne mondiale, et alimente sa sortie à une couche active sigmoïde, au lieu d'ajouter l'ensemble de la pile de la couche de connexion.
Notez que la couche active est sigmoïde plutôt que softmax couche active de notre discussion. Nous avons choisi en fonction d'activation sigmoïde, parce que dans Keras, afin d'effectuer une classification binaire, tout comme la fonction d'activation sigmoïde, binary_crossentropy en fonction de la perte.
Code 4 code est classificateur construit, 7 et 8 sont le résultat de la courbe d'apprentissage.
# Définir modèle
des modèles d'importation KERAS
des couches d'importation KERAS
de optimiseurs d'importation KERAS
époques = 100
model = models.Sequential ()
model.add (layers.GlobalAveragePooling2D (input_shape = (7,7,512)))
model.add (layers.Dense (1, activation = 'sigmoïde'))
model.summary ()
# Compile modèle
model.compile (optimiseur = optimizers.Adam (),
perte = 'binary_crossentropy',
métriques = )
# Modèle de train
histoire = model.fit (train_features, train_labels,
époques = époques,
batch_size = batch_size,
validation_data = (validation_features, validation_labels))
Code 4 Piscine des solutions globales moyennes
Un bref aperçu des résultats:
1. vérifier l'exactitude et la précision du système d'authentification est obtenu par une solution similaire à la couche entièrement connecté.
2. Ce modèle ne semble pas avant l'apparition du phénomène surajustement.
3. Lorsque la formation d'arrêt de modèle, la fonction de perte est toujours en baisse. Peut-être que le modèle peut être améliorée en augmentant le nombre d'époque.
6.3.3. Machine à vecteur de support linéaire
Ici, nous allons former une classification machine à vecteur de support linéaire (SVM) selon la caractéristique de l'extrait à base de convolution.
Pour cette formation, un classificateur, la méthode traditionnelle d'apprentissage de la machine est préférée. Par conséquent, nous utiliserons classificateur d'erreur estimée K- pli validation croisée. Lors de l'utilisation K- fold validation croisée, nous pouvons former et ensembles de validation reliés entre eux pour développer les données de formation (le même que dans le cas précédent, l'ensemble de test pour rester intact). 5 illustre le processus de connexion des données de code.
# formation Concatenate et ensembles de validation
svm_features = np.concatenate ((train_features, validation_features))
svm_labels = np.concatenate ((train_labels, validation_labels))
Code connexion de données 5Enfin, il faut savoir qu'il ya un paramètre de classificateur super-SVM. Ce paramètre ultra est le terme d'erreur du paramètre de pénalité C. Afin d'optimiser le choix des hyper-paramètres, nous allons utiliser une grille de recherche exhaustive. 6 le code est le code utilisé pour construire le classificateur. La figure 9 est une courbe d'apprentissage.
# Modèle Build
importation sklearn
de train_test_split import sklearn.cross_validation
de GridSearchCV d'importation sklearn.grid_search
de LinearSVC import sklearn.svm
X_train, y_train = svm_features.reshape (300,7 * 7 * 512), svm_labels
param =
svm = LinearSVC (pénalité = 'l2', perte = 'squared_hinge') # Comme dans Tang (2013)
NSI = GridSearchCV (SVM, param, cv = 10)
clf.fit (X_train, y_train)
6 codes, la solution de SVM linéaire
Un bref aperçu des résultats:
1. La précision du modèle est de 0,86, similaire aux solutions précédentes.
2. coin du raccord excessif. De plus, la précision de la formation est toujours 1.0, ce qui est commun, peut être considéré comme un signe de plus-raccord.
3. La précision du modèle devrait être augmenté le nombre d'échantillons de formation augmente. Cependant, le fait est pas le cas, il peut être parce que surapprentissage. Lorsque l'augmentation de l'ensemble de données, modèle comment y répondre? Ceci est une question intéressante.
Dans cet article, nous avons:
1. Introduction Le concept d'une étude sur la migration, convolution et pré-formés modèles de réseaux de neurones.
2 Définir les stratégies de réglage fin de base pour ré-ajuster le modèle de pré-formation.
3. Décrire l'ensemble de données en fonction de la taille et la similarité de décider quelle stratégie pour affiner devrait être utilisé une approche structurée.
4. Le haut des listes de classification trois fonctions peuvent être utilisées à partir d'une extraction à base de convolution.
Les trois catégories de ce document cité à titre d'exemple fournissent extrémité libre, respectivement, de la Fig.
