Introduction à SfMLearner et l'importance de l'augmentation de données

SfMLearner est un framework d'apprentissage non supervisé conçu pour estimer la profondeur et le mouvement propre (ego-motion) à partir de séquences vidéo monoculaires. Dans les tâches d'estimation de profondeur sans supervision, les modèles risquent de surapprendre les données d'entraînement en raison de l'absence d'étiquettes de profondeur réelles. L'augmentation de données atténue ce problème en introduisant des transformations variées des images d'entrée, ce qui améliore la robustesse et la capacité de généralisation du modèle. Des études montrent que l'intégration de l'augmentation de données dans SfMLearner, même sans utilisation de données supplémentaires comme Cityscapes, peut surpasser les performances des modèles originaux sur des benchmarks tels que KITTI et Eigen.

Mise en œuvre de l'augmentation de données dans SfMLearner

L'augmentation de données dans SfMLearner est principalement implémentée dans le fichier data_loader.py via la classe DataLoader. Deux techniques clés sont combinées : le scaling aléatoire et le recadrage aléatoire, avec ajustement cohérent de la matrice intrinsèque de la caméra pour maintenir les contraintes géométriques.

Scaling aléatoire

Cette technique applique une mise à l'échelle non uniforme à l'image pour simuler des variations d'échelle. Voici une implémentation refactorisée :

def random_scaling(image, camera_matrix):
    batch_size, img_h, img_w, _ = image.get_shape().as_list()
    scale_values = tf.random.uniform([2], 1.0, 1.15)
    scale_x, scale_y = scale_values[0], scale_values[1]
    scaled_h = tf.cast(img_h * scale_y, dtype=tf.int32)
    scaled_w = tf.cast(img_w * scale_x, dtype=tf.int32)
    image = tf.image.resize(image, [scaled_h, scaled_w])
    fx_new = camera_matrix[:, 0, 0] * scale_x
    fy_new = camera_matrix[:, 1, 1] * scale_y
    cx_new = camera_matrix[:, 0, 2] * scale_x
    cy_new = camera_matrix[:, 1, 2] * scale_y
    camera_matrix = self.build_camera_matrix(fx_new, fy_new, cx_new, cy_new)
    return image, camera_matrix

Le scaling aléatoire génère des facteurs entre 1.0 et 1.15, ajustant simultanément les paramètres intrinsèques (fx, fy, cx, cy) pour préserver la cohérence géométrique. Cela aide le modèle à s'adapter aux différentes distances de prise de vue.

Recadrage aléatoire

Après le scaling, un recadrage aléatoire est appliqué pour augmenter la diversité des échatnillons en simulant des variations de champ de vision :

def random_cropping(image, camera_matrix, target_h, target_w):
    batch, src_h, src_w, _ = tf.unstack(tf.shape(image))
    start_y = tf.random.uniform([1], 0, src_h - target_h + 1, dtype=tf.int32)[0]
    start_x = tf.random.uniform([1], 0, src_w - target_w + 1, dtype=tf.int32)[0]
    image = tf.image.crop_to_bounding_box(image, start_y, start_x, target_h, target_w)
    fx_orig = camera_matrix[:, 0, 0]
    fy_orig = camera_matrix[:, 1, 1]
    cx_adjusted = camera_matrix[:, 0, 2] - tf.cast(start_x, dtype=tf.float32)
    cy_adjusted = camera_matrix[:, 1, 2] - tf.cast(start_y, dtype=tf.float32)
    camera_matrix = self.build_camera_matrix(fx_orig, fy_orig, cx_adjusted, cy_adjusted)
    return image, camera_matrix

Cette méthode recadre l'image à une position aléatoire, en modifiant le point principal (cx, cy) pour refléter le décalage. Cela permet au modèle d'apprendre des représentations invariantes aux changements de composition.

Processus complet d'augmentation

Les transformations sont combinées séquentiellement dans une méthode dédiée :

def data_augmentation_pipeline(self, image, camera_matrix, output_height, output_width):
    # Application du scaling aléatoire
    image, camera_matrix = random_scaling(image, camera_matrix)
    # Suivi du recadrage aléatoire
    image, camera_matrix = random_cropping(image, camera_matrix, output_height, output_width)
    image = tf.cast(image, dtype=tf.uint8)
    return image, camera_matrix

Cette approche combinée génère des échantillons d'entraînement diversifiés tout en maintenant les contraintes géométriques essentielles pour l'estimation de profondeur non supervisée.

Impact sur les performances du modèle

L'augmentation de données améliore les performances de SfMLearner de plusieurs manières :

• Diversification des données : Les transformations aléatoires réduisent le surapprentissage en exposant le modèle à une plus grande variété de scènes.
• Robustesse accrue : Le modèle apprend des caractéristiques visuelles plus générales, ce qui améliore sa capacité à généraliser sur des scénarios non vus.
• Cohérence géométrique : L'ajustement des paramètres intrinsèques assure que les données augmentées respectent les contraintes physiques du système de vision.

Les rapports expérimentaux indiquent que l'ajout de l'augmentation de données entraîne des gains significatifs sur des ensembles de test comme Eigen, validant son efficaicté pour l'odométrie visuelle monoculaire.