[PYTHON] J'ai essayé de classer Oba Hanana et Otani Emiri par apprentissage profond

introduction

agréable de vous rencontrer tous. Mon nom est Oboro. Depuis que j'ai résolu le problème de classification par reconnaissance d'image dans la formation de l'entreprise cette fois, puis-je réellement obtenir la même précision et le même résultat avec ce que j'aime? De plus, si la précision n'est pas élevée, je voudrais vérifier quel type d'approche peut être adopté pour améliorer la précision. J'ai écrit l'article en supposant que les personnes qui ne sont pas liées à l'IA liront l'article, donc je pense que ce n'est pas suffisant pour ceux qui veulent apprendre l'apprentissage en profondeur à travers cet article. Cependant, le contenu de la mise en œuvre est facile à essayer, veuillez donc y jeter un œil.

Tout d'abord, qui sont Hanana Oba et Emiri Otani?

Kana Oba est membre du groupe d'idols "= LOVE", que j'adore les chiffons. ** Incroyablement mignon. ** **

Voici un compte Twitter. Merci de nous suivre. Hanana Oba (https://twitter.com/hana_oba) Emiri Otani est également membre du groupe d'idols "= LOVE". Cet enfant est également mignon.

Emiri Otani (https://twitter.com/otani_emiri)

Différence par rapport à la mission de formation

Lors de la formation, j'ai résolu le problème de classification des chiens et des chats. Je pense que la précision était d'environ 95% de taux de réponse correcte.

1. Conditions préalables à la tâche

• Le nombre d'échantillons est de 100 pour chaque chien et chat

• La taille de l'image est de 224 * 224

• Les données de formation représentent 70% du total (les données de vérification représentent 30% du total)

2. Conditions de cette expérience

――Le nombre d'échantillons est de 300 chacun (c'est un secret que j'étais heureux quand j'ai enregistré 300 images sur Twitter pour collecter des échantillons)

• La taille de l'image est de 224 * 224

• Les données de formation représentent 70% du total (les données de vérification représentent 30% du total)

Conférence en classe

Avant de l'implémenter, j'expliquerai un peu la théorie du traitement d'image par deep learning. Si vous n'êtes pas intéressé à la fois par la mise en œuvre et par les cours en classe, veuillez passer à la fin.

Qu'est-ce que le Deep Learning?

Avant l'apprentissage en profondeur Je pense que beaucoup de gens ne comprennent pas ce que signifient l'intelligence artificielle, l'apprentissage automatique et l'apprentissage profond, alors laissez-moi vous expliquer brièvement en incluant ceux-ci. Je suis désolé si j'ai fait une erreur ...

――AI est l'intelligence artificielle, qui est littéralement une intelligence créée artificiellement.

―― L'apprentissage automatique est l'une des technologies actuellement indispensables à la réalisation de l'IA. Actuellement, il est courant d'utiliser l'apprentissage automatique pour réaliser l'IA.

«L'apprentissage en profondeur est l'une des méthodes d'apprentissage automatique, et vous pouvez juger quelles données sont importantes et à quel point elles sont importantes à partir d'une grande quantité de données, et en tirer une solution.

Traitement des données d'image

Un pixel de données d'image peut être exprimé par la luminosité (luminosité 0-255) pour chaque RVB (rouge, vert, bleu), de sorte qu'il peut être traité comme des données numériques en le déposant dans cette forme. Exemple) Dans le cas de 22 * 224 images Cela peut être représenté par une matrice de 224 * 224 * 3 (vertical * horizontal * trois couleurs primaires), donc img.shape = (224,224,3).

À propos du réseau neuronal

Ci-dessous, une image simple du réseau neuronal.

z1 est calculé par la formule suivante.

z_1  = w_{31} y_1 + w_{32} y_2

Puisque y1 et y2 sont également calculés de la même manière, la sortie peut être calculée pour chaque entrée et chaque poids. Comparez la sortie et la réponse et ajustez le poids par erreur De plus, la sortie est sortie avec une autre entrée, et ainsi de suite, et ainsi de suite. L'apprentissage en profondeur est dit très expressif car cette couche intermédiaire est multicouche. Je pense que c'est facile à comprendre si vous pensez que la sortie souhaitée peut être exprimée par diverses entrées et pondérations.

Comment construire un réseau neuronal dans le traitement d'image

Dans le traitement d'image, les poids ci-dessus forment un réseau neuronal avec un filtre. Appliquez le filtre (rouge) à la partie verte de l'image comme indiqué dans l'image ci-dessous. Cela vous donnera finalement la sortie "6" (bleu). Cela dépend de la manière dont vous appliquez le filtre, mais vous pouvez obtenir une nouvelle matrice par sortie en la déplaçant vers la droite d'un carré et en faisant la même chose. Après avoir répété ce processus, nous classons par la valeur à laquelle nous sommes arrivés.

la mise en oeuvre

Mettons-le en œuvre. L'environnement est Google Colaboratory

idol.ipynb

from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import cv2
import matplotlib.pyplot
import numpy  as np
from glob import glob
import pandas as pd
%cd /content/drive/My Drive/

%tensorflow_version 2.x
from tensorflow.keras.preprocessing import image
from tensorflow.python.client import device_lib
#Définir le modèle
from tensorflow.keras import models, layers
from tensorflow.python.keras.layers import Dropout
from tensorflow.keras import utils
import tensorflow as tf
from google.colab import drive
drive.mount('/content/drive')

J'appelle cette zone à Tekito, que je l'utilise ou non. Obtenez le chemin du dossier qui recueille chaque image préparée à l'avance dans Google Drive.

idol.ipynb

%cd /content/drive/My Drive/DATA/IDOL
hana_filepaths = glob('OBA_HANA/*')
emiri_filepaths = glob('OTANI_EMIRI/*')

Ensuite, puisque la taille de l'image enregistrée varie, nous unifierons la taille à 224 * 224 et numériserons l'image.

idol.ipynb

image_size = 224
x, t =[],[]
for i in range(0,np.array(emiri_filepaths).size):
  hana_filepath = hana_filepaths[i]
  emiri_filepath = emiri_filepaths[i]
  img = image.load_img(hana_filepath, target_size=(image_size, image_size))
  img = np.array(img)
  x.append(img)
  t.append(0)
  img = image.load_img(emiri_filepath, target_size=(image_size, image_size))
  img = np.array(img)
  x.append(img)
  t.append(1)
x = np.array(x)/255.0 #Standardisation
t = np.array(t)

Apprenons maintenant.

idol.ipynb

K.clear_session()
reset_seed(0)

#nas_mobile_conv = keras.applications.nasnet.NASNetMobile(weights = 'imagenet', include_top = False, input_shape = (x_train.shape[1:]), classes=2)
nas_mobile_conv = NASNetMobile(weights = 'imagenet', include_top = False, input_shape = (x_train.shape[1:]), classes=2)

x = nas_mobile_conv.layers[-1].output
x = layers.Flatten()(x) #Supprimez le dernier calque de sortie et ajoutez-en un nouveau
x = layers.Dense(1024, activation = 'relu')(x)
x = layers.BatchNormalization()(x)
x = layers.Dense(516, activation = 'relu')(x)
x = layers.BatchNormalization()(x)
x = layers.Dense(2, activation = 'softmax')(x)

model = models.Model(nas_mobile_conv.inputs, x)
model.summary()

optimizer = tf.keras.optimizers.Adam(lr=1e-4)

model.compile(optimizer = optimizer,
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

batch_size = 32
epochs = 100

history = model.fit(x_train, t_train,
                   batch_size = batch_size,
                   epochs = epochs,
                   verbose=1,
                   validation_data=(x_test, t_test))

Avec epochs = 100 (le nombre de répétitions), la transition de précision pour chaque nombre peut être représentée graphiquement ci-dessous.

idol.ipynb

result = pd.DataFrame(history.history)
result[['accuracy','val_accuracy']].plot()

Le bleu correspond aux données d'entraînement et l'orange aux données de vérification. (Couleur psyllium de Hana-chan) Vous pouvez voir que la précision du flou augmente à mesure que le nombre de fois augmente. Il continue d'augmenter, alors je vais essayer d'augmenter le nombre de fois.

• Il semble difficile de définir la valeur initiale du même nombre aléatoire à chaque fois lors du calcul avec GPU, et le résultat sera différent à chaque fois qu'il est exécuté. (Inversement, si vous pouvez fixer la valeur initiale du nombre aléatoire à chaque fois, vous devriez obtenir le même résultat quel que soit le nombre de fois que vous le faites)

Je l'ai augmenté à 200 fois.

La précision s'est un peu améliorée et le taux de réponse correct est d'environ 90%.

Je suis fatigué aujourd'hui, alors j'aimerais le terminer jusqu'à présent, et la prochaine fois, j'aimerais voir à quoi ressemblait la mauvaise image par essais et erreurs pour améliorer la précision.