J'ai découvert en ligne cette API de séquence (je ne me souviens plus où, désolé):

class PlanetSequence(tf.keras.utils.Sequence):
    """
    Custom Sequence object to train a model on out-of-memory datasets. 
    """

    def __init__(self, df_path, data_path, im_size, batch_size, mode='train'):
        """
        df_path: path to a .csv file that contains columns with image names and labels
        data_path: path that contains the training images
        im_size: image size
        mode: when in training mode, data will be shuffled between epochs
        """
        self.df = pd.read_csv(df_path)
        self.im_size = im_size
        self.batch_size = batch_size
        self.mode = mode

        # Take labels and a list of image locations in memory
        labelsEncoder = self.df['label'].values
        self.labels = to_categorical(labelsEncoder, num_classes=11)
        self.image_list = self.df['image'].apply(lambda x: os.path.join(data_path, x)).tolist()

    def __len__(self):
        return int(math.ceil(len(self.df) / float(self.batch_size)))

    def on_epoch_end(self):
        # Shuffles indexes after each epoch
        self.indexes = range(len(self.image_list))
        if self.mode == 'train':
            self.indexes = random.sample(self.indexes, k=len(self.indexes))

    def get_batch_labels(self, idx): 
        # Fetch a batch of labels
        return self.labels[idx * self.batch_size : (idx + 1) * self.batch_size]

    def get_batch_features(self, idx):
        # Fetch a batch of images
        batch_images = self.image_list[idx * self.batch_size : (1 + idx) * self.batch_size]
        return np.array([load_image(im, self.im_size) for im in batch_images])

    def __getitem__(self, idx):
        batch_x = self.get_batch_features(idx)
        batch_y = self.get_batch_labels(idx)
        return batch_x, batch_y

Et dans la fonction load_image, nous avons ceci :

def load_image(image_path, size):
    # data augmentation logic such as random rotations can be added here
    return img_to_array(load_img(image_path, target_size=(size, size))) / 255.

Il semble que je puisse utiliser l'augmentation de données là-bas, mais je n'arrive pas à comprendre comment.

J'ai pensé à utiliser DataImageGenerator de Keras et à utiliser le flux pour augmenter les images, mais je n'ai pas pu faire en sorte que cela fonctionne.

Quelle est la meilleure approche pour y faire face?

0
user12879007 11 févr. 2020 à 16:20

1 réponse

Meilleure réponse

J'ai un peu modifié la réponse. J'essaierai également d'adapter le générateur de données à votre code, mais je suggérerais d'utiliser cette méthode pour utiliser le générateur d'images avec une gestion de base des données.
lisez d'abord train csv et importez shutil util pour vous déplacer et aligner votre dossier selon la structure mentionnée ci-dessous : import shutil utilisez cette méthode pour lire rapidement chaque ligne de csv et copier l'image dans les dossiers respectifs selon la structure shutil.copy(path given in csv, <destination folder>) de cette façon, lisez les deux csv et utilisez Shutil pour déplacer vos images dans la hiérarchie mentionnée ci-dessous, croyez-moi, cela prendra beaucoup moins de temps pour conserver les données. vous pouvez créer plusieurs sous-dossiers (selon la classe) avec un dossier en train et un dossier de test.

|__ train
|______ planète : [contient des images.]
|______ étoile : [contient des images.]

|__ test
|______ Planètes : [contient des images]
|______ chiens : [images]

test_dir = os.path.join(PATH, 'test')
train_dir = os.path.join(PATH, 'train')

train_planets_dir = os.path.join(train_dir, 'planet')  # directory with our planets images
train_stars_dir = os.path.join(train_dir, 'star')  # directory with our training star images
# similarly for stars i.e. other class
test_planets_dir = os.path.join(test_dir, 'planet')  
test_stars_dir = os.path.join(test_dir, 'star') 

Appelez maintenant le générateur d'images avec tous les types d'augmentations dont vous avez besoin selon vos besoins (voir les arguments pour les différentes augmentations, activez toutes celles requises)

train_data_gen = train_image_generator.flow_from_directory(batch_size=batch_size,
                                                           directory=train_dir,
                                                           shuffle=True,
                                                           target_size=(IMG_HEIGHT, IMG_WIDTH),
                                                           class_mode='binary')


see **train_dir** is the common path which contains all the sub class folders within

similarly for test.
test_data_gen = test_image_generator.flow_from_directory(batch_size=batch_size,
                                                              directory=test_dir,
                                                              target_size=(IMG_HEIGHT, IMG_WIDTH),
                                                              class_mode='binary')

De cette façon, vous obtiendrez la bonne façon de conserver les données et pourrez utiliser efficacement le générateur de données. De plus, de cette façon, vous finirez par gérer automatiquement l'étiquetage.

J'espère que ça aide un peu.

1
Raj kamal Srivastav 15 févr. 2020 à 13:38