Tensorflow2.x+Kerasで環境構築しつつ画像収集から画像二値分類まで【Windows】

pip install tensorflow
pip install keras

from tensorflow.python.client import device_lib
device_lib.list_local_devices()

import tensorflow as tf
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
    for k in range(len(physical_devices)):
        tf.config.experimental.set_memory_growth(physical_devices[k], True)
        print('memory growth:', tf.config.experimental.get_memory_growth(physical_devices[k]))
else:
    print("Not enough GPU hardware devices available")

pip install face_recognition

import tensorflow as tf
from tensorflow import keras
from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D
from keras.callbacks import ModelCheckpoint

import itertools
from datetime import datetime
import json
import cv2
import glob
import re
import os
import sys
import matplotlib.pyplot as plt
import numpy as np
import time
import random
import IPython.display as display
import pathlib

img_file = glob.glob('./imgs/A/*.jpg')

tc = 0
fc = 0

for i in range(len(img_file)):
    try:
        img = face_recognition.load_image_file(img_file[i])
        imgs = cv2.imread(img_file[i], cv2.IMREAD_COLOR)
    except:
        print('image' + str(i) + ':NoImg')
        continue
    if imgs is None:
         print('image' + str(i) + ':NoImg')
    else:
        face_locations = face_recognition.face_locations(img)
        if len(face_locations) > 0:
            for rect in face_locations:
                t, r, b, l = rect
                cv2.imwrite('./cutImg/A/' + 'cutted' + str(tc) + '.jpg',imgs[t:b,l:r])
                tc +=1
        else:
            print(img_file[i],' :NoFace') 
            fc += 1
print('True Count :',str(tc))
print('False Count :',str(fc))

print('done')

rimg_file = glob.glob('./cutImg/A/*.jpg')

criret = 0.999
IMG_SIZE = (100, 100)
passhist_list = []
face_detect_count = 0

for file_name in rimg_file:
    try:
        img = cv2.imread(file_name)
        img = cv2.resize(img, dsize=IMG_SIZE)
    except:
        continue
    if img is None:
        print("img is none.")
        continue
    img_hist = []
    img_hist.append(cv2.calcHist([img], [0], None, [256], [0, 256]))
    img_hist.append(cv2.calcHist([img], [1], None, [256], [0, 256]))
    img_hist.append(cv2.calcHist([img], [2], None, [256], [0, 256]))
    for pass_hist in passhist_list:
        if cv2.compareHist(img_hist[0],pass_hist[0],cv2.HISTCMP_CORREL) > criret:
            break
        if cv2.compareHist(img_hist[1],pass_hist[1],cv2.HISTCMP_CORREL) > criret:
            break
        if cv2.compareHist(img_hist[2],pass_hist[2],cv2.HISTCMP_CORREL) > criret:
            break
    else:
        passhist_list.append(img_hist)
        cv2.imwrite('./resizeImg/A/' +  str(face_detect_count) + '.jpg',img)
        face_detect_count += 1

dirs = glob.glob('./resizeImg/*')

dir_names = [re.sub('./resizeImg\\\\','',x) for x in dirs]

datagen = ImageDataGenerator(
        rotation_range=40,
        width_shift_range=0.2,
        height_shift_range=0.2,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest')


for i,name in enumerate(dir_names):
    files = glob.glob('./resizeImg/'+name+'/*.jpg')
    
    if not os.path.exists('./data/'+name):
        os.makedirs('./data/'+name, exist_ok=True)
    
    for file in files:
        img_array = cv2.imread(file,)
        img_array = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
        img_array = img_array.reshape((1,) + img_array.shape)
        j = 0
        for batch in datagen.flow(img_array, batch_size=1,
                                  save_to_dir='./data/'+name, save_prefix=name, save_format='jpg'):
            j += 1
            if j == 8:
                break

def preprocess_image(image):
    image = tf.image.decode_jpeg(image, channels=3)
    image = tf.image.resize(image, [100, 100])
    image /= 255.0  # normalize to [0,1] range

    return image

def load_and_preprocess_image(path):
    image = tf.io.read_file(path)
    return preprocess_image(image)

AUTOTUNE = tf.data.experimental.AUTOTUNE

data_root = pathlib.Path('./data/')
all_image_paths = list(data_root.glob('*/*'))
all_image_paths = [str(path) for path in all_image_paths]
random.shuffle(all_image_paths)

image_count = len(all_image_paths)

label_names_all = sorted(item.name for item in data_root.glob('*/') if item.is_dir())
label_names = [x for x in label_names_all if '.' not in x]

label_to_index = dict((name, index) for index,name in enumerate(label_names))

all_image_labels = [label_to_index[pathlib.Path(path).parent.name]
                    for path in all_image_paths]

path_ds = tf.data.Dataset.from_tensor_slices(all_image_paths)
image_ds = path_ds.map(load_and_preprocess_image, num_parallel_calls=AUTOTUNE)

label_ds = tf.data.Dataset.from_tensor_slices(tf.cast(all_image_labels, tf.int64))

image_label_ds = tf.data.Dataset.zip((image_ds, label_ds))

BATCH_SIZE = 32

ds = image_label_ds.apply(
  tf.data.experimental.shuffle_and_repeat(buffer_size=image_count))
ds = ds.batch(BATCH_SIZE)
ds = ds.prefetch(buffer_size=AUTOTUNE)

TAKE_SIZE = int(image_count * 0.2)

train_data = ds.skip(TAKE_SIZE)
test_data = ds.take(TAKE_SIZE)

batch_size = 32
epochs = 30
IMG_HEIGHT = 100
IMG_WIDTH = 100

model = Sequential([
    Conv2D(16, 3, padding='same', activation='relu', input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),
    MaxPooling2D(),
    Dropout(0.2),
    Conv2D(32, 3, padding='same', activation='relu'),
    MaxPooling2D(),
    Conv2D(64, 3, padding='same', activation='relu'),
    MaxPooling2D(),
    Dropout(0.2),
    Flatten(),
    Dense(512, activation='relu'),
    Dense(1, activation='sigmoid')
])

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

total_train = image_count - TAKE_SIZE
total_val = TAKE_SIZE

modelCheckpoint = ModelCheckpoint(filepath = 'cnn.h5',
                                  monitor='val_loss',
                                  verbose=1,
                                  save_best_only=True,
                                  save_weights_only=False,
                                  mode='min',
                                  period=1)

history = model.fit(
    train_data,
    steps_per_epoch=total_train // batch_size,
    epochs=epochs,
    validation_data=test_data,
    validation_steps=total_val // batch_size,
    callbacks=[modelCheckpoint]
)

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(epochs)

plt.figure(figsize=(8, 8))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()