introduction

―― La taille totale de l'image d'entraînement, de l'image de test et de l'image rembourrée est cette fois d'environ «1,4 Go». ――Le chargement de ces images prendra un certain temps une fois le programme d'apprentissage mis en œuvre. —— De plus, lorsque vous exécutez un programme d'apprentissage dans un autre environnement, le temps de transfert se produit. De plus, il faut du temps pour redimensionner l'image et passer de la couleur au gris. «En créant un ensemble de données qui a été redimensionné et converti en gris à l'avance, nous avons pu en faire environ« 50 Mo ».

La source complète est ici.

Bibliothèque

Comme la dernière fois, j'utilise Numpy Pillow`.

Réglage

Les paramètres suivants ont été ajoutés.
Le jeu de données créé cette fois est enregistré dans DATASETS_PATH. --ʻIMG_ROWS ʻIMG_COLS est un redimensionnement de la taille de l'image. Cette fois, nous le redimensionnerons à la taille «28 x 28».
La taille de l'image est également mentionnée dans le modèle de formation ultérieur.

`config.py`


DATASETS_PATH = os.path.join(DATA_PATH, 'datasets')

IMG_ROWS, IMG_COLS = 28, 28

Créer une liste de fichiers

--Créez une liste de fichiers d'images d'entraînement, d'images de test et d'images complétées. --query reçoit "CLASSES" dans l'ordre. --ʻAugmentL'argument est un indicateur de disponibilité des images remplies. --La dernière fois, l'image remplie a été créée pour chaquerequête`` 6000`. Si cela ne suffit pas, c'est une erreur.

def make_filesets(augment):
    """Créer un ensemble de fichiers."""

    filesets = {'train': dict(), 'test': dict(), 'augment': dict()}

    for query in CLASSES:

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

        if not os.path.isdir(train_path):
            print('no train path: {}'.format(train_path))
            return None
        if not os.path.isdir(test_path):
            print('no test path: {}'.format(test_path))
            return None
        if not os.path.isdir(augment_path):
            print('no augment path: {}'.format(augment_path))
            return None

        train_files = glob.glob(os.path.join(train_path, '*.jpeg'))
        train_files.sort()
        filesets['train'][query] = train_files

        test_files = glob.glob(os.path.join(test_path, '*.jpeg'))
        test_files.sort()
        filesets['test'][query] = test_files

        augment_files = glob.glob(os.path.join(augment_path, '*.jpeg'))
        random.shuffle(augment_files)
        filesets['augment'][query] = augment_files

        if augment and len(augment_files) < AUGMENT_NUM:
            print('less augment num: {}, path: {}'.format(len(augment_files), augment_path))
            return None

    return filesets

Fonction de chargement d'image

Traite l'image en fonction du chemin complet du fichier.
Il sera redimensionné en fonction du fichier de configuration.
À l'origine, dans OpenCV Haar Cascades, il a été enregistré sans redimensionnement. Le redimensionnement dans un processus ultérieur est plus pratique à essayer dans différentes tailles. ―― LANCZOS prend du temps, mais il est redimensionné avec une bonne qualité. La valeur par défaut est «LE PLUS PROCHE». La vitesse est prioritaire sur la qualité. --Référence: https://pillow.readthedocs.io/en/4.0.x/handbook/concepts.html#filters
Ensuite, convertissez en échelle de gris, puis en ʻuint8`.

def read_image(filename):
    """Chargement d'image, redimensionnement, conversion de gris."""

    image = Image.open(filename)
    image = image.resize((IMG_ROWS, IMG_COLS), Image.LANCZOS)
    image = image.convert('L')
    image = np.array(image, dtype=np.uint8)

    return image

Créer un jeu de données

--Préparez un tableau d'images d'entraînement, d'étiquettes d'entraînement, d'images de test et d'étiquettes de test.

def make_datasets(augment, filesets):
    """Créer un jeu de données."""

    train_images = []
    train_labels = []
    test_images = []
    test_labels = []

--query reçoit "CLASSES" dans l'ordre. --Num reçoit une étiquette séquentielle. ――Par exemple, au début de «CLASSES», le libellé «Abe Otsu» est comme «0». --Déterminez s'il faut utiliser l'image gonflée avec «augmentation». Si vous voulez l'utiliser, définissez uniquement le nombre décrit dans ʻAUGMENT_NUM sur train_files`.

Le tqdm est également utilisé pour lire chaque image. La progression du traitement est affichée, ce qui est facile à comprendre. --Donner read_image le chemin du fichier de l'image pour lire l'image redimensionnée et en niveaux de gris.
En même temps, une étiquette sera ajoutée.

    for num, query in enumerate(CLASSES):
        print('create dataset: {}'.format(query))

        if augment:
            train_files = filesets['augment'][query][:AUGMENT_NUM]
        else:
            train_files = filesets['train'][query]
        test_files = filesets['test'][query]

        for train_file in tqdm.tqdm(train_files, desc='create train', leave=False):
            train_images.append(read_image(train_file))
            train_labels.append(num)
        for test_file in tqdm.tqdm(test_files, desc='create test', leave=False):
            test_images.append(read_image(test_file))
            test_labels.append(num)

Collectez des images d'entraînement, des étiquettes d'entraînement, des images de test et des étiquettes de test sous forme de jeu de données. --DATASET_PATH CLASSES ʻIMG_ROWS ʻIMG_COLS` Détermine le nom de fichier de l'ensemble de données en fonction de l'utilisation ou non de l'image complétée.

    datasets = ((np.array(train_images), (np.array(train_labels))), (np.array(test_images), (np.array(test_labels))))

    datasets_path = os.path.join(DATASETS_PATH, ','.join(CLASSES))
    os.makedirs(datasets_path, exist_ok=True)
    train_num = AUGMENT_NUM if augment else 0
    datasets_file = os.path.join(datasets_path, '{}x{}-{}.pickle'.format(IMG_ROWS, IMG_COLS, train_num))
    with open(datasets_file, 'wb') as fout:
        pickle.dump(datasets, fout)
    print('save datasets: {}'.format(datasets_file))

――L'utilisation d'images gonflées est permutée avec les options suivantes.

$ python save_datasets.py

$ python save_datasets.py --augment

L'ensemble de données pickle est le suivant.
Dans le cas de l'original, un fichier pickle du test train`` totalisant environ 148MB à 3,2 Mo--Pour les images rembourrées, pickle les fichiers du test ʻaugment`` totalisant environ1433MB à 46MB`

$ du -d1 -h .
115M	./train
 33M	./test
 51M	./datasets
1.4G	./augment


$ ls
3.2M 12 15 23:22 28x28-0.pickle
46M 12 15 22:24 28x28-6000.pickle

en conclusion

――Nous avons créé un ensemble de données qui a redimensionné et mis à l'échelle les données d'image afin qu'il puisse être facilement utilisé à partir du programme d'apprentissage. ―― Vous pouvez créer divers ensembles de données en modifiant le nombre d'images remplies et plusieurs tailles, et les utiliser tout en changeant par nom de fichier. ――La prochaine fois, je prévois de créer une pièce pour lire l'ensemble de données du programme d'apprentissage.

[PYTHON] Créer un ensemble de données d'images à utiliser pour la formation