Consensus d'échantillons aléatoires

Le consensus d'échantillons aléatoires ( RANSAC ) est une méthode itérative permettant d'estimer les paramètres d'un modèle mathématique à partir d'un ensemble de données observées contenant des valeurs aberrantes , lorsque les valeurs aberrantes ne doivent avoir aucune influence sur les valeurs des estimations. Par conséquent, il peut également être interprété comme une méthode de détection des valeurs aberrantes. Il s'agit d'un algorithme non déterministe dans le sens où il ne produit un résultat raisonnable qu'avec une certaine probabilité, cette probabilité augmentant à mesure que davantage d'itérations sont autorisées. L'algorithme a été publié pour la première fois par Fischler et Bolles au SRI International en 1981. Ils ont utilisé RANSAC pour résoudre le problème de détermination de l'emplacement (LDP), où l'objectif est de déterminer les points dans l'espace qui se projettent sur une image dans un ensemble de points de repère avec des emplacements connus.

RANSAC utilise un sous-échantillonnage aléatoire répété . Une hypothèse de base est que les données sont constituées de « valeurs aberrantes », c'est-à-dire de données dont la distribution peut être expliquée par un ensemble de paramètres du modèle, bien qu'elles puissent être sujettes à du bruit, et de « valeurs aberrantes », qui sont des données qui ne correspondent pas au modèle. Les valeurs aberrantes peuvent provenir, par exemple, de valeurs extrêmes du bruit ou de mesures erronées ou d'hypothèses incorrectes sur l'interprétation des données. RANSAC suppose également que, étant donné un ensemble (généralement petit) de valeurs aberrantes, il existe une procédure qui peut estimer les paramètres d'un modèle expliquant ou ajustant de manière optimale ces données.

Un exemple simple consiste à ajuster une ligne en deux dimensions à un ensemble d'observations. En supposant que cet ensemble contienne à la fois des points aberrants , c'est-à-dire des points qui peuvent être ajustés approximativement à une ligne, et des points aberrants , c'est-à-dire des points qui ne peuvent pas être ajustés à cette ligne, une simple méthode des moindres carrés pour l'ajustement de la ligne produira généralement une ligne mal ajustée aux données, y compris les points aberrants et les points aberrants. La raison en est qu'elle s'adapte de manière optimale à tous les points, y compris les points aberrants. RANSAC, d'autre part, tente d'exclure les points aberrants et de trouver un modèle linéaire qui n'utilise que les points aberrants dans son calcul. Cela se fait en ajustant les modèles linéaires à plusieurs échantillons aléatoires des données et en renvoyant le modèle qui s'adapte le mieux à un sous-ensemble des données. Étant donné que les points aberrants ont tendance à être plus linéairement liés qu'un mélange aléatoire de points aberrants et de points aberrants, un sous-ensemble aléatoire entièrement composé de points aberrants aura le meilleur ajustement du modèle. En pratique, il n’y a aucune garantie qu’un sous-ensemble d’inliers soit échantillonné de manière aléatoire, et la probabilité de réussite de l’algorithme dépend de la proportion d’inliers dans les données ainsi que du choix de plusieurs paramètres de l’algorithme.

• 
  Un ensemble de données comportant de nombreuses valeurs aberrantes pour lesquelles une ligne doit être ajustée.
• 
  Ligne ajustée avec RANSAC ; les valeurs aberrantes n'ont aucune influence sur le résultat.

L'algorithme RANSAC est une technique d'apprentissage permettant d'estimer les paramètres d'un modèle par échantillonnage aléatoire de données observées. Étant donné un ensemble de données dont les éléments de données contiennent à la fois des valeurs aberrantes et des valeurs aberrantes, RANSAC utilise le schéma de vote pour trouver le résultat d'ajustement optimal. Les éléments de données de l'ensemble de données sont utilisés pour voter pour un ou plusieurs modèles. La mise en œuvre de ce schéma de vote repose sur deux hypothèses : les caractéristiques bruyantes ne voteront pas systématiquement pour un seul modèle (peu de valeurs aberrantes) et il y a suffisamment de caractéristiques pour s'accorder sur un bon modèle (peu de données manquantes). L'algorithme RANSAC est essentiellement composé de deux étapes qui sont répétées de manière itérative :

1. Un sous-ensemble d'échantillons contenant un nombre minimal d'éléments de données est sélectionné de manière aléatoire dans l'ensemble de données d'entrée. Un modèle d'ajustement avec des paramètres de modèle est calculé en utilisant uniquement les éléments de ce sous-ensemble d'échantillons. La cardinalité du sous-ensemble d'échantillons (par exemple, la quantité de données dans ce sous-ensemble) est suffisante pour déterminer les paramètres du modèle.
2. L'algorithme vérifie quels éléments de l'ensemble de données sont cohérents avec le modèle instancié par les paramètres estimés du modèle obtenus à partir de la première étape. Un élément de données sera considéré comme une valeur aberrante s'il ne correspond pas au modèle dans les limites d'un seuil d'erreur définissant l'écart maximal des données des valeurs aberrantes (les éléments de données au-delà de cet écart sont des valeurs aberrantes).

L'ensemble des valeurs aberrantes obtenues pour le modèle d'ajustement est appelé ensemble de consensus . L'algorithme RANSAC répétera de manière itérative les deux étapes ci-dessus jusqu'à ce que l'ensemble de consensus obtenu dans une certaine itération contienne suffisamment de valeurs aberrantes.

L'algorithme RANSAC est alimenté par un ensemble de valeurs de données observées, un modèle à adapter aux observations et certains paramètres de confiance définissant les valeurs aberrantes. De manière plus détaillée que la présentation de l'algorithme RANSAC mentionnée ci-dessus, RANSAC atteint son objectif en répétant les étapes suivantes :

1. Sélectionnez un sous-ensemble aléatoire des données d'origine. Appelez ce sous-ensemble les inliers hypothétiques .
2. Un modèle est ajusté à l’ensemble des inliers hypothétiques.
3. Toutes les données sont ensuite testées par rapport au modèle ajusté. Tous les points de données (des données d'origine) qui correspondent bien au modèle estimé, selon une fonction de perte spécifique au modèle , sont appelés ensemble de consensus (c'est-à-dire l'ensemble des valeurs aberrantes du modèle).
4. Le modèle estimé est raisonnablement bon si un nombre suffisant de points de données ont été classés comme faisant partie de l’ensemble de consensus.
5. Le modèle peut être amélioré en le réestimant en utilisant tous les membres de l'ensemble de consensus. La qualité d'ajustement en tant que mesure de la qualité d'ajustement du modèle à l'ensemble de consensus sera utilisée pour affiner l'ajustement du modèle au fil des itérations (par exemple, en définissant cette mesure comme critère de qualité d'ajustement à l'itération suivante).

Pour converger vers un ensemble de paramètres de modèle suffisamment bon, cette procédure est répétée un nombre fixe de fois, produisant à chaque fois soit le rejet d'un modèle parce que trop peu de points font partie de l'ensemble de consensus, soit un modèle raffiné avec une taille d'ensemble de consensus plus grande que l'ensemble de consensus précédent.

L'algorithme générique RANSAC fonctionne comme le pseudo-code suivant :

Donné: données – Un ensemble d’observations. modèle – Un modèle pour expliquer les points de données observés. n – Le nombre minimum de points de données requis pour estimer les paramètres du modèle. k – Le nombre maximal d’itérations autorisées dans l’algorithme. t – Une valeur seuil pour déterminer les points de données qui sont bien ajustés par le modèle (inlier). d – Le nombre de points de données proches (inliers) requis pour affirmer que le modèle s’adapte bien aux données. Retour: bestFit – Les paramètres du modèle qui peuvent le mieux s’adapter aux données (ou null si aucun bon modèle n’est trouvé). itérations = 0 meilleurAjustement = null bestErr = quelque chose de vraiment grand // Ce paramètre est utilisé pour affiner les paramètres du modèle afin d'obtenir le meilleur ajustement des données au fur et à mesure des itérations. tant que 
les itérations < k 
font maybeInliers := n valeurs sélectionnées aléatoirement à partir des données maybeModel := paramètres du modèle adaptés à maybeInliers confirmedInliers := ensemble vide pour chaque point dans les données, faites 
si le point correspond peut-être au modèle avec une erreur inférieure à t alors ajouter un point aux inliers confirmés fin si 
fin pour 
si le nombre d'éléments dans confirmedInliers est > d alors // Cela implique que nous avons peut-être trouvé un bon modèle. // Testez maintenant à quel point c'est bon. betterModel := paramètres du modèle ajustés à tous les points dans confirmedInliers thisErr := une mesure de la façon dont betterModel s'adapte à ces points si thisErr < bestErr alors meilleurAjustement := meilleurModèle meilleureErr := cetteErr fin si 
fin si incrémenter les itérations fin pendant que
retour bestFit 

Une implémentation Python reflétant le pseudo-code. Cela définit également une méthode LinearRegressorbasée sur les moindres carrés, s'applique RANSACà un problème de régression 2D et visualise le résultat :

à partir de 
copier 
importer 
copier 
importer 
numpy 
comme 
np 
à partir de 
numpy.random 
importer 
default_rng 
rng 
= 
default_rng ()
classe 
RANSAC : 
def 
__init__ ( self , 
n = 10 , 
k = 100 , 
t = 0.05 , 
d = 10 , 
model = None , 
loss = None , 
metric = None ): 
self . n 
= 
n 
# `n` : nombre minimal de points de données pour estimer les paramètres 
self . k 
= 
k 
# `k` : nombre maximal d'itérations autorisées 
self . t 
= 
t 
# `t` : valeur seuil pour déterminer si les points sont bien ajustés 
self . d 
= 
d 
# `d` : nombre de points de données proches requis pour affirmer que le modèle s'ajuste bien 
self . model 
= 
model 
# `model` : classe implémentant `fit` et `predict` 
self . loss 
= 
loss 
# `loss` : fonction de `y_true` et `y_pred` qui renvoie un vecteur 
self . metric 
= 
metric 
# `metric` : fonction de `y_true` et `y_pred` et renvoie un float 
self . best_fit 
= 
None 
self . best_error 
= 
np . inf
def 
fit ( self , 
X , 
y ): 
pour 
_ 
dans 
la plage ( self . k ): 
ids 
= 
rng . permutation ( X . shape [ 0 ])
peut - être_inliers = 
ids [: 
self.n ] peut -être_model = copy ( self.model ) .fit ( X [ peut -être_inliers ] , y [ peut-être_inliers ])
seuillé 
= 
( 
self . loss ( y [ ids ][ self . n 
:], 
maybe_model . predict ( X [ ids ][ self . n 
:])) 
< 
self . t 
)
inlier_ids 
= 
ids [ self . n 
:][ np . flatnonzero ( avec seuil ) . flatten ()]
si 
inlier_ids.size > self.d : inlier_points = np.hstack ( [ maybe_inliers , inlier_ids ] ) better_model = copy ( self.model ) .fit ( X [ inlier_points ] , y [ inlier_points ] )​​​​​
cette_erreur 
= 
self.metric ( y [ inlier_points ] , better_model.predict ( X [ inlier_points ] ) )​​
si 
cette_erreur 
< 
self . meilleure_erreur : 
self . meilleure_erreur 
= 
cette_erreur 
self . meilleur_ajustement 
= 
meilleur_modèle
retour 
à soi-même
def 
predict ( self , 
X ) : 
renvoie 
self.best_fit.predict ( X )​​​
def 
square_error_loss ( y_true , 
y_pred ): 
retour 
( y_true 
- 
y_pred ) 
** 
2
def 
mean_square_error ( y_true , 
y_pred ) : 
return 
np.sum ( square_error_loss ( y_true , y_pred ) ) / y_true.shape [ 0 ]​​
classe 
LinearRegressor : 
def 
__init__ ( self ): 
self . params 
= 
None
def 
fit ( self , 
X : 
np.ndarray , y : np.ndarray ) : r , _ = X.shape X = np.hstack ( [ np.ones ( ( r , 1 ) ) , X ] ) self.params = np.linalg.inv ( X.T@X ) @ X.T @ y return self​​​​​​​​​​​​​​​​
def 
prédire ( self , 
X : 
np . ndarray ): 
r , 
_ 
= 
X . shape 
X 
= 
np . hstack ([ np . ones (( r , 
1 )), 
X ]) 
retourner 
X 
@ 
self . params
si 
__name__ 
== 
"__main__" :
régresseur 
= 
RANSAC ( modèle = LinearRegressor (), 
perte = square_error_loss , 
métrique = mean_square_error )
X 
= 
np . tableau ([ - 0,848 , - 0,800 , - 0,704 , - 0,632 , - 0,488 , - 0,472 , - 0,368 , - 0,336 , - 0,280 , - 0,200 , - 0,00800 , - 0,0840 , 0,0240 , 0,100 , 0,124 , 0,148 , 0,232 , 0,236 , 0,324 , 0,356 , 0,368 , 0,440 , 0,512 , 0,548 , 0,660 , 0,640 , 0,712 , 0,752 , 0,776 , 0,880 , 0,920 , 0,944 , - 0,108 , - 0,168 , - 0,720 , - 0,784 , - 0,224 , - 0,604 , - 0,740 , - 0,0440 , 0,388 , - 0,0200 , 0,752 , 0,416 , - 0,0800 , - 0,348 , 0,988 , 0,776 , 0,680 , 0,880 , - 0,816 , - 0,424 , - 0,932 , 0,272 , - 0,556 , - 0,568 , - 0,600 , - 0,716 , - 0,796 , - 0,880 , - 0,972 , - 0,916 , 0,816 , 0,892 , 0,956 , 0,980 , 0,988 , 0,992 , 0,00400 ]) . reshape ( - 1 , 1 ) 
y 
= 
np . array ([- 0,917 , - 0,833 , - 0,801 , - 0,665 , - 0,605 , - 0,545 , - 0,509 , - 0,433 , - 0,397 , - 0,281 , - 0,205 , - 0,169 , - 0,0531 , - 0,0651 , 0,0349 , 0,0829 , 0,0589 , 0,175 , 0,179 , 0,191 , 0,259 , 0,287 , 0,359 , 0,395 , 0,483 , 0,539 , 0,543 , 0,603 , 0,667 , 0,679 , 0,751 , 0,803 , - 0,265 , - 0,341 , 0,111 , - 0,113 , 0,547 , 0,791 , 0,551 , 0,347 , 0,975 , 0,943 , - 0,249 , - 0,769 , - 0,625 , - 0,861 , - 0,749 , - 0,945 , - 0,493 , 0,163 , - 0,469 , 0,0669 , 0,891 , 0,623 , - 0,609 , - 0,677 , - 0,721 , - 0,745 , - 0,885 , - 0,897 , - 0,969 , - 0,949 , 0,707 , 0,783 , 0,859 , 0,979 , 0,811 , 0,891 , - 0,137 ]) . remodeler ( - 1 , 1 )
régresseur . fit ( X , 
y )
importer 
matplotlib.pyplot 
comme 
plt 
plt . style . use ( "seaborn-darkgrid" ) 
fig , 
ax 
= 
plt . subplots ( 1 , 
1 ) 
ax . set_box_aspect ( 1 )
plt . dispersion ( X , 
y )
ligne 
= 
np . linspace ( - 1 , 
1 , 
num = 100 ) . reshape ( - 1 , 
1 ) 
plt . plot ( ligne , 
regressor . predict ( ligne ), 
c ​​= "peru" ) 
plt . show ()

La valeur seuil pour déterminer quand un point de données s'adapte à un modèle ( t ) et le nombre d'inliers (points de données ajustés au modèle dans un délai de t ) requis pour affirmer que le modèle s'adapte bien aux données ( d ) sont déterminés en fonction des exigences spécifiques de l'application et de l'ensemble de données, et éventuellement en fonction d'une évaluation expérimentale. Le nombre d'itérations ( k ) peut cependant être déterminé approximativement en fonction de la probabilité de succès souhaitée ( p ) comme indiqué ci-dessous.

Soit p la probabilité souhaitée que l'algorithme RANSAC fournisse au moins un résultat utile après exécution. Dans l'extrême (pour simplifier la dérivation), RANSAC renvoie un résultat positif si, dans une certaine itération, il sélectionne uniquement des inliers dans l'ensemble de données d'entrée lorsqu'il choisit n points dans l'ensemble de données à partir duquel les paramètres du modèle sont estimés. (En d'autres termes, tous les n points de données sélectionnés sont des inliers du modèle estimé par ces points). Soit la probabilité de choisir un inlier chaque fois qu'un seul point de données est sélectionné, c'est-à-dire approximativement,

Un cas courant est celui qui n'est pas bien connu à l'avance en raison d'un nombre inconnu d'inliers dans les données avant d'exécuter l'algorithme RANSAC, mais une valeur approximative peut être donnée. Avec une valeur approximative donnée de et en supposant approximativement que les n points nécessaires à l'estimation d'un modèle sont sélectionnés indépendamment (c'est une hypothèse approximative car chaque sélection de point de données réduit le nombre de points de données candidats à choisir dans la sélection suivante en réalité), est la probabilité que tous les n points soient des inliers et est la probabilité qu'au moins un des n points soit une valeur aberrante, un cas qui implique qu'un mauvais modèle sera estimé à partir de cet ensemble de points. Cette probabilité à la puissance k (le nombre d'itérations dans l'exécution de l'algorithme) est la probabilité que l'algorithme ne sélectionne jamais un ensemble de n points qui sont tous des inliers, et c'est la même chose que (la probabilité que l'algorithme n'aboutisse pas à une estimation réussie du modèle) à l'extrême. Par conséquent,

ce qui, après avoir pris le logarithme des deux côtés, conduit à

Ce résultat suppose que les n points de données sont sélectionnés indépendamment, c'est-à-dire qu'un point qui a été sélectionné une fois est remplacé et peut être sélectionné à nouveau dans la même itération. Cette approche n'est souvent pas raisonnable et la valeur dérivée de k doit être considérée comme une limite supérieure dans le cas où les points sont sélectionnés sans remplacement. Par exemple, dans le cas de la recherche d'une ligne qui correspond à l'ensemble de données illustré dans la figure ci-dessus, l'algorithme RANSAC choisit généralement deux points à chaque itération et calcule maybe_modelcomme ligne entre les points ; il est alors essentiel que les deux points soient distincts.

Pour obtenir une confiance supplémentaire, l' écart type ou ses multiples peuvent être ajoutés à k . L'écart type de k est défini comme

L'un des avantages de RANSAC est sa capacité à réaliser une estimation robuste des paramètres du modèle, c'est-à-dire qu'il peut estimer les paramètres avec un degré élevé de précision même lorsqu'un nombre significatif de valeurs aberrantes sont présentes dans l'ensemble de données. L'inconvénient de RANSAC est qu'il n'y a pas de limite supérieure au temps nécessaire pour calculer ces paramètres (à l'exception de l'épuisement). Lorsque le nombre d'itérations calculées est limité, la solution obtenue peut ne pas être optimale, et peut même ne pas être celle qui s'adapte bien aux données. De cette façon, RANSAC offre un compromis : en calculant un plus grand nombre d'itérations, la probabilité de produire un modèle raisonnable est augmentée. De plus, RANSAC n'est pas toujours capable de trouver l'ensemble optimal même pour les ensembles modérément contaminés, et il fonctionne généralement mal lorsque le nombre de valeurs aberrantes est inférieur à 50 %. Le RANSAC optimal a été proposé pour traiter ces deux problèmes et est capable de trouver l'ensemble optimal pour les ensembles fortement contaminés, même pour un taux de valeurs aberrantes inférieur à 5 %. Un autre inconvénient du RANSAC est qu’il nécessite la définition de seuils spécifiques au problème.

RANSAC ne peut estimer qu'un seul modèle pour un ensemble de données particulier. Comme pour toute approche à modèle unique lorsque deux (ou plusieurs) instances de modèle existent, RANSAC peut ne pas en trouver une. La transformation de Hough est une autre technique d'estimation robuste qui peut être utile lorsque plusieurs instances de modèle sont présentes. Une autre approche pour l'ajustement multi-modèle est connue sous le nom de PEARL, qui combine l'échantillonnage de modèles à partir de points de données comme dans RANSAC avec une réestimation itérative des inliers et l'ajustement multi-modèle formulé comme un problème d'optimisation avec une fonction d'énergie globale décrivant la qualité de la solution globale.

L'algorithme RANSAC est souvent utilisé en vision par ordinateur , par exemple pour résoudre simultanément le problème de correspondance et estimer la matrice fondamentale liée à une paire de caméras stéréo ; voir également : Structure à partir du mouvement , transformation de caractéristiques invariantes à l'échelle , assemblage d'images , segmentation de mouvement rigide .

Depuis 1981, RANSAC est devenu un outil fondamental dans la communauté de la vision par ordinateur et du traitement d'images. En 2006, pour le 25e anniversaire de l'algorithme, un atelier a été organisé lors de la Conférence internationale sur la vision par ordinateur et la reconnaissance de formes (CVPR) pour résumer les contributions et les variations les plus récentes de l'algorithme original, principalement destinées à améliorer la vitesse de l'algorithme, la robustesse et la précision de la solution estimée et à diminuer la dépendance aux constantes définies par l'utilisateur.

RANSAC peut être sensible au choix du seuil de bruit correct qui définit quels points de données correspondent à un modèle instancié avec un certain ensemble de paramètres. Si ce seuil est trop grand, alors toutes les hypothèses ont tendance à être classées de manière égale (bonnes). D'autre part, lorsque le seuil de bruit est trop petit, les paramètres estimés ont tendance à être instables (c'est-à-dire qu'en ajoutant ou en supprimant simplement une donnée à l'ensemble des inliers, l'estimation des paramètres peut fluctuer). Pour compenser partiellement cet effet indésirable, Torr et al. ont proposé deux modifications de RANSAC appelées MSAC (M-estimator Sample and Consensus) et MLESAC (Maximum Likelihood Estimation Sample and Consensus). L'idée principale est d'évaluer la qualité de l'ensemble de consensus (c'est-à-dire les données qui correspondent à un modèle et à un certain ensemble de paramètres) en calculant sa vraisemblance (alors que dans la formulation originale de Fischler et Bolles, le rang était la cardinalité de cet ensemble). Tordoff a proposé une extension de MLESAC qui prend en compte les probabilités a priori associées à l'ensemble de données d'entrée. L'algorithme résultant est appelé Guided-MLESAC. Dans la même optique, Chum a proposé de guider la procédure d'échantillonnage si certaines informations a priori concernant les données d'entrée sont connues, c'est-à-dire si une donnée est susceptible d'être une valeur aberrante ou une valeur aberrante. L'approche proposée est appelée PROSAC, PROgressive SAmple Consensus.

Chum et al. ont également proposé une version randomisée de RANSAC appelée R-RANSAC pour réduire la charge de calcul nécessaire à l'identification d'un bon ensemble de consensus. L'idée de base est d'évaluer initialement la qualité du modèle actuellement instancié en utilisant uniquement un ensemble réduit de points au lieu de l'ensemble de données. Une stratégie solide indiquera avec une grande confiance quand il est nécessaire d'évaluer l'ajustement de l'ensemble de données ou quand le modèle peut être facilement rejeté. Il est raisonnable de penser que l'impact de cette approche est plus pertinent dans les cas où le pourcentage d'inliers est important. Le type de stratégie proposé par Chum et al. est appelé schéma de préemption. Nistér a proposé un paradigme appelé Preemptive RANSAC qui permet une estimation robuste en temps réel de la structure d'une scène et du mouvement de la caméra. L'idée centrale de l'approche consiste à générer un nombre fixe d'hypothèses afin que la comparaison se fasse par rapport à la qualité de l'hypothèse générée plutôt que par rapport à une mesure de qualité absolue.

D'autres chercheurs ont tenté de faire face à des situations difficiles où l'échelle de bruit n'est pas connue et/ou où plusieurs instances de modèles sont présentes. Le premier problème a été abordé dans les travaux de Wang et Suter. Toldo et al. représentent chaque donnée avec la fonction caractéristique de l'ensemble des modèles aléatoires qui correspondent au point. Ensuite, plusieurs modèles sont révélés sous forme de clusters qui regroupent les points supportant le même modèle. L'algorithme de clustering, appelé J-linkage, ne nécessite pas de spécification préalable du nombre de modèles, ni de réglage manuel des paramètres.

RANSAC a également été adapté aux applications d'estimation d'état récursives, où les mesures d'entrée sont corrompues par des valeurs aberrantes et les approches de filtre de Kalman , qui reposent sur une distribution gaussienne de l'erreur de mesure, sont vouées à l'échec. Une telle approche est appelée KALMANSAC.

• MLESAC (Maximum Likelihood Estimate Sample Consensus) – maximise la probabilité que les données aient été générées à partir du modèle ajusté à l'échantillon, par exemple un modèle mixte de valeurs aberrantes et de valeurs aberrantes
• MAPSAC (Maximum A Posterior Sample Consensus) – étend MLESAC pour incorporer une probabilité a priori des paramètres à ajuster et maximise la probabilité a posteriori
• KALMANSAC – inférence causale de l'état d'un système dynamique
• Rééchantillonnage (statistiques)
• La méthode Monte Carlo Hop-Diffusion utilise un échantillonnage aléatoire impliquant des sauts globaux et une diffusion locale pour choisir l'échantillon à chaque étape de RANSAC pour l'estimation de la géométrie épipolaire entre des images à très large base.
• FSASAC (RANSAC basé sur le filtrage des données et le recuit simulé )