[DOCKER] Identifiez le nom de l'image de la fleur avec des keras (flux tenseur)

Réseau neuronal convolutif (CNN) Réseau neuronal convolutif (CNN) Faisons une expérience pour identifier le nom de l'image de la fleur!

introduction

Cette fois, nous mettrons le programme dans l'environnement docker.

    1. Préparation environnementale
  1. programme
    1. Expérience   Placez le programme dans Git.

Préparation environnementale

Environnement de développement

Macbook pro 13 2016

installation de docker

docker peut être facilement installé en tant que binaire à partir du site suivant.

https://docs.docker.com/docker-for-mac/

Créer un environnement d'apprentissage automatique à partir d'une image Miniconda

Vous pouvez installer un binaire compilé contenant des packages d'apprentissage automatique Construisez un environnement avec conda (Miniconda).

① Télécharger le modèle

$ docker pull continuumio/miniconda3

② Créer Dockerfile

$ vi Dockerfile
  :
$ cat Dockerfile
FROM continuumio/miniconda3
  RUN apt-get update
  RUN pip install --upgrade pip
  RUN pip install tensorflow \
                  pandas \
                  scipy \
                  Pillow \
                  keras
  RUN pip install -U scikit-learn
  RUN mkdir /home/src/

③ construction de docker (créer une image)

$ docker build -t conda:init .

④ Confirmation

$ docker images
REPOSITORY               TAG                 IMAGE ID            CREATED             SIZE
conda                    init                daf923e29da8        2 hours ago         1.55 GB

⑤ Démarrer le docker

Cette fois, montez le dossier à développer sur le docker.

# [mount dir]Veuillez réécrire et utiliser.
$ docker run -i -t -v [mount dir]:/home/src conda:init /bin/bash

Vous pouvez quitter en appuyant sur "Ctrl + p" ou "Ctrl + q".

Lors de l'accès à nouveau au conteneur

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
745860b72c67        conda:init         "/usr/bin/tini -- ..."   11 hours ago        Up 11 hours                             friendly_galileo

#Spécifiez l'ID DE CONTENEUR
$ docker attach 745860b72c67

Ceci termine la préparation de l'environnement

Programme de classification d'images de fleurs à partir d'ici

① Préparation des données d'entraînement

Collectez des images de fleurs sur Internet! Nommez la fleur dans le nom du répertoire comme indiqué dans la capture ci-dessous, et placez-y l'image de la fleur.

キャプチャ

② Création d'un modèle d'apprentissage

Préparez un programme pour enregistrer les données d'image et un tableau de catégories.

data_create.py


from PIL import Image
import sys
from sklearn import cross_validation
import os, glob
import numpy as np
import random, math

#
#Générer des données d'entraînement
#
class DataCreate : 
  def __init__(self, script_name):
    Image.LOAD_TRUNCATED_IMAGES = True
  
  def create(self) :
    input_dir = "images"
    categorys = []
    
    dir_list = os.listdir(input_dir)
    for index, dir_name in enumerate(dir_list):
      if dir_name == '.DS_Store' :
        continue
      categorys.append(dir_name)
    image_size = 50
    train_data = [] #données d'image,Données d'étiquette
    for idx, category in enumerate(categorys): 
      try :
        print("---", category)
        image_dir = input_dir + "/" + category
        files = glob.glob(image_dir + "/*.jpg ")
        for i, f in enumerate(files):
          img = Image.open(f)
          img = img.convert("RGB")
          img = img.resize((image_size, image_size))
          data = np.asarray(img)
          train_data.append([data, idx])

      except:
        print("SKIP : " + category)

    #Mélanger les données
    random.shuffle(train_data)
    X, Y = [],[]
    for data in train_data: 
      X.append(data[0])
      Y.append(data[1])

    test_idx = math.floor(len(X) * 0.8)
    xy = (np.array(X[0:test_idx]), np.array(X[test_idx:]), 
          np.array(Y[0:test_idx]), np.array(Y[test_idx:]))
    np.save("./npy/flower", xy)
  

if __name__ == "__main__":
  args = sys.argv
  datacreate = DataCreate(args[0])
  datacreate.create()


Ensuite, préparez un programme pour créer un modèle d'apprentissage.

train.py


import sys
import os
import numpy as np
import pandas as pd
import gc
from keras.models import Sequential
from keras.layers import Convolution2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.utils import np_utils

#
#Générer un modèle
#
class TrainModel : 
  def __init__(self):
    input_dir = 'images'
    self.nb_classes = len([name for name in os.listdir(input_dir) if name != ".DS_Store"])
    x_train, x_test, y_train, y_test = np.load("./npy/flower.npy")
    #Normaliser les données
    self.x_train = x_train.astype("float") / 256
    self.x_test = x_test.astype("float") / 256
    self.y_train = np_utils.to_categorical(y_train, self.nb_classes)
    self.y_test = np_utils.to_categorical(y_test, self.nb_classes)

  def train(self, input=None) :
    model = Sequential()
    # K=32, M=3, H=3
    if input == None :
      model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape=self.x_train.shape[1:]))
    else :
      model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape=input))

    # K=64, M=3, H=3 (réglage)
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))
    model.add(Convolution2D(64, 3, 3, border_mode='same'))
    model.add(Activation('relu'))
    # K=64, M=3, H=3 (réglage)
    model.add(Convolution2D(64, 3, 3))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))
    model.add(Flatten()) 
    model.add(Dense(512))
    # biases  nb_classes
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(self.nb_classes))
    model.add(Activation('softmax'))

    model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
    if input == None :
      #Apprenez et enregistrez le modèle
      model.fit(self.x_train, self.y_train, batch_size=32, nb_epoch=10)
      hdf5_file = "./model/flower-model.hdf5"
      model.save_weights(hdf5_file)

      #test de modèle
      score = model.evaluate(self.x_test, self.y_test)
      print('loss=', score[0])
      print('accuracy=', score[1])
    return model

if __name__ == "__main__":
  args = sys.argv
  train = TrainModel()
  train.train()
  gc.collect()

L'apprentissage est maintenant terminé.

Ensuite, essayez de l'exécuter.

#Organiser les images
$ python data_create.py
---Ai (Tadeai)
---Aogiri
---Aomoria Zami (Okino Zami)
---Agapanthe (Murasakikunsilane)
---Akaza
---Akashouma
---Sarrasin Akabana
---Akabana Mitsumata
---Akaya Jio
---Acanthe(Haazami)
---Aginashi
---Flocon de neige Akizaki
---Akino Unagitsukami
---Akino Tamurasou (Salvia Japonica)
---Akinonogeshi
---Akinowasu Regusa
   :
   :

#Apprentissage
$ python train.py 
  :
loss= 0.0410282239616
accuracy= 0.992773946126

Le taux de réussite de 99% est buggy (rires)

③ Test du modèle pour le moment

Préparez un programme simple pour tester le modèle.

check.py


import train as train
import sys, os
from PIL import Image
import numpy as np
import pandas as pd

if len(sys.argv) <= 1:
  quit()

image_size = 50
input_dir = 'images'
categories = [name for name in os.listdir(input_dir) if name != ".DS_Store"]

X = []
for file_name in sys.argv[1:]:
  img = Image.open(file_name)
  img = img.convert("RGB")
  img = img.resize((image_size, image_size))
  in_data = np.asarray(img)
  X.append(in_data)

X = np.array(X)

model = train.TrainModel().train(X.shape[1:])
model.load_weights("./model/flower-model.hdf5")

predict = model.predict(X)

for pre in predict:
  y = pre.argmax()
  print("Nom de la fleur: ", categories[y])

Essai

Testé avec des fleurs de concombre.

flower.jpg

$ python check.py test/flower.jpg
Using TensorFlow backend.
Nom de la fleur:concombre

Le concombre est réussi! Mais il y avait des moments où d'autres photos ne fonctionnaient pas. Je vais étudier un peu plus et le redonner.

finalement

Je vais également vous expliquer comment créer un chat bot avec apprentissage lorsque vous en aurez le temps.

Recommended Posts

Identifiez le nom de l'image de la fleur avec des keras (flux tenseur)
Défiez la classification des images avec TensorFlow2 + Keras CNN 1 ~ Bougez pour le moment ~
Reconnaissance d'image avec keras
Challenge classification des images par TensorFlow2 + Keras 3 ~ Visualiser les données MNIST ~
Supprimer le cadre de l'image
Reconnaissance d'image avec Keras + OpenCV
2020/02 Python 3.7 + TensorFlow 2.1 + Keras 2.3.1 + YOLOv3 Détection d'objets avec la dernière version
MNIST (DCNN) avec Keras (backend TensorFlow)
Défi la classification des images par TensorFlow2 + Keras 4 ~ Prédisons avec un modèle entraîné ~
Challenge classification des images par TensorFlow2 + Keras 1-Move pour le moment-
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
Défiez la classification des images avec TensorFlow2 + Keras 9-Apprentissage, sauvegarde et chargement de modèles-
Le sexe est déterminé à partir du nom.
Coupons le visage de l'image
Essayez de brouiller l'image avec opencv2
[TensorFlow / Keras] La route pour assembler un RNN de votre structure préférée
Affichage de l'image prise avec l'ISIGHT intégré
Comparez le TensorFlow brut avec tf.contrib.learn et Keras
Exécutez Keras avec le backend CNTK à partir de CentOS
Acquisition d'images depuis une caméra avec Python + OpenCV
Faites un clic droit sur l'image → Réalisez "Compresser avec TinyPNG"
J'ai essayé de jouer avec l'image avec Pillow
Comprendre les images de diverses opérations matricielles utilisées dans Keras (Tensorflow) avec des exemples
Méthode d'extraction de zone à l'aide de l'automate cellulaire Essayez l'extraction de zone de l'image avec growcut (Python)
[Python] J'ai essayé le même calcul que la prédiction de LSTM à partir de zéro [Keras]
Essayez de résoudre le problème du fizzbuzz avec Keras
J'ai essayé de "lisser" l'image avec Python + OpenCV
Coupez l'image aux coins arrondis avec pythonista
J'ai essayé de "différencier" l'image avec Python + OpenCV
(Remarque) Importation d'Excel avec le même nom de colonne
Traitement d'image à partir de zéro avec python (5) Transformation de Fourier
Télécharger des images à partir d'un fichier texte contenant l'URL
Présentation du modèle DCGAN pour Cifar 10 avec keras
Déterminez les nombres dans l'image prise avec la webcam
Traitement d'image à partir de zéro avec python (4) Extraction de contour
Détecter les dossiers avec la même image dans ImageHash
Renommer la balise avec un espace de noms en lxml
J'ai essayé de "binariser" l'image avec Python + OpenCV
Chargez le fichier de modèle TensorFlow .pb avec readNetFromTensorflow ().
Calculer l'angle entre les vecteurs à n dimensions avec TensorFlow
Afficher l'image après l'augmentation des données avec Pytorch
Défiez la classification des images par TensorFlow2 + Keras 6-Essayez le prétraitement et la classification des images préparées par vous-même-