Image d'apprentissage gonflée

introduction

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

Bibliothèque

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

$ pip install numpy==1.16.5 pillow

Réglage

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

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()

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)
$ 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.

Fonction inversée horizontalement

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

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.

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()
    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.

    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

Recommended Posts

Image d'apprentissage gonflée
Reconnaissance d'image par apprentissage profond 1 théorie
Gonflage des données d'entraînement [Image Date Generator]
Implémentation du modèle de reconnaissance d'images d'apprentissage en profondeur 2
[AI] Apprentissage en profondeur pour le débruitage d'image
estimation personnelle en temps réel (apprentissage)
Deep learning 2 appris par l'implémentation (classification d'images)
Dossier d'apprentissage
Dossier d'apprentissage n ° 3
Dossier d'apprentissage n ° 1
Apprentissage automatique
Suppression du bruit de l'image
apprentissage de python
Alignement d'image: du SIFT au deep learning
Dossier d'apprentissage n ° 2
Reconnaissance d'image
6/10 Contenu d'apprentissage
Reconnaissance d'image en apprentissage profond 3 après la création du modèle
L'apprentissage en profondeur
apprentissage numpy-sigmoïde
Explorateur d'images
Système de jugement d'image de petite fille Apprentissage automatique Lolinco
Lire et mettre en œuvre l'apprentissage résiduel profond pour la reconnaissance d'image
Implémentation du modèle Deep Learning pour la reconnaissance d'images