Aidemy 2020/10/3
Bonjour, c'est Yope! Je suis une école littéraire croustillante, mais j'étais intéressé par les possibilités de l'IA, alors je suis allé à l'école spécialisée en IA "Aidemy" pour étudier. Je voudrais partager les connaissances acquises ici avec vous, et je les ai résumées dans Qiita. Je suis très heureux que de nombreuses personnes aient lu l'article de synthèse précédent. Je vous remercie! Ceci est le deuxième message de CNN. Ravi de vous rencontrer.
Quoi apprendre cette fois ・ À propos du remplissage des données (générateur de données d'image) ・ À propos de la normalisation ・ À propos de l'apprentissage par transfert
-En reconnaissance d'image, une grande quantité de combinaison de données d'image et de son étiquette (données de l'enseignant) est nécessaire, mais la collecte d'une grande quantité de données est coûteuse et prend du temps. Par conséquent, afin d'augmenter le nombre de données à une quantité suffisante, image padding est effectué. ・ Gonflez l'image en inversant l'image. (→ Exercices complets pour le nettoyage des données) ・ Cette fois, j'utiliserai ImageDataGenerator de Keras. Les données peuvent être facilement traitées en définissant une valeur appropriée pour cet argument.
-__ Rotation_range__: Plage lorsque rotation aléatoirement (x °) -__ Width_shift_range : Pourcentage d'images lors d'un déplacement aléatoire en parallèle dans le sens horizontal (x% en fractions) - Height_shift_range__: Pourcentage d'images lors d'un déplacement aléatoire en parallèle dans la direction verticale (x% en fractions) ・ Shear_range: __ Degré de cisaillement , plus la valeur est élevée, plus l'image est tirée en diagonale (0 ~ 0,3925) - Zoom_range__: __ Pourcentage de compression et d'agrandissement aléatoires de images. (Limite inférieure 1-x, limite supérieure 1 + x) - Channel_shift_range__: Pour le canal RGB3, chaque valeur de R, V, B change aléatoirement dans la plage de 0 à 255 (changements de couleur) (0 à 255) -__ Horizontal_flip__: Si True, alors retourner au hasard horizontally __ - Vertial_flip__: Si Vrai, alors retourner au hasard __verticalement __
-__ Flow__ est utilisé pour recevoir des données et des étiquettes et générer un lot de données étendues / normalisées, qui seront décrites plus loin. Des opérations spécifiques sont également traitées dans cette section. -Utiliser comme __flow (données, argument) __, et ses arguments seront expliqués ci-dessous. ・ X: Données d'image (4 dimensions) ・ Y: étiquette -Batch_size: taille du lot de données (nombre de données à entrer dans le modèle à la fois → apprentissage en profondeur) ・ Shuffle: mélanger les données (True ouFalse) -Save_to_dir: Spécifiez le répertoire pour enregistrer l'image étendue / normalisée générée (efficace pour la visualisation) -Save_prefix: nom du fichier lors de l'enregistrement -Save_format: Enregistrer le format ("png" ou "jpeg")
-La normalisation consiste à traiter les données selon une certaine règle et à les rendre __facile à utiliser __. -Il existe différentes méthodes de normalisation, et une méthode typique est la "normalisation par lots (BN)". Ces méthodes de normalisation peuvent être largement divisées en __ "standardisation" __ et __ "blanchiment" __. Consultez les sections suivantes pour plus de détails.
-La normalisation est une méthode de normalisation qui rapproche la distribution des données pour chaque entité en définissant la moyenne des entités sur 0 et la variance sur 1. L'image standardisée est moyennée de façon à avoir une couleur grisâtre, mais cela rend les couleurs auparavant discrètes aussi importantes que les autres couleurs, donc elle est masquée. Il sera plus facile de trouver les fonctionnalités dont vous disposez.
-Comme la méthode de standardisation consiste à définir la moyenne sur 0 et la distribution sur 1, définissez respectivement samplewise_center = True et samplewise_std_normalization = True dans les arguments de ImageDataGenerator (). -De plus, il est nécessaire de générer un lot de données en utilisant le flow mentionné ci-dessus. Si vous ne le faites pas, il ne sera pas standardisé. ・ Ce qui suit est la normalisation du CIFER-10 (images de véhicules et d'animaux).
from keras.datasets import cifar10
from keras.preprocessing.image import ImageDataGenerator
#CIFER-Obtenir l'ensemble de données de 10
(X_train,y_train),(X_test,y_test)=cifar10.load_data()
#Génération de générateur standardisé
datagen= ImageDataGenerator(samplewise_center=True,samplewise_std_normalization=True)
#Standardisé avec débit
g=datagen.flow(X_train, y_train, shuffle=False)
X_batch,y_batch=g.next()
-Le blanchiment est une méthode de normalisation qui élimine la corrélation entre les caractéristiques. ・ Lors du blanchiment, les données s'assombrissent et le contour est accentué, mais ce faisant, le temps d'apprentissage alloué à l'arrière-plan avec une petite quantité d'informations est réduit et le temps d'apprentissage alloué au contour (de l'objet) avec une grande quantité d'informations __ À mesure qu'il augmente __, l'efficacité de l'apprentissage s'améliorera.
-Pour la méthode de blanchiment, spécifiez featurewise_center = True et __zca_whitening = True __ dans ImageDataGenerator. De plus, comme pour la standardisation, créez un lot avec flow ().
#Génération de générateur de blanchiment
datagen = ImageDataGenerator(featurewise_center=True,zca_whitening=True)
#Blanchiment
g = datagen.flow(X_train, y_train, shuffle=False)
X_batch, y_batch = g.next()
-La normalisation des lots est __ normalisation pour chaque lot __. En conséquence, la normalisation peut être effectuée même dans la couche intermédiaire (couche cachée). Surtout lors de l'utilisation de la fonction __ReLU, l'utilisation de la normalisation par lots pour __ rendra l'apprentissage plus fluide. -La méthode est __model.add (BatchNormalization ()) __.
-Ce qui suit est un exemple de normalisation par lots.
model.add(BatchNormalization())
model.add(Dense(128))
model.add(Activation('relu'))
-L'apprentissage par transfert consiste à __ apprendre un nouveau modèle en utilisant un modèle qui a déjà été formé __. Cela permet de créer en douceur un nouveau modèle même lorsqu'il s'agit d'une grande quantité de données. -Un exemple de modèle utilisé pour l'apprentissage par transfert est VGG. Le modèle VGG est un modèle qui entraîne 12 millions de données d'image appelé ImageNet avec un ensemble de données divisé en 1000 classes. -Puisque VGG a 1000 classes, il y a aussi 1000 couches entièrement connectées à la fin, mais dans l'apprentissage __transfer, il est seulement nécessaire d'utiliser des couches intermédiaires __.
・ Le flux d'apprentissage dans ce cas est ① Importez et définissez le modèle VGG (2) Définissez un nouveau calque à ajouter après le calque du modèle VGG ③ Définissez le nombre de couches du modèle VGG à utiliser ④ Compilez et terminez
#① Importez et définissez le modèle VGG
from keras.applications.vgg16 import VGG16
input_tensor=Input(shape=(32,32,3))
vgg16=VGG16(include_top=False,weights='imagenet',input_tensor=input_tensor)
#(2) Définissez un nouveau calque à ajouter après le calque du modèle VGG
top_model=Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256,activation='sigmoid'))
top_model.add(Dropout(0.5))
top_model.add(Dense(10,activation='softmax'))
model = Model(inputs=vgg16.input,outputs=top_model(vgg16.output))
#③ Définissez le nombre de couches du modèle VGG à utiliser
for layer in model.layers[:19]:
layer.trainable=False
#④ Compilez et terminez
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
・ Pour ①, __Input (shape = (32,32,3)) __ est l'entrée de l'image d'entrée, include_top = False est le paramètre permettant d'utiliser ou non la dernière couche entièrement connectée du modèle VGG, _weights = 'imagenet' _ Signifie que les poids utilisés sont ceux appris par ImageNet. ・ Concernant ②, __Model (inputs = vgg16.input, output = top_model (vgg16.output)) __ signifie combiner le modèle VGG et le nouveau modèle. ・ En ce qui concerne ③, __for layer dans model.layers [: 19]: __ signifie utiliser jusqu'à la 20e couche du modèle VGG, et __layer.trainable = False __ n'est pas configuré pour entraîner le modèle VGG. .. ・ En ce qui concerne ④, la compilation est normale, mais lors de l'apprentissage de __transfer, il est préférable de définir la fonction d'optimisation sur SGD __.
-Les données sont gonflées en donnant un argument à ImageDataGenerator () . Plus précisément, l'image est inversée. - La normalisation consiste à traiter les données selon une certaine règle et à les rendre faciles à utiliser. Il existe __ "standardisation" __ et __ "blanchiment" __ comme méthodes de normalisation. __ La normalisation améliore la précision de l'extraction des fonctionnalités et améliore l'efficacité de l'apprentissage __. -L'apprentissage par transfert consiste à __ apprendre un nouveau modèle en utilisant un modèle qui a déjà été formé __. Cette fois, j'ai utilisé le jeu de données d'image VGG.
Cette fois, c'est fini. Merci d'avoir lu jusqu'à la fin.
Recommended Posts