Corrélation avec Python – Real Python

By | décembre 23, 2019

Formation gratuite Python

Coefficients de corrélation quantifier l'association entre les variables ou les caractéristiques d'un ensemble de données. Ces statistiques sont d'une grande importance pour la science et la technologie, et Python dispose d'excellents outils que vous pouvez utiliser pour les calculer. Les méthodes de corrélation SciPy, NumPy et Pandas sont rapides, complètes et bien documentées.

Dans ce didacticiel, vous apprendrez:

  • Ce que Pearson, Spearman et Kendall coefficients de corrélation sont
  • Comment utiliser SciPy, NumPy et Pandas fonctions de corrélation
  • Comment visualiser données, lignes de régression et matrices de corrélation avec Matplotlib

Vous commencerez par une explication de la corrélation, puis verrez trois exemples d'introduction rapides, et enfin vous plongerez dans les détails de la corrélation NumPy, SciPy et Pandas.

Corrélation

Les statistiques et la science des données sont souvent préoccupées par les relations entre deux ou plusieurs variables (ou caractéristiques) d'un ensemble de données. Chaque point de données de l'ensemble de données est un observation, et le Caractéristiques sont les propriétés ou les attributs de ces observations.

Chaque ensemble de données avec lequel vous travaillez utilise des variables et des observations. Par exemple, vous pourriez être intéressé à comprendre les éléments suivants:

Dans les exemples ci-dessus, la taille, la précision de la prise de vue, les années d'expérience, le salaire, la densité de la population et le produit intérieur brut sont les caractéristiques ou les variables. Les données relatives à chaque joueur, employé et chaque pays sont les observations.

Lorsque les données sont représentées sous la forme d'un tableau, les lignes de ce tableau sont généralement les observations, tandis que les colonnes sont les entités. Jetez un œil à cette table des employés:

Nom des années d'expérience Salaire annuel
Ann 30 120 000
Rob 21 105 000
À M 19 90 000
Lierre dix 82 000

Dans ce tableau, chaque ligne représente une observation ou les données d'un employé (Ann, Rob, Tom ou Ivy). Chaque colonne affiche une propriété ou une fonction (nom, expérience ou salaire) pour tous les employés.

Si vous analysez deux caractéristiques d'un ensemble de données, vous trouverez un type de corrélation entre ces deux caractéristiques. Considérez les figures suivantes:

mmst-py-corr-1

Chacun de ces graphiques montre l'une des trois différentes formes de corrélation:

  1. Corrélation négative (points rouges): Dans le graphique de gauche, les valeurs y ont tendance à diminuer à mesure que les valeurs x augmentent. Cela montre une forte corrélation négative, qui se produit lorsque grand les valeurs d'une caractéristique correspondent à petit valeurs de l'autre, et vice versa.

  2. Corrélation faible ou inexistante (points verts): L'intrigue au milieu ne montre aucune tendance évidente. Il s'agit d'une forme de faible corrélation, qui se produit lorsqu'une association entre deux caractéristiques n'est pas évidente ou est à peine observable.

  3. Corrélation positive (points bleus): Dans le graphique de droite, les valeurs y ont tendance à augmenter à mesure que les valeurs x augmentent. Cela illustre une forte corrélation positive, qui se produit lorsque grand les valeurs d'une caractéristique correspondent à grand valeurs de l'autre, et vice versa.

La figure suivante représente les données du tableau des employés ci-dessus:

mmst-py-corr-6

La corrélation entre l'expérience et le salaire est positive car une expérience plus élevée correspond à un salaire plus élevé et vice versa.

La corrélation est étroitement liée à d'autres quantités statistiques comme la moyenne, l'écart type, la variance et la covariance. Si vous souhaitez en savoir plus sur ces quantités et comment les calculer avec Python, consultez les statistiques descriptives avec Python.

Il existe plusieurs statistiques que vous pouvez utiliser pour quantifier la corrélation. Dans ce didacticiel, vous découvrirez trois coefficients de corrélation:

Le coefficient de Pearson mesure la corrélation linéaire, tandis que les coefficients Spearman et Kendall comparent les rangs de données. Il existe plusieurs fonctions et méthodes de corrélation NumPy, SciPy et Pandas que vous pouvez utiliser pour calculer ces coefficients. Vous pouvez également utiliser Matplotlib pour illustrer facilement les résultats.

Exemple: calcul de corrélation NumPy

NumPy possède de nombreuses routines de statistiques, notamment np.corrcoef (), qui renvoient une matrice de coefficients de corrélation de Pearson. Vous pouvez commencer par importer NumPy et définir deux tableaux NumPy. Ce sont des instances de la classe ndarray. Appelle les X et y:

>>>

>>> importation engourdi comme np
>>> X = np.arange(dix, 20)
>>> X
tableau ([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
>>> y = np.tableau([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])
>>> y
tableau ([ 2,  1,  4,  5,  8, 12, 18, 25, 96, 48])

Ici, vous utilisez np.arange () créer un tableau X d'entiers compris entre 10 (inclus) et 20 (exclusif). Ensuite, vous utilisez np.array () pour créer un deuxième tableau y contenant des entiers arbitraires.

Une fois que vous avez deux tableaux de la même longueur, vous pouvez appeler np.corrcoef () avec les deux tableaux comme arguments:

>>>

>>> r = np.corrcoef(X, y)
>>> r
tableau ([[1.        , 0.75864029],
       [0.75864029, 1.        ]])
>>> r[[[[0, 1]
0,7586402890911867
>>> r[[[[1, 0]
0,7586402890911869

corrcoef () renvoie la matrice de corrélation, qui est un tableau à deux dimensions avec les coefficients de corrélation. Voici une version simplifiée de la matrice de corrélation que vous venez de créer:

                                x y

x 1,00 0,76
y 0,76 1,00

Les valeurs sur la diagonale principale de la matrice de corrélation (en haut à gauche et en bas à droite) sont égales à 1. La valeur en haut à gauche correspond au coefficient de corrélation pour X et X, tandis que la valeur inférieure droite est le coefficient de corrélation pour y et y. Ils sont toujours égaux à 1.

Cependant, vous avez généralement besoin des valeurs inférieures gauche et supérieure droite de la matrice de corrélation. Ces valeurs sont égales et représentent toutes deux la Coefficient de corrélation de Pearson pour X et y. Dans ce cas, c'est environ 0,76.

Cette figure montre les points de données et les coefficients de corrélation pour l'exemple ci-dessus:

mmst-py-corr-5

Les carrés rouges sont les points de données. Comme vous pouvez le voir, la figure montre également les valeurs des trois coefficients de corrélation.

Exemple: calcul de corrélation SciPy

SciPy possède également de nombreuses routines de statistiques contenues dans scipy.stats. Vous pouvez utiliser les méthodes suivantes pour calculer les trois coefficients de corrélation que vous avez vus précédemment:

Voici comment utiliser ces fonctions en Python:

>>>

>>> importation engourdi comme np
>>> importation scipy.stats
>>> X = np.arange(dix, 20)
>>> y = np.tableau([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])
>>> scipy.Statistiques.pearsonr(X, y)    # R de Pearson
(0,7586402890911869, 0,010964341301680832)
>>> scipy.Statistiques.spearmanr(X, y)   # Rho de Spearman
SpearmanrResult (corrélation = 0,9757575757575757, pvalue = 1,4675461874042197e-06)
>>> scipy.Statistiques.kendalltau(X, y)  # Tau de Kendall
KendalltauResult (corrélation = 0,911111111111111, pvalue = 2,9761904761904762e-05)

Notez que ces fonctions renvoient des objets qui contiennent deux valeurs:

  1. Le coefficient de corrélation
  2. La valeur p

Vous utilisez le valeur p dans les méthodes statistiques lorsque vous testez une hypothèse. La valeur de p est une mesure importante qui nécessite une connaissance approfondie des probabilités et des statistiques pour interpréter. Pour en savoir plus à leur sujet, vous pouvez lire les principes de base ou consulter l'explication d'un data scientist sur les valeurs de p.

Vous pouvez extraire les valeurs de p et les coefficients de corrélation avec leurs indices, comme les éléments de tuples:

>>>

>>> scipy.Statistiques.pearsonr(X, y)[[[[0]    # R de Pearson
0,7586402890911869
>>> scipy.Statistiques.spearmanr(X, y)[[[[0]   # Rho de Spearman
0,9757575757575757
>>> scipy.Statistiques.kendalltau(X, y)[[[[0]  # Tau de Kendall
0,91111111111111111

Vous pouvez également utiliser la notation par points pour les coefficients Spearman et Kendall:

>>>

>>> scipy.Statistiques.spearmanr(X, y).corrélation   # Rho de Spearman
0,9757575757575757
>>> scipy.Statistiques.kendalltau(X, y).corrélation  # Tau de Kendall
0,91111111111111111

La notation par points est plus longue, mais elle est également plus lisible et plus explicite.

Si vous souhaitez obtenir simultanément le coefficient de corrélation de Pearson et la valeur de p, vous pouvez décompresser la valeur de retour:

>>>

>>> r, p = scipy.Statistiques.pearsonr(X, y)
>>> r
0,7586402890911869
>>> p
0,010964341301680829

Cette approche exploite le déballage de Python et le fait que pearsonr () renvoie un tuple avec ces deux statistiques. Vous pouvez également utiliser cette technique avec spearmanr () et kendalltau (), comme vous le verrez plus tard.

Exemple: calcul de corrélation de Pandas

Pandas est, dans certains cas, plus pratique que NumPy et SciPy pour le calcul des statistiques. Il propose des méthodes statistiques pour Séries et Trame de données instances. Par exemple, étant donné deux Séries objets avec le même nombre d'articles, vous pouvez appeler .corr () sur l'un d'eux avec l'autre comme premier argument:

>>>

>>> importation pandas comme pd
>>> X = pd.Séries(intervalle(dix, 20))
>>> X
0 10
1 11
2 12
3 13
4 14
5 15
6 16
7 17
8 18
9 19
dtype: int64
>>> y = pd.Séries([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])
>>> y
0 2
1 1
2 4
3 5
4 8
5 12
6 18
7 25
8 96
9 48
dtype: int64
>>> X.corr(y)                     # R de Pearson
0,7586402890911867
>>> y.corr(X)
0,7586402890911869
>>> X.corr(y, méthode='lancier')  # Rho de Spearman
0,9757575757575757
>>> X.corr(y, méthode=«kendall»)   # Tau de Kendall
0,91111111111111111

Ici, vous utilisez .corr () pour calculer les trois coefficients de corrélation. Vous définissez la statistique souhaitée avec le paramètre méthode, qui peut prendre plusieurs valeurs:

  • «Pearson»
  • 'lancier'
  • «kendall»
  • un appelable

L'appelable peut être n'importe quelle fonction, méthode ou objet avec .__appel__() qui accepte deux tableaux unidimensionnels et renvoie un nombre à virgule flottante.

Corrélation linéaire

Corrélation linéaire mesure la proximité de la relation mathématique entre des variables ou des entités de jeu de données à une fonction linéaire. Si la relation entre les deux caractéristiques est plus proche d'une fonction linéaire, alors leur corrélation linéaire est plus forte et la valeur absolue du coefficient de corrélation est plus élevée.

Coefficient de corrélation de Pearson

Prenons un ensemble de données avec deux fonctionnalités: X et y. Chaque entité a n valeurs, donc X et y sont n-tuples. Disons que la première valeur x₁ de X correspond à la première valeur y₁ de y, la deuxième valeur x₂ de X à la deuxième valeur y₂ de y, etc. Ensuite, il y a n paires de valeurs correspondantes: (x₁, y₁), (x₂, y₂), etc. Chacune de ces paires x-y représente une seule observation.

le Coefficient de corrélation de Pearson (produit-moment) est une mesure de la relation linéaire entre deux entités. C’est le rapport de la covariance de X et y au produit de leurs écarts-types. Il est souvent désigné par la lettre r et appelé Pearson’s r. Vous pouvez exprimer cette valeur mathématiquement avec cette équation:

r = Σᵢ ((xᵢ – moyenne (x)) (yᵢ – moyenne (y))) (√Σᵢ (xᵢ – moyenne (x)) ² √Σᵢ (yᵢ – moyenne (y)) ²) ⁻¹

Ici, je prend les valeurs 1, 2,…, n. Les valeurs moyennes de X et y sont désignés par la moyenne (x) et la moyenne (y). Cette formule montre que si des valeurs x plus grandes ont tendance à correspondre à des valeurs y plus grandes et vice versa, alors r est positif. D'un autre côté, si des valeurs x plus grandes sont principalement associées à des valeurs y plus petites et vice versa, alors r est négatif.

Voici quelques faits importants sur le coefficient de corrélation de Pearson:

  • Le coefficient de corrélation de Pearson peut prendre n'importe quelle valeur réelle dans la plage −1 ≤ r ≤ 1.

  • La valeur maximale r = 1 correspond au cas où il existe une relation linéaire positive parfaite entre X et y. En d'autres termes, des valeurs x plus grandes correspondent à des valeurs y plus grandes et vice versa.

  • La valeur r> 0 indique une corrélation positive entre X et y.

  • La valeur r = 0 correspond au cas où X et y sont indépendants.

  • La valeur r <0 indique une corrélation négative entre X et y.

  • La valeur minimale r = -1 correspond au cas où il existe une parfaite relation linéaire négative entre X et y. En d'autres termes, des valeurs x plus grandes correspondent à des valeurs y plus petites et vice versa.

Les faits ci-dessus peuvent être résumés dans le tableau suivant:

Valeur r de Pearson Corrélation entre X et y
égal à 1 relation linéaire positive parfaite
supérieur à 0 correlation positive
égal à 0 indépendant
moins de 0 corrélation négative
égal à -1 relation linéaire négative parfaite

En bref, une valeur absolue plus grande de r indique une corrélation plus forte, plus proche d'une fonction linéaire. Une valeur absolue plus petite de r indique une corrélation plus faible.

Régression linéaire: implémentation de SciPy

La régression linéaire est le processus de recherche de la fonction linéaire la plus proche possible de la relation réelle entre les entités. En d'autres termes, vous déterminez la fonction linéaire qui décrit le mieux l'association entre les entités. Cette fonction linéaire est également appelée ligne de régression.

Vous pouvez implémenter une régression linéaire avec SciPy. Vous obtiendrez la fonction linéaire qui correspond le mieux à la relation entre deux tableaux, ainsi que le coefficient de corrélation de Pearson. Pour commencer, vous devez d'abord importer les bibliothèques et préparer certaines données avec lesquelles travailler:

>>>

>>> importation engourdi comme np
>>> importation scipy.stats
>>> X = np.arange(dix, 20)
>>> y = np.tableau([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])

Ici, vous importez engourdi et scipy.stats et définir les variables X et y.

Vous pouvez utiliser scipy.stats.linregress () pour effectuer une régression linéaire pour deux tableaux de même longueur. Vous devez fournir les tableaux comme arguments et obtenir les sorties en utilisant la notation par points:

>>>

>>> résultat = scipy.Statistiques.linregress(X, y)
>>> résultat.pente
7.4363636363636365
>>> résultat.intercepter
-85,92727272727274
>>> résultat.rvalue
0,7586402890911869
>>> résultat.pvalue
0,010964341301680825
>>> résultat.stderr
2.257878767543913

C'est ça! Vous avez terminé la régression linéaire et obtenu les résultats suivants:

Vous apprendrez à visualiser ces résultats dans une section ultérieure.

Vous pouvez également fournir un seul argument à linregress (), mais il doit s'agir d'un tableau à deux dimensions avec une dimension de longueur deux:

>>>

>>> xy = np.tableau([[[[[[[[dix, 11, 12, 13, 14, 15, 16, 17, 18, 19],
...                [[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48]])
>>> scipy.Statistiques.linregress(xy)
LinregressResult (pente = 7,4363636363636365, intercept = -85,92727272727274, rvalue = 0,7586402890911869, pvalue = 0,010964341301680825, stderr = 2,25787876757543913)

Le résultat est exactement le même que dans l'exemple précédent car xy contient les mêmes données que X et y ensemble. linregress () a pris la première rangée de xy comme une caractéristique et la deuxième ligne comme l'autre caractéristique.

linregress () retournera le même résultat si vous fournissez la transposition de xyou un tableau NumPy avec 10 lignes et deux colonnes. Dans NumPy, vous pouvez transposer une matrice de plusieurs manières:

Voici comment vous pourriez transposer xy:

>>>

>>> xy.T
tableau ([[10,  2],
       [11,  1],
       [12,  4],
       [13,  5],
       [14,  8],
       [15, 12],
       [16, 18],
       [17, 25],
       [18, 96],
       [19, 48]])

Maintenant que vous savez comment obtenir la transposition, vous pouvez en passer une à linregress (). La première colonne sera une entité et la deuxième colonne l'autre entité:

>>>

>>> scipy.Statistiques.linregress(xy.T)
LinregressResult (pente = 7,4363636363636365, intercept = -85,92727272727274, rvalue = 0,7586402890911869, pvalue = 0,010964341301680825, stderr = 2,25787876757543913)

Ici, vous utilisez .T pour obtenir la transposition de xy. linregress () fonctionne de la même manière avec xy et sa transposition. Il extrait les entités en divisant le tableau le long de la dimension avec une longueur de deux.

Vous devez également prendre soin de noter si votre jeu de données contient ou non des valeurs manquantes. Dans la science des données et l'apprentissage automatique, vous trouverez souvent des données manquantes ou corrompues. La façon habituelle de le représenter en Python, NumPy, SciPy et Pandas est d'utiliser NaN ou Pas un chiffre valeurs. Mais si vos données contiennent nan valeurs, alors vous n'obtiendrez pas un résultat utile avec linregress ():

>>>

>>> scipy.Statistiques.linregress(np.arange(3), np.tableau([[[[2, np.nan, 5]))
LinregressResult (pente = nan, interception = nan, rvalue = nan, pvalue = nan, stderr = nan)

Dans ce cas, votre objet résultant renvoie tous nan valeurs. En Python, nan est une valeur à virgule flottante spéciale que vous pouvez obtenir en utilisant l'un des éléments suivants:

Vous pouvez également vérifier si une variable correspond à nan avec math.isnan () ou numpy.isnan ().

Corrélation Pearson: implémentation NumPy et SciPy

Vous avez déjà vu comment obtenir le coefficient de corrélation de Pearson avec corrcoef () et pearsonr ():

>>>

>>> r, p = scipy.Statistiques.pearsonr(X, y)
>>> r
0,7586402890911869
>>> p
0,010964341301680829
>>> np.corrcoef(X, y)
tableau ([[1.        , 0.75864029],
       [0.75864029, 1.        ]])

Notez que si vous fournissez un tableau avec un nan valeur à pearsonr (), vous obtiendrez un ValueError.

Il y a peu de détails supplémentaires à considérer. Tout d'abord, rappelez-vous que np.corrcoef () peut prendre deux tableaux NumPy comme arguments. Au lieu de cela, vous pouvez passer un seul tableau bidimensionnel avec les mêmes valeurs que l'argument:

>>>

>>> np.corrcoef(xy)
tableau ([[1.        , 0.75864029],
       [0.75864029, 1.        ]])

Les résultats sont les mêmes dans cet exemple et dans les exemples précédents. Encore une fois, la première rangée de xy représente une fonction, tandis que la deuxième ligne représente l'autre.

Si vous souhaitez obtenir les coefficients de corrélation pour trois entités, vous devez simplement fournir un tableau numérique à deux dimensions avec trois lignes comme argument:

>>>

>>> xyz = np.tableau([[[[[[[[dix, 11, 12, 13, 14, 15, 16, 17, 18, 19],
...                 [[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48],
...                 [[[[5, 3, 2, 1, 0, -2, -8, -11, -15, -16]])
>>> np.corrcoef(xyz)
tableau ([[ 1.        ,  0.75864029, -0.96807242],
       [ 0.75864029,  1.        , -0.83407922],
       [-0.96807242, -0.83407922,  1.        ]])

Vous obtiendrez à nouveau la matrice de corrélation, mais celle-ci sera plus grande que les précédentes:

                                    x y z

x 1,00 0,76 -0,97
y 0,76 1,00 -0,83
z -0,97 -0,83 1,00

Ceci est dû au fait corrcoef () considère chaque ligne de xyz comme une caractéristique. La valeur 0,76 est le coefficient de corrélation pour les deux premières caractéristiques de xyz. C'est le même que le coefficient pour X et y dans les exemples précédents. -0,97 représente le r de Pearson pour les première et troisième fonctions, tandis que -0,83 est le r de Pearson pour les deux dernières fonctionnalités.

Voici un exemple intéressant de ce qui se passe lorsque vous passez nan données à corrcoef ():

>>>

>>> arr_with_nan = np.tableau([[[[[[[[0, 1, 2, 3],
...                          [[[[2, 4, 1, 8],
...                          [[[[2, 5, np.nan, 2]])
>>> np.corrcoef(arr_with_nan)
tableau ([[1.        , 0.62554324,        nan],
       [0.62554324, 1.        ,        nan],
       [       nan,        nan,        nan]])

Dans cet exemple, les deux premières lignes (ou fonctions) de arr_with_nan ça va, mais la troisième rangée [2, 5, np.nan, 2] contient un nan valeur. Tout ce qui n'inclut pas la fonctionnalité avec nan est bien calculé. Cependant, les résultats qui dépendent de la dernière ligne sont nan.

Par défaut, numpy.corrcoef () considère les lignes comme des entités et les colonnes comme des observations. Si vous voulez le comportement opposé, qui est largement utilisé dans l'apprentissage automatique, utilisez l'argument rowvar = False:

>>>

>>> xyz.T
tableau ([[ 10,   2,   5],
       [ 11,   1,   3],
       [ 12,   4,   2],
       [ 13,   5,   1],
       [ 14,   8,   0],
       [ 15,  12,  -2],
       [ 16,  18,  -8],
       [ 17,  25, -11],
       [ 18,  96, -15],
       [ 19,  48, -16]])
>>> np.corrcoef(xyz.T, rowvar=Faux)
tableau ([[ 1.        ,  0.75864029, -0.96807242],
       [ 0.75864029,  1.        , -0.83407922],
       [-0.96807242, -0.83407922,  1.        ]])

Ce tableau est identique à celui que vous avez vu précédemment. Ici, vous appliquez une convention différente, mais le résultat est le même.

Corrélation de Pearson: mise en œuvre des pandas

Jusqu'à présent, vous avez utilisé Séries et Trame de données méthodes d'objet pour calculer les coefficients de corrélation. Explorons ces méthodes plus en détail. Tout d'abord, vous devez importer des pandas et créer des instances de Séries et Trame de données:

>>>

>>> importation pandas comme pd
>>> X = pd.Séries(intervalle(dix, 20))
>>> X
0 10
1 11
2 12
3 13
4 14
5 15
6 16
7 17
8 18
9 19
dtype: int64
>>> y = pd.Séries([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])
>>> y
0 2
1 1
2 4
3 5
4 8
5 12
6 18
7 25
8 96
9 48
dtype: int64
>>> z = pd.Séries([[[[5, 3, 2, 1, 0, -2, -8, -11, -15, -16])
>>> z
0 5
1 3
2 2
3 1
4 0
5 -2
6 -8
7 -11
8 -15
9 -16
dtype: int64
>>> xy = pd.Trame de données(«valeurs x»: X, «valeurs y»: y)
>>> xy
            valeurs x valeurs y
0 10 2
1 11 1
2 12 4
3 13 5
4 14 8
5 15 12
6 16 18
7 17 25
8 18 96
9 19 48
>>> xyz = pd.Trame de données(«valeurs x»: X, «valeurs y»: y, «valeurs z»: z)
>>> xyz
            valeurs x valeurs y valeurs z
0 10 2 5
1 11 1 3
2 12 4 2
3 13 5 1
4 14 8 0
5 15 12 -2
6 16 18 -8
7 17 25 -11
8 18 96 -15
9 19 48 -16

Vous en avez maintenant trois Séries objets appelés X, y, et z. Vous en avez également deux Trame de données objets, xy et xyz.

Vous avez déjà appris à utiliser .corr () avec Séries objets pour obtenir le coefficient de corrélation de Pearson:

>>>

>>> X.corr(y)
0,7586402890911867

Ici, vous appelez .corr () sur un objet et passez l'autre comme premier argument.

Si vous fournissez un nan valeur, .corr () fonctionnera toujours, mais il exclura les observations contenant nan valeurs:

>>>

>>> u, u_with_nan = pd.Séries([[[[1, 2, 3]), pd.Séries([[[[1, 2, np.nan, 3])
>>> v, w = pd.Séries([[[[1, 4, 8]), pd.Séries([[[[1, 4, 154, 8])
>>> u.corr(v)
0.9966158955401239
>>> u_with_nan.corr(w)
0.9966158955401239

Vous obtenez la même valeur du coefficient de corrélation dans ces deux exemples. C'est parce que .corr () ignore la paire de valeurs (np.nan, 154) qui a une valeur manquante.

Vous pouvez aussi utiliser .corr () avec Trame de données objets. Vous pouvez l'utiliser pour obtenir la matrice de corrélation pour leurs colonnes:

>>>

>>> corr_matrix = xy.corr()
>>> corr_matrix
                                        valeurs x valeurs y
Valeurs x 1,00000 0,75864
valeurs y 0,75864 1,00000

La matrice de corrélation résultante est une nouvelle instance de Trame de données et détient les coefficients de corrélation pour les colonnes xy['x-values'] et xy['y-values']. Ces résultats étiquetés sont généralement très pratiques à utiliser, car vous pouvez y accéder avec leurs étiquettes ou leurs indices de position entiers:

>>>

>>> corr_matrix.à[[[[«valeurs x», «valeurs y»]
0,7586402890911869
>>> corr_matrix.iat[[[[0, 1]
0,7586402890911869

Cet exemple montre deux façons d'accéder aux valeurs:

  1. Utilisation .à[] pour accéder à une valeur unique par des étiquettes de ligne et de colonne.
  2. Utilisation .iat[] pour accéder à une valeur par les positions de sa ligne et de sa colonne.

Vous pouvez postuler .corr () de la même manière avec Trame de données objets contenant trois colonnes ou plus:

>>>

>>> xyz.corr()
                                        valeurs x valeurs y valeurs z
Valeurs x 1,000000 0,758640 -0,968072
valeurs y 0,758640 1,000000 -0,834079
Valeurs z -0,968072 -0,834079 1,000000

Vous obtiendrez une matrice de corrélation avec les coefficients de corrélation suivants:

  • 0,758640 pour valeurs x et valeurs y
  • -0,968072 pour valeurs x et valeurs z
  • -0.834079 pour valeurs y et valeurs z

Une autre méthode utile est .corrwith (), qui vous permet de calculer les coefficients de corrélation entre les lignes ou les colonnes d'un objet DataFrame et d'un autre objet Series ou DataFrame transmis comme premier argument:

>>>

>>> xy.corrwith(z)
Valeurs x -0,968072
valeurs y -0.834079
dtype: float64

Dans ce cas, le résultat est un nouveau Séries objet avec le coefficient de corrélation pour la colonne xy['x-values'] et les valeurs de z, ainsi que le coefficient de xy['y-values'] et z.

.corrwith () a le paramètre facultatif axe qui spécifie si les colonnes ou les lignes représentent les entités. La valeur par défaut de axe est 0, et il s'agit également par défaut de colonnes représentant les entités. Il y a aussi un laissez tomber , qui indique que faire des valeurs manquantes.

Tous les deux .corr () et .corrwith () avoir le paramètre facultatif méthode pour spécifier le coefficient de corrélation que vous souhaitez calculer. Le coefficient de corrélation de Pearson est renvoyé par défaut, vous n'avez donc pas besoin de le fournir dans ce cas.

Corrélation de rang

Corrélation de rang compare les rangs ou les ordonnances des données liées à deux variables ou entités d'ensemble de données. Si les ordonnances sont similaires, la corrélation est forte, positive et élevée. Cependant, si les commandes sont presque inversées, la corrélation est forte, négative et faible. En d'autres termes, la corrélation de rang ne concerne que l'ordre des valeurs, pas les valeurs particulières de l'ensemble de données.

Pour illustrer la différence entre la corrélation linéaire et la corrélation de rang, considérons la figure suivante:

mmst-py-corr-2

Le graphique de gauche a une relation linéaire positive parfaite entre X et y, donc r = 1. Le graphique central montre une corrélation positive et celui de droite montre une corrélation négative. Cependant, aucune d'entre elles n'est une fonction linéaire, donc r est différent de −1 ou 1.

Lorsque vous ne regardez que les commandes ou les rangs, les trois relations sont parfaites! Les graphiques gauche et central montrent les observations où des valeurs x plus grandes correspondent toujours à des valeurs y plus grandes. Il s'agit d'une parfaite corrélation de rang positif. Le graphique de droite illustre le cas contraire, qui est une parfaite corrélation de rang négatif.

Coefficient de corrélation de Spearman

le Coefficient de corrélation de Spearman entre deux caractéristiques est le coefficient de corrélation de Pearson entre leurs valeurs de rang. Il est calculé de la même manière que le coefficient de corrélation de Pearson mais prend en compte leurs rangs plutôt que leurs valeurs. Il est souvent désigné par la lettre grecque rho (ρ) et appelé Rho de Spearman.

Disons que vous avez deux n-tuples, X et y, où (x₁, y₁), (x₂, y₂),… sont les observations sous forme de paires de valeurs correspondantes. Vous pouvez calculer le coefficient de corrélation de Spearman ρ de la même manière que le coefficient de Pearson. Vous utiliserez les classements au lieu des valeurs réelles de X et y.

Voici quelques faits importants sur le coefficient de corrélation de Pearson:

  • Il peut prendre une valeur réelle dans la plage −1 ≤ ρ ≤ 1.

  • Sa valeur maximale ρ = 1 correspond au cas où il existe une fonction augmentant de façon monotone entre X et y. En d'autres termes, des valeurs x plus grandes correspondent à des valeurs y plus grandes et vice versa.

  • Sa valeur minimale ρ = −1 correspond au cas où il existe une fonction décroissante monotone entre X et y. En d'autres termes, des valeurs x plus grandes correspondent à des valeurs y plus petites et vice versa.

Vous pouvez calculer le rho de Spearman en Python d'une manière très similaire à celle du r de Pearson.

Coefficient de corrélation de Kendall

Commençons à nouveau en considérant deux n-tuples, X et y. Chacune des paires x-y (x₁, y₁), (x₂, y₂),… est une seule observation. Une paire d'observations (xᵢ, yᵢ) et (xⱼ, yⱼ), où i <j, sera l'une des trois choses:

  • concordant si (xᵢ> xⱼ et yᵢ> yⱼ) ou (xᵢ <xⱼ et yᵢ <yⱼ)
  • discordant si soit (xᵢ < xⱼ and yᵢ > yⱼ) ou (xᵢ> xⱼ et yᵢ <yⱼ)
  • ni s'il y a une égalité X (xᵢ = xⱼ) ou une égalité y (yᵢ = yⱼ)

le Coefficient de corrélation de Kendall compare le nombre de paires de données concordantes et discordantes. Ce coefficient est basé sur la différence entre le nombre de paires concordantes et discordantes par rapport au nombre de paires x-y. Il est souvent désigné par la lettre grecque tau (τ) et appelé Tau de Kendall.

Selon le scipy.stats documents officiels, le coefficient de corrélation de Kendall est calculé comme suit:
τ = (n⁺ – n⁻) / √ ((n⁺ + n⁻ + nˣ) (n⁺ + n⁻ + nʸ)),
où:

  • n⁺ est le nombre de paires concordantes
  • n⁻ est le nombre de paires discordantes
  • nˣ est le nombre de liens uniquement dans X
  • nʸ est le nombre de liens uniquement dans y

En cas d'égalité dans les deux X et y, alors il n'est inclus ni dans nˣ ni dans nʸ.

La page Wikipedia sur le coefficient de corrélation des rangs de Kendall donne l'expression suivante:
τ = (2 / (n (n – 1))) Σᵢⱼ (signe (xᵢ – xⱼ) signe (yᵢ – yⱼ))
pour i <j, où i = 1, 2,…, n – 1 et j = 2, 3,…, n.
La fonction de signe signe (z) est -1 si z < 0, 0 if z = 0, and 1 if z > 0. n (n – 1) / 2 est le nombre total de paires x-y.

Voici quelques faits importants sur le coefficient de corrélation de Kendall:

  • Il peut prendre une valeur réelle dans la plage −1 ≤ τ ≤ 1.

  • Sa valeur maximale τ = 1 correspond au cas où les rangs des valeurs correspondantes dans X et y sont identiques. En d'autres termes, toutes les paires sont concordantes.

  • Sa valeur minimale τ = −1 correspond au cas où le classement en X sont l'inverse du classement y. En d'autres termes, toutes les paires sont discordantes.

Vous pouvez calculer le tau de Kendall en Python de la même manière que vous calculeriez le r de Pearson.

Rang: mise en œuvre de SciPy

Vous pouvez utiliser scipy.stats pour déterminer le rang de chaque valeur dans un tableau. Tout d'abord, vous allez importer les bibliothèques et créer des tableaux NumPy:

>>>

>>> importation engourdi comme np
>>> importation scipy.stats
>>> X = np.arange(dix, 20)
>>> y = np.tableau([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])
>>> z = np.tableau([[[[5, 3, 2, 1, 0, -2, -8, -11, -15, -16])

Maintenant que vous avez préparé les données, vous pouvez déterminer le rang de chaque valeur dans un tableau NumPy avec scipy.stats.rankdata ():

>>>

>>> scipy.Statistiques.Rankdata(X)
tableau ([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
>>> scipy.Statistiques.Rankdata(y)
tableau ([ 2.,  1.,  3.,  4.,  5.,  6.,  7.,  8., 10.,  9.])
>>> scipy.Statistiques.Rankdata(z)
tableau ([10.,  9.,  8.,  7.,  6.,  5.,  4.,  3.,  2.,  1.])

Les tableaux X et z sont monotones, donc leurs rangs sont également monotones. La plus petite valeur y est 1 et cela correspond au rang 1. Le deuxième plus petit est 2, ce qui correspond au rang 2. La plus grande valeur est 96, ce qui correspond au rang le plus élevé dix car il y a 10 éléments dans le tableau.

rankdata () a le paramètre facultatif méthode. Cela indique à Python quoi faire s'il y a des liens dans le tableau (si deux ou plusieurs valeurs sont égales). Par défaut, il leur attribue la moyenne des rangs:

>>>

>>> scipy.Statistiques.Rankdata([[[[8, 2, 0, 2])
tableau ([4. , 2.5, 1. , 2.5])

Il y a deux éléments avec une valeur de 2 et ils ont les rangs 2.0 et 3.0. La valeur 0 a un rang 1.0 et la valeur 8 a un rang 4,0. Ensuite, les deux éléments avec la valeur 2 obtiendra le même rang 2,5.

rankdata () traite nan valeurs comme si elles étaient grandes:

>>>

>>> scipy.Statistiques.Rankdata([[[[8, np.nan, 0, 2])
tableau ([3., 4., 1., 2.])

Dans ce cas, la valeur np.nan correspond au plus grand rang 4,0. Vous pouvez également obtenir des rangs avec np.argsort ():

>>>

>>> np.argsort(y) + 1
tableau ([ 2,  1,  3,  4,  5,  6,  7,  8, 10,  9])

argsort () renvoie les indices que les éléments du tableau auraient dans le tableau trié. Ces indices sont basés sur zéro, vous devrez donc ajouter 1 à tous.

Corrélation de rang: implémentation NumPy et SciPy

Vous pouvez calculer le coefficient de corrélation Spearman avec scipy.stats.spearmanr ():

>>>

>>> résultat = scipy.Statistiques.spearmanr(X, y)
>>> résultat
SpearmanrResult (corrélation = 0,9757575757575757, pvalue = 1,4675461874042197e-06)
>>> résultat.corrélation
0,9757575757575757
>>> résultat.pvalue
1.4675461874042197e-06
>>> rho, p = scipy.Statistiques.spearmanr(X, y)
>>> rho
0,9757575757575757
>>> p
1.4675461874042197e-06

spearmanr () renvoie un objet qui contient la valeur du coefficient de corrélation Spearman et de la valeur p. Comme vous pouvez le voir, vous pouvez accéder à des valeurs particulières de deux manières:

  1. Utilisation de la notation par points (result.correlation et result.pvalue)
  2. Utilisation du déballage de Python (rho, p = scipy.stats.spearmanr (x, y))

Vous pouvez obtenir le même résultat si vous fournissez le tableau à deux dimensions xy qui contient les mêmes données que X et y à spearmanr ():

>>>

>>> xy = np.tableau([[[[[[[[dix, 11, 12, 13, 14, 15, 16, 17, 18, 19],
...                [[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48]])
>>> rho, p = scipy.Statistiques.spearmanr(xy, axe=1)
>>> rho
0,9757575757575757
>>> p
1.4675461874042197e-06

La première rangée de xy est une fonctionnalité, tandis que la deuxième ligne est l'autre fonctionnalité. Vous pouvez modifier cela. Le paramètre facultatif axe détermine si les colonnes (axe = 0) ou des lignes (axe = 1) représentent les caractéristiques. Le comportement par défaut est que les lignes sont des observations et les colonnes sont des entités.

Un autre paramètre facultatif nan_policy définit comment gérer nan valeurs. Il peut prendre l'une des trois valeurs suivantes:

  • 'propager' Retour nan s'il y a un nan valeur parmi les entrées. Ceci est le comportement par défaut.
  • 'élever' soulève un ValueError s'il y a un nan valeur parmi les entrées.
  • 'omettre' ignore les observations avec nan valeurs.

Si vous fournissez un tableau à deux dimensions avec plus de deux fonctionnalités, vous obtiendrez la matrice de corrélation et la matrice des valeurs de p:

>>>

>>> xyz = np.tableau([[[[[[[[dix, 11, 12, 13, 14, 15, 16, 17, 18, 19],
...                 [[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48],
...                 [[[[5, 3, 2, 1, 0, -2, -8, -11, -15, -16]])
>>> corr_matrix, p_matrix = scipy.Statistiques.spearmanr(xyz, axe=1)
>>> corr_matrix
array([[ 1.        ,  0.97575758, -1.        ],
       [ 0.97575758,  1.        , -0.97575758],
       [-1.        , -0.97575758,  1.        ]])
>>> p_matrix
array([[6.64689742e-64, 1.46754619e-06, 6.64689742e-64],
       [1.46754619e-06, 6.64689742e-64, 1.46754619e-06],
       [6.64689742e-64, 1.46754619e-06, 6.64689742e-64]])

The value -1 in the correlation matrix shows that the first and third features have a perfect negative rank correlation, that is that larger values in the first row always correspond to smaller values in the third.

You can obtain the Kendall correlation coefficient with kendalltau():

>>>

>>> result = scipy.Statistiques.kendalltau(X, y)
>>> result
KendalltauResult(correlation=0.911111111111111, pvalue=2.9761904761904762e-05)
>>> result.correlation
0.911111111111111
>>> result.pvalue
2.9761904761904762e-05
>>> tau, p = scipy.Statistiques.kendalltau(X, y)
>>> tau
0.911111111111111
>>> p
2.9761904761904762e-05

kendalltau() works much like spearmanr(). It takes two one-dimensional arrays, has the optional parameter nan_policy, and returns an object with the values of the correlation coefficient and p-value.

However, if you provide only one two-dimensional array as an argument, then kendalltau() will raise a TypeError. If you pass two multi-dimensional arrays of the same shape, then they’ll be flattened before the calculation.

Rank Correlation: Pandas Implementation

You can calculate the Spearman and Kendall correlation coefficients with Pandas. Just like before, you start by importing pandas and creating some Séries et DataFrame instances:

>>>

>>> import pandas comme pd
>>> X, y, z = pd.Séries(X), pd.Séries(y), pd.Séries(z)
>>> xy = pd.DataFrame('x-values': X, 'y-values': y)
>>> xyz = pd.DataFrame('x-values': X, 'y-values': y, 'z-values': z)

Now that you have these Pandas objects, you can use .corr() et .corrwith() just like you did when you calculated the Pearson correlation coefficient. You just need to specify the desired correlation coefficient with the optional parameter method, which defaults to 'pearson'.

To calculate Spearman’s rho, pass method=spearman:

>>>

>>> X.corr(y, method='spearman')
0.9757575757575757
>>> xy.corr(method='spearman')
                                        x-values  y-values
x-values  1.000000  0.975758
y-values  0.975758  1.000000
>>> xyz.corr(method='spearman')
                                        x-values  y-values  z-values
x-values  1.000000  0.975758 -1.000000
y-values  0.975758  1.000000 -0.975758
z-values -1.000000 -0.975758  1.000000
>>> xy.corrwith(z, method='spearman')
x-values   -1.000000
y-values   -0.975758
dtype: float64

If you want Kendall’s tau, then you use method=kendall:

>>>

>>> X.corr(y, method='kendall')
0.911111111111111
>>> xy.corr(method='kendall')
                                        x-values  y-values
x-values  1.000000  0.911111
y-values  0.911111  1.000000
>>> xyz.corr(method='kendall')
                                        x-values  y-values  z-values
x-values  1.000000  0.911111 -1.000000
y-values  0.911111  1.000000 -0.911111
z-values -1.000000 -0.911111  1.000000
>>> xy.corrwith(z, method='kendall')
x-values   -1.000000
y-values   -0.911111
dtype: float64

As you can see, unlike with SciPy, you can use a single two-dimensional data structure (a dataframe).

Visualization of Correlation

Data visualization is very important in statistics and data science. It can help you better understand your data and give you a better insight into the relationships between features. In this section, you’ll learn how to visually represent the relationship between two features with an x-y plot. You’ll also use heatmaps to visualize a correlation matrix.

You’ll learn how to prepare data and get certain visual representations, but you won’t cover many other explanations. To learn more about Matplotlib in-depth, check out Python Plotting With Matplotlib (Guide). You can also take a look at the official documentation and Anatomy of Matplotlib.

To get started, first import matplotlib.pyplot:

>>>

>>> import matplotlib.pyplot comme plt
>>> plt.style.utilisation('ggplot')

Here, you use plt.style.use('ggplot') to set the style of the plots. Feel free to skip this line if you want.

You’ll use the arrays X, y, z, et xyz from the previous sections. You can create them again to cut down on scrolling:

>>>

>>> import numpy comme np
>>> import scipy.stats
>>> X = np.arange(dix, 20)
>>> y = np.array([[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48])
>>> z = np.array([[[[5, 3, 2, 1, 0, -2, -8, -11, -15, -16])
>>> xyz = np.array([[[[[[[[dix, 11, 12, 13, 14, 15, 16, 17, 18, 19],
...                 [[[[2, 1, 4, 5, 8, 12, 18, 25, 96, 48],
...                 [[[[5, 3, 2, 1, 0, -2, -8, -11, -15, -16]])

Now that you’ve got your data, you’re ready to plot.

X-Y Plots With a Regression Line

First, you’ll see how to create an x-y plot with the regression line, its equation, and the Pearson correlation coefficient. You can get the slope and the intercept of the regression line, as well as the correlation coefficient, with linregress():

>>>

>>> slope, intercept, r, p, stderr = scipy.Statistiques.linregress(X, y)

Now you have all the values you need. You can also get the string with the equation of the regression line and the value of the correlation coefficient. f-strings are very convenient for this purpose:

>>>

>>> line = F'Regression line: y=intercept:.2f+slope:.2fx, r=r:.2f"
>>> line
'Regression line: y=-85.93+7.44x, r=0.76'

Now, create the x-y plot with .plot():

fig, ax = plt.subplots()
ax.terrain(X, y, linewidth=0, marker='s', label='Data points')
ax.terrain(X, intercept + slope * X, label=line)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.Légende(facecolor='white')
plt.spectacle()

Your output should look like this:

mmst-py-corr-3

The red squares represent the observations, while the blue line is the regression line. Its equation is listed in the legend, together with the correlation coefficient.

Heatmaps of Correlation Matrices

The correlation matrix can become really big and confusing when you have a lot of features! Fortunately, you can present it visually as a heatmap where each field has the color that corresponds to its value. You’ll need the correlation matrix:

>>>

>>> corr_matrix = np.corrcoef(xyz).round(decimals=2)
>>> corr_matrix
array([[ 1.  ,  0.76, -0.97],
       [ 0.76,  1.  , -0.83],
       [-0.97, -0.83,  1.  ]])

It can be convenient for you to round the numbers in the correlation matrix with .round(), as they’re going to be shown be on the heatmap.

Finally, create your heatmap with .imshow() and the correlation matrix as its argument:

fig, ax = plt.subplots()
im = ax.imshow(corr_matrix)
im.set_clim(-1, 1)
ax.grid(Faux)
ax.xaxis.ensemble(ticks=(0, 1, 2), ticklabels=('x', 'y', 'z'))
ax.yaxis.ensemble(ticks=(0, 1, 2), ticklabels=('x', 'y', 'z'))
ax.set_ylim(2,5, -0,5)
pour je dans range(3):
    pour j dans range(3):
        ax.text(j, je, corr_matrix[[[[je, j], Ha='center', va='center',
                color='r')
cbar = ax.figure.colorbar(im, ax=ax, format="% .2f")
plt.spectacle()

Your output should look like this:

mmst-py-corr-4

The result is a table with the coefficients. It sort of looks like the Pandas output with colored backgrounds. The colors help you interpret the output. In this example, the yellow color represents the number 1, green corresponds to 0.76, and purple is used for the negative numbers.

Conclusion

You now know that correlation coefficients are statistics that measure the association between variables or features of datasets. They’re very important in data science and machine learning.

You can now use Python to calculate:

  • Pearson’s product-moment correlation coefficient
  • Spearman’s rank correlation coefficient
  • Kendall’s rank correlation coefficient

Now you can use NumPy, SciPy, and Pandas correlation functions and methods to effectively calculate these (and other) statistics, even when you work with large datasets. You also know how to visualize data, regression lines, and correlation matrices with Matplotlib plots and heatmaps.

If you have any questions or comments, please put them in the comments section below!