Appliquer des transformations à la vision fastai v2

Question

En fastai v2, j'essaie d'ajouter des augmentations d'image

Donc

tfms = aug_transforms(do_flip=True,
                                 flip_vert=True, 
                                 max_lighting=0.1, 
                                 )
data = ImageDataLoaders.from_df(df, bs=5, item_tfms=tfms, folder=chemin_des_données)

cela donne une sortie

Impossible d'effectuer une passe dans votre dataloader, il y a quelque chose qui ne va pas

Et lorsque je fais

data.show_batch()

cela génère

RuntimeError: "check_uniform_bounds" non implémenté pour 'Byte'

Comment résoudre

Answer 1

Je n'ai pas essayé la transformation do_flip, mais ce qui a fonctionné pour moi était de les appliquer non pas en tant que item_tfms mais en tant que batch_tfms:

item_tfms = [ Resize((200, 150), method='squish')]

batch_tfms = [Brightness(max_lighting = 0.3, p = 0.4),
    Contrast(max_lighting = 0.6, p = 0.4),
    Saturation(max_lighting = 0.75, p = 0.4)]

db = DataBlock(blocks = (ImageBlock, CategoryBlock),
                  get_items = get_image_files,
                  splitter = RandomSplitter(valid_pct=0.2, seed=42),
                  item_tfms=item_tfms,
                  batch_tfms=batch_tfms,
                  get_y = parent_label)

Vous pouvez ensuite alimenter le DataBlock dans un DataLoader comme dans le tutoriel fastbook

Answer 2

J'ai trouvé cela dans la documentation de fastai. Ajouter des choses liées à la question que vous pouvez vérifier sur ici Lié à augs

class AlbumentationsTransform(RandTransform):
    "Un gestionnaire de transformation pour plusieurs transformations `Albumentation`"
    split_idx,order=None,2
    def __init__(self, train_aug, valid_aug): store_attr()

    def before_call(self, b, split_idx):
        self.idx = split_idx

    def encodes(self, img: PILImage):
        if self.idx == 0:
            aug_img = self.train_aug(image=np.array(img))['image']
        else:
            aug_img = self.valid_aug(image=np.array(img))['image']
        return PILImage.create(aug_img)

Essentiellement, c'est tout ce dont vous avez besoin

Pour définir des augs différents, utilisez

def get_train_aug(): return albumentations.Compose([
            albumentations.RandomResizedCrop(224,224),
            albumentations.Transpose(p=0.5),
])

def get_valid_aug(): return albumentations.Compose([
    albumentations.CenterCrop(224,224, p=1.),
    albumentations.Resize(224,224)
], p=1.)

Et ensuite

item_tfms = [Resize(256), AlbumentationsTransform(get_train_aug(), get_valid_aug())]

dls = ImageDataLoaders.from_name_func(
    path, get_image_files(path), valid_pct=0.2, seed=42,
    label_func=is_cat, item_tfms=item_tfms)
dls.train.show_batch(max_n=4)

Profitez-en