introduction

--Il existe une méthode de remplissage au cas où il y aurait peu d'images d'apprentissage.

Il existe diverses choses telles que le contraste, le gamma, le flou et le bruit. ――Cette fois, nous avons effectué une inversion gauche-droite et un recadrage aléatoire. ――En fait, après diverses expériences, c'était la combinaison avec la meilleure précision d'apprentissage. C'est le cas de l'image originale cette fois.
La source complète est ici.

Bibliothèque

--J'ai utilisé l'oreiller `` Numpy ''.

$ pip install numpy==1.16.5 pillow

Réglage

Le traitement séquentiel est répété selon les «CLASSES».
L'image du visage est enregistrée dans FACE_PATH. --Selon TEST_NUM, l'image est dupliquée de FACE_PATH à TEST_PATH. --TRAIN_PATH duplique les images qui n'ont pas été répliquées vers TEST_PATH. --Selon ʻAUGMENT_NUM, une image gonflée est créée de TRAIN_PATH à ʻAUGMENT_PATH.

`config.py`


CLASSES = [
    'Abe Otsu',
    'Satomi Ishihara',
    'Yuno Ohara',
    'Koshiba Fuka',
    'Haruna Kawaguchi',
    'Nana Mori',
    'Minami Hamabe',
    'Kaya Kiyohara',
    'Haruka Fukuhara',
    'Kuroshima Yuina'
]

BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DATA_PATH = os.path.join(BASE_PATH, 'data')
FACE_PATH = os.path.join(DATA_PATH, 'face')
TRAIN_PATH = os.path.join(DATA_PATH, 'train')
TEST_PATH = os.path.join(DATA_PATH, 'test')
AUGMENT_PATH = os.path.join(DATA_PATH, 'augment')

TRAIN_NUM = 0
TEST_NUM = 100
AUGMENT_NUM = 6000

Dupliquer l'image du visage en une image d'apprentissage et une image de test

Vérifiez le chemin de l'image du visage, de l'image d'apprentissage et de l'image de test. --Créez une liste d'images de visage.
"La requête" est donnée séquentiellement "CLASSES".

`save_train_test_from_face.py`


def split(query):
    """Obtenez une liste d'images faciales, divisez-les et copiez-les en apprentissage et en test."""

    face_path = os.path.join(FACE_PATH, query)
    train_path = os.path.join(TRAIN_PATH, query)
    test_path = os.path.join(TEST_PATH, query)

    face_file_list = glob.glob(os.path.join(face_path, '*.jpeg'))
    face_file_list.sort()

Mélangez la liste des images de visage.
Diviser la liste des images de visage en images d'entraînement et images de test selon TEST_NUM.

`save_train_test_from_face.py`


    random.shuffle(face_file_list)

    train_file_list = face_file_list[:-TEST_NUM]
    test_file_list = face_file_list[len(train_file_list):]

--Créez une copie de l'image de formation et de l'image de test. ――Si vous conservez l'image du visage d'origine, vous pouvez éviter de la refaire.

`save_train_test_from_face.py`


    for face_file in train_file_list:
        train_file = os.path.join(train_path, os.path.basename(face_file))
        shutil.copy(face_file, train_file)

    for face_file in test_file_list:
        test_file = os.path.join(test_path, os.path.basename(face_file))
        shutil.copy(face_file, test_file)

L'image du visage a été divisée en une image d'apprentissage et une image de test comme indiqué ci-dessous.
Le nombre maximum d'images d'apprentissage est «392» et le nombre minimum est «269». Peut-être peu.

$ python save_train_test_from_face.py
query:Abe Otsu, face: 415, train: 315, test: 100
query:Satomi Ishihara, face: 492, train: 392, test: 100
query:Yuno Ohara, face: 372, train: 272, test: 100
query:Koshiba Fuka, face: 400, train: 300, test: 100
query:Haruna Kawaguchi, face: 369, train: 269, test: 100
query:Nana Mori, face: 389, train: 289, test: 100
query:Minami Hamabe, face: 481, train: 381, test: 100
query:Kaya Kiyohara, face: 428, train: 328, test: 100
query:Haruka Fukuhara, face: 420, train: 320, test: 100
query:Kuroshima Yuina, face: 448, train: 348, test: 100

Image d'apprentissage gonflée

«J'ai évoqué ce qui suit.

Résumé de l'augmentation des données des images dans NumPy

Fonction inversée horizontalement

Commencez par convertir de «Pillow» en «Numpy».
De plus, rate donne la probabilité d'inversion. Nous définissons «0,5» sur une chance de 50 à 50.
Convertissez en Numpy et retournez-le horizontalement avec fliplr.
Enfin, passez de «Numpy» à «Oreiller».

def horizontal_flip(image, rate=0.5):
    """Inverser horizontalement."""

    image = np.array(image, dtype=np.float32)

    if np.random.rand() < rate:
        image = np.fliplr(image)

    return Image.fromarray(np.uint8(image))

Fonction de recadrage aléatoire

Obtenez la hauteur et la largeur de l'image avec ʻimage.shape. --Déterminez la taille du recadrage en fonction de la «taille». «0,8» signifie rogner à une taille de «80%». --Positionnez «en haut à gauche» et «en bas à droite». --top sera une valeur aléatoire dans la plage 0àhauteur -- crop_size`.
De la même manière, déterminez «gauche». --bottom est localisé en ajoutant top et crop_size.
De la même manière, déterminez «juste». --Enfin, recadrer à partir de ʻimage`.

def random_crop(image, size=0.8):
    """Recadrer à une taille aléatoire."""

    image = np.array(image, dtype=np.float32)

    height, width, _ = image.shape
    crop_size = int(min(height, width) * size)

    top = np.random.randint(0, height - crop_size)
    left = np.random.randint(0, width - crop_size)
    bottom = top + crop_size
    right = left + crop_size
    image = image[top:bottom, left:right, :]

    return Image.fromarray(np.uint8(image))

Traitement gonflant

--Définissez le chemin de l'image d'entraînement et de l'image rembourrée.

"La requête" est donnée séquentiellement "CLASSES".

def augment(query):
    """Charger, gonfler et enregistrer des images d'apprentissage."""

    train_path = os.path.join(TRAIN_PATH, query)
    augment_path = os.path.join(AUGMENT_PATH, query)

--Créez une liste d'images faciales.

    train_list = glob.glob(os.path.join(train_path, '*.jpeg'))
    train_list.sort()

À partir du nombre d'images rembourrées, vérifiez combien d'images de visage doivent être créées et déterminez le nombre de processus en boucle.

    loop_num = math.ceil(AUGMENT_NUM / len(train_list))

--Effectuez les opérations suivantes dans le compte de traitement de la boucle et la boucle de liste d'images de visage.

Lecture de l'image du visage. --Inversé horizontalement à un taux de 50%.
Recadrage aléatoire avec une taille d'image de 80%. --Ajoutez -0001.jpeg au nom de fichier de l'image du visage et enregistrez l'image gonflée.

    augment_num = 0
    for num in range(1, loop_num + 1):
        for train_file in train_list:
            if augment_num == AUGMENT_NUM:
                break

            image = Image.open(train_file)

            image = horizontal_flip(image)
            image = random_crop(image)

            augment_file = os.path.join(AUGMENT_PATH, query, os.path.basename(train_file).split('.')[0] + '-{:04d}.jpeg'.format(num))
            image.save(augment_file, optimize=True, quality=95)
            print('query: {}, train_file: {}, augment_file: {}'.format(
                query, os.path.basename(train_file), os.path.basename(augment_file)))

            augment_num += 1

en conclusion

L'image d'entraînement a été gonflée avec «Pillo» et «Numpy». Dans le processus de travail, nous avons également confirmé le recadrage à l'échelle, la coupe apto, l'effacement aléatoire et la rotation aléatoire autre que le recadrage aléatoire. Dans le cas de l'image du visage cette fois, je ne l'ai pas utilisé car il ne convenait pas pour améliorer la précision. ―― La prochaine fois, nous prévoyons de créer un ensemble de données pour faciliter la gestion des images d'entraînement et des images de test.