Aperçu

Il est devenu nécessaire de s'entraîner en utilisant une partie de MNIST au lieu de l'ensemble de données MNIST. Par conséquent, j'ai créé un programme qui extrait de manière aléatoire n images de 60 000 données d'entraînement de MNIST, les divise en dossiers pour chaque classe et enregistre les images.

Environnement d'exécution

Google Colaboratory PyTorch 1.6.0

la mise en oeuvre

Enregistrer MNIST au format d'image

Téléchargez le jeu de données MNIST et enregistrez-le au format image pour une extraction aléatoire du jeu de données Train. J'ai fait référence à ce site. Essayez d'utiliser le dossier d'images avec PyTorch

Tout d'abord, importez les modules requis

import os
from PIL import Image
from torchvision.datasets import MNIST
import shutil
import glob
from pprint import pprint
import random
from pathlib import Path
from tqdm import tqdm

Si vous ne disposez pas du module requis, installez-le avec pip ou conda selon le cas.

Ensuite, téléchargez MNIST.

mnist_data = MNIST(root='./', train=True, transform=None, download=True)

Vous pouvez recevoir un avertissement d'utilisateur lorsque vous téléchargez la mnist, mais ne vous inquiétez pas, cette fois, vous n'apprendrez pas avec la mnist téléchargée.

Enregistrez l'image MNIST au format PNG à partir du fichier binaire MNIST téléchargé.

def makeMnistPng(image_dsets):
    for idx in tqdm(range(10)):
        print("Making image file for index {}".format(idx))
        num_img = 0
        dir_path = './mnist_all/'
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)
        for image, label in image_dsets:
           if label == idx:
                filename = dir_path +'/mnist_'+ str(idx) + '-' + str(num_img) + '.png'
                if not os.path.exists(filename):
                    image.save(filename)
                num_img += 1
    print('Success to make MNIST PNG image files. index={}'.format(idx))

Exécutez la fonction.

makeMnistPng(mnist_data)

Cela enregistre les 600 millions d'images mnist sous mnist_all. Si vous souhaitez enregistrer des images pour chaque classe, procédez comme suit.

def makeMnistPng(image_dsets):
    for idx in tqdm(range(10)):
        print("Making image file for index {}".format(idx))
        num_img = 0
        dir_path = './MNIST_PNG/' + str(idx)
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)
        for image, label in image_dsets:
            if label == idx:
                filename = dir_path +'/' + 'mnist_'+ str(idx) + '_' + str(num_img) + '.png'
                if not os.path.exists(filename):
                    image.save(filename)
                num_img += 1
    print('Success to make MNIST PNG image files. index={}'.format(idx))

Échantillonner au hasard à partir des fichiers du répertoire

Comme j'ai pu déposer toutes les données de mnist dans un répertoire, je vais échantillonner n images au hasard à partir de là et les copier dans un autre répertoire. L'article que j'ai utilisé comme référence (utilisé presque tel quel) est ici

Définition de classe


class FileControler(object):
    def get_file_path(self, input_dir, pattern):
        #Obtenir le chemin du fichier
        #Créer un objet chemin en spécifiant un répertoire
        path_obj = Path(input_dir)
        #Faire correspondre les fichiers au format glob
        files_path = path_obj.glob(pattern)
        #Conversion Posix à traiter comme une chaîne de caractères
        files_path_posix = [file_path.as_posix() for file_path in files_path]
        return files_path_posix
    
    def random_sampling(self, files_path, sample_num, output_dir, fix_seed=True) -> None:
        #Échantillonnage aléatoire
        #Épinglez Seed pour échantillonner le même fichier à chaque fois
        if fix_seed is True:
            random.seed(0)
        #Spécifiez le chemin du groupe de fichiers et le nombre d'échantillons
        files_path_sampled = random.sample(files_path, sample_num)
        #Créer s'il n'y a pas de répertoire de destination de sortie
        os.makedirs(output_dir, exist_ok=True)
        #copie
        for file_path in files_path_sampled:
            shutil.copy(file_path, output_dir)

Création d'instance

file_controler =FileControler()

Paramètres du répertoire

Définissez le répertoire source d'échantillonnage et le répertoire pour copier les fichiers échantillonnés.

all_file_dir = './mnist_all/'
sampled_dir = './mnist_sampled/'

Obtenez le chemin de tous les fichiers

pattern = '*.png'
files_path = file_controler.get_file_path(all_file_dir, pattern)

print(len(files_path))
# 60000

n échantillonnage

sample_num = 100
file_controler.random_sampling(files_path, sample_num, sampled_dir)

sampled_files_path = file_controler.get_file_path(sampled_dir, pattern)
print(len(sampled_files_path))
# 100

Avec cela, n feuilles (100 feuilles cette fois) ont été échantillonnées au hasard à partir de la liste de 60000 feuilles.

Classification

Nous diviserons les images échantillonnées en classes afin qu'elles puissent être utilisées comme un ensemble de données d'apprentissage automatique.

Tout d'abord, récupérez tous les noms de fichiers dans le répertoire échantillonné au format liste.

files = glob.glob("./mnist_sampled/*")

L'opérateur in est utilisé pour déterminer les sous-chaînes de la liste des noms de fichiers et les dossiers sont divisés par classe.

for i in range(10):
    os.makedirs(sampled_dir+str(i), exist_ok=True)
    for x in files:
        if '_' + str(i) in x:
            shutil.move(x, sampled_dir + str(i))

Le répertoire échantillonné a une telle structure de répertoires.

./mnist_sampled
├── 0
├── 1
├── 2
├── 3
├── 4
├── 5
├── 6
├── 7
├── 8
└── 9

Vous pouvez désormais échantillonner au hasard des images mnist et les classer pour créer un ensemble de données.

Créer un ensemble de données en échantillonnant au hasard les données MNIST