[PYTHON] Aufgeblasenes Lernbild

Einführung

• Es gibt eine Methode zum Auffüllen, falls nur wenige Lernbilder vorhanden sind.
• Es gibt verschiedene Dinge wie Kontrast, Gamma, Unschärfe und Rauschen. ――Dieses Mal haben wir eine Umkehrung von links nach rechts und ein zufälliges Zuschneiden durchgeführt. ―― Nach verschiedenen Experimenten war es tatsächlich die Kombination mit der besten Lerngenauigkeit. Diesmal ist es das Originalbild.
• Die vollständige Quelle ist hier.

Bibliothek

• Ich habe Numpy`` Pillow verwendet.

$ pip install numpy==1.16.5 pillow

Aufbau

• Die sequentielle Verarbeitung wird gemäß "KLASSEN" wiederholt.
• Das Gesichtsbild wird in FACE_PATH gespeichert.
• Gemäß TEST_NUM wird das Bild von FACE_PATH nach TEST_PATH dupliziert. --TRAIN_PATH dupliziert Bilder, die nicht auf TEST_PATH repliziert wurden.
• Gemäß "AUGMENT_NUM" wird ein aufgeblähtes Bild von "TRAIN_PATH" zu "AUGMENT_PATH" erstellt.

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

Duplizieren Sie das Gesichtsbild in ein Lernbild und ein Testbild

--Überprüfen Sie den Pfad des Gesichtsbilds, des Lernbilds und des Testbilds. --Erstellen Sie eine Liste mit Gesichtsbildern.

• "Abfrage" wird nacheinander "KLASSEN" gegeben.

save_train_test_from_face.py

def split(query):
    """Holen Sie sich eine Liste mit Gesichtsbildern, teilen Sie diese auf und kopieren Sie sie in Lernen und Testen."""

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

• Mische die Liste der Gesichtsbilder.
• Unterteilen der Liste der Gesichtsbilder in Trainingsbilder und Testbilder gemäß 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):]

--Erstellen Sie ein Duplikat des Trainingsbildes und des Testbildes. ――Wenn Sie das ursprüngliche Gesichtsbild beibehalten, können Sie sich das Wiederherstellen ersparen.

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)

• Das Gesichtsbild wurde wie unten gezeigt in ein Lernbild und ein Testbild unterteilt. ――Die maximale Anzahl von Lernbildern beträgt "392" und die minimale Anzahl "269". Vielleicht wenige.

$ 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

Aufgeblasenes Lernbild

――Ich habe mich auf Folgendes bezogen.

• Zusammenfassung der Datenerweiterung von Bildern in NumPy

Horizontal invertierte Funktion

• Konvertieren Sie zuerst von "Kissen" zu "Numpy".
• Außerdem gibt "Rate" die Wahrscheinlichkeit einer Inversion an. Ich habe "0,5" eingestellt, um eine 50: 50-Chance zu erzielen. --Konvertieren Sie zu "Numpy" und drehen Sie es horizontal mit "fliplr".
• Wechseln Sie schließlich von "Numpy" zurück zu "Pillow".

def horizontal_flip(image, rate=0.5):
    """Horizontal umkehren."""

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

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

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

Zufällige Erntefunktion

• Holen Sie sich die Höhe und Breite des Bildes mit image.shape. --Bestimmen Sie die Erntegröße anhand der "Größe". "0,8" bedeutet, mit einer Größe von "80%" zu ernten.
• Positionieren Sie die "oben links" und "unten rechts". --top ist ein zufälliger Wert im Bereich von 0 bis height -- crop_size.
• Bestimmen Sie auf ähnliche Weise "links". --bottom wird durch Hinzufügen von top und crop_size gefunden.
• Bestimmen Sie in ähnlicher Weise "richtig".
• Zum Schluss aus "Bild" zuschneiden.

def random_crop(image, size=0.8):
    """Ernte in zufälliger Größe."""

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

Aufblasbehandlung

• Legen Sie den Pfad für das Trainingsbild und das aufgefüllte Bild fest.
• "Abfrage" wird nacheinander "KLASSEN" gegeben.

def augment(query):
    """Laden, aufblasen und speichern Sie Lernbilder."""

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

--Erstellen Sie eine Liste mit Gesichtsbildern.

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

• Überprüfen Sie anhand der Anzahl der aufgefüllten Bilder, wie viele Gesichtsbilder erstellt werden sollen, und bestimmen Sie die Anzahl der Schleifenprozesse.

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

• Führen Sie die folgenden Schritte in der Schleifenverarbeitungszähl- und Gesichtsbildlistenschleife durch.
• Lesen Sie das Gesichtsbild.
• Horizontal mit einer Rate von 50% invertiert.
• Zufälliges Zuschneiden mit 80% Bildgröße.
• Fügen Sie dem Dateinamen des Gesichtsbildes -0001.jpeg hinzu und speichern Sie das aufgeblasene Bild.

    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

abschließend

• Das Trainingsbild wurde mit "Pillo" und "Numpy" aufgeblasen. ――In der Arbeit haben wir auch bestätigt, dass die Waage ausgeschnitten, apto geschnitten, zufällig gelöscht und zufällig gedreht wurde, außer zufällig zugeschnitten. Beim Gesichtsbild habe ich es diesmal nicht verwendet, da es nicht zur Verbesserung der Genauigkeit geeignet war. ――Nächstes Mal planen wir, einen Datensatz zu erstellen, um die Handhabung der Trainingsbilder und Testbilder zu vereinfachen.