5 algorithmes d'échantillonnage principaux


Travailler avec des données - travailler avec des algorithmes de traitement des données.


Et comme je devais travailler quotidiennement avec les plus divers, j'ai décidé de faire une liste des plus populaires dans une série de publications.


Cet article se concentre sur les techniques d'échantillonnage les plus courantes pour travailler avec des données.





Échantillonnage aléatoire simple


Supposons que vous souhaitiez effectuer une sélection où chaque élément a une probabilité égale d'être sélectionné.


Ci-dessous, nous sélectionnons 100 de ces éléments dans l'ensemble de données.


sample_df = df.sample(100) 



Échantillonnage stratifié



Supposons que nous devions estimer le nombre moyen de votes pour chaque candidat à l'élection. Le vote a lieu dans trois villes:


1 million de travailleurs vivent dans la ville A


2 millions d'artistes vivent dans la ville B


3 millions de seniors vivent dans la ville C


Si nous essayons de prélever des échantillons tout aussi probables de 60 personnes dans l'ensemble de la population, ils seront sûrement déséquilibrés par rapport aux différentes villes, et donc biaisés, ce qui entraînera une grave erreur dans les prévisions.


Si nous faisons spécifiquement un échantillon de 10, 20 et 30 personnes des villes A , B et C, respectivement, l'erreur sera minime.


En Python, cela peut être fait comme ceci:


 from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.25) 



Échantillonnage en réservoir



J'aime cette formulation du problème:


Supposons que vous disposiez d'un flux d'éléments de grande taille inconnue que vous ne pouvez répéter qu'une seule fois.


Créez un algorithme qui sélectionne au hasard un élément du flux comme si n'importe quel élément pouvait être sélectionné avec une probabilité égale.


Comment faire


Supposons que nous devions sélectionner 5 objets dans un flux infini, de sorte que chaque élément du flux puisse être sélectionné de la même manière.


 import random def generator(max): number = 1 while number < max: number += 1 yield number #    stream = generator(10000) #    k=5 reservoir = [] for i, element in enumerate(stream): if i+1<= k: reservoir.append(element) else: probability = k/(i+1) if random.random() < probability: #    ,    reservoir[random.choice(range(0,k))] = element print(reservoir) ------------------------------------ [1369, 4108, 9986, 828, 5589] 

Il est mathématiquement possible de prouver que chaque élément pourrait être choisi également probable.


Comment?


En ce qui concerne les mathématiques, il est préférable d'essayer de démarrer la solution avec un petit cas spécial.


Examinons donc un flux composé de 3 éléments, où nous devons n'en sélectionner que 2.


Nous voyons le premier élément, enregistrez-le dans la liste, car il y a encore de l'espace dans le réservoir. Nous voyons le deuxième élément, enregistrez-le dans la liste, car il y a encore de la place dans le réservoir.


Nous voyons le troisième élément. Cela devient plus intéressant ici. Nous enregistrerons le troisième élément avec une probabilité de 2/3.


Voyons maintenant la probabilité finale de sauvegarde du premier élément:


La probabilité de déplacement du premier élément du réservoir est égale à la probabilité que le troisième élément soit sélectionné, multiplié par la probabilité que le premier élément des deux soit sélectionné pour le déplacement. Soit:


2/3 * 1/2 = 1/3


Autrement dit, la probabilité finale du premier élément à enregistrer:


1 - 1/3 = 2/3


Absolument la même logique peut être appliquée au deuxième élément, en l'étendant à l'avenir à un plus grand nombre d'éléments avec un réservoir croissant.


Autrement dit, chaque élément sera enregistré avec une probabilité de 2/3 ou dans le cas général k / n .




Sous-échantillonnage et suréchantillonnage aléatoires


Source

Trop souvent dans la vie, il existe des ensembles de données déséquilibrés.


La méthode qui est largement utilisée dans ce cas s'appelle le rééchantillonnage (parfois ils disent «rééchantillonnage» dans la traduction russe - environ la traduction) . Son essence consiste soit à supprimer des éléments d'un ensemble trop grand (sous-échantillonnage) et / ou à ajouter plus d'éléments à un ensemble insuffisamment grand (suréchantillonnage).


Commençons par créer des ensembles déséquilibrés.


 from sklearn.datasets import make_classification X, y = make_classification( n_classes=2, class_sep=1.5, weights=[0.9, 0.1], n_informative=3, n_redundant=1, flip_y=0, n_features=20, n_clusters_per_class=1, n_samples=100, random_state=10 ) X = pd.DataFrame(X) X['target'] = y 

Maintenant, nous pouvons effectuer un sous-échantillonnage et un suréchantillonnage aléatoires comme ceci:


 num_0 = len(X[X['target']==0]) num_1 = len(X[X['target']==1]) print(num_0,num_1) #   undersampled_data = pd.concat([ X[X['target']==0].sample(num_1) , X[X['target']==1] ]) print(len(undersampled_data)) #   oversampled_data = pd.concat([ X[X['target']==0] , X[X['target']==1].sample(num_0, replace=True) ]) print(len(oversampled_data)) ------------------------------------------------------------ OUTPUT: 90 10 20 180 



Andersampling et suréchantillonnage utilisant déséquilibré-apprendre


imbalanced -learn (imblearn) est une bibliothèque python pour traiter les problèmes des ensembles de données non équilibrés.


Il contient plusieurs méthodes différentes de rééchantillonnage.


a. Andersampling à l'aide des liens Tomek:


L'une des méthodes fournies s'appelle Tomek Links. Dans ce cas, les «liens» sont des paires d'éléments de différentes classes qui se trouvent à proximité.


En utilisant l'algorithme, nous finirons par supprimer l'élément paire du plus grand ensemble, ce qui permettra au classificateur de mieux fonctionner.


Source


 from imblearn.under_sampling import TomekLinks tl = TomekLinks(return_indices=True, ratio='majority') X_tl, y_tl, id_tl = tl.fit_sample(X, y) 

b. Suréchantillonnage avec SMOTE:


Dans SMOTE (Synthesis Minority Oversampling Method), nous créons des éléments à proximité des éléments existants dans un ensemble plus petit.


Source
 from imblearn.over_sampling import SMOTE smote = SMOTE(ratio='minority') X_sm, y_sm = smote.fit_sample(X, y) 

Mais dans imblearn, il existe d'autres moyens de sous-échantillonnage (Cluster Centroids, NearMiss, etc.) et de suréchantillonnage (ADASYN et bSMOTE), qui peuvent également être utiles.




Conclusion


Les algorithmes sont le sang de la science des données.


L'échantillonnage est l'un des domaines les plus importants pour travailler avec des données, et seul un aperçu superficiel est donné ci-dessus.


Une stratégie d'échantillonnage bien choisie peut entraîner tout le projet. Une mauvaise sélection conduit à des résultats erronés. Par conséquent, le choix doit être fait avec sagesse.

Source: https://habr.com/ru/post/fr461285/


All Articles