Courbes et nuages de points (scatter plot) avec python

Voici un code à copier-coller pour avoir un petit jeu de données pour tester les graphiques

hematies = [4.51, 4.92, 4.66, 4.63, 4.67, 4.72, 4.76, 4.76, 4.57, 4.58, 4.46, 4.63, 4.59, 4.46] # nb de globules rouges

vgm = [94.0, 93.0, 93.0, 93.4, 93.4, 94.4, 93.6, 94.3, 94.9, 94.9, 96.8, 95.2, 95.0, 97.2] # taille des globules rouges

Un exemple simple à reprendre :

cate = ["f","m","f","f","m"]

import pandas as pd

cate = pd.Series(cate)

plt.scatter([1,2,3,4,5],[1,2,3,4,5],c=cate.apply(lambda x : cat[x])) ; plt.show()

• • Prenons un jeu de données poids, tailles et IMC de filles et garçons (code à copier-coller directement pour simuler ces valeurs)

import numpy as np

from numpy.random import normal as norm # On tapera ainsi norm() au lien de np.random.normal()

import pandas as pd

f_poids = list(norm(loc = 55, size=20, scale=11)) # Conversion en list nécessaire pour faire des concaténation avec +

f_taille = list(norm(loc = 163, size=20, scale=14))

m_poids = list(norm(loc = 70, size=20, scale=11))

m_taille = list(norm(loc = 175, size=20, scale=15))

poids = f_poids+m_poids ; poids = np.array(poids) # conversion np.array nécessaire pour multiplier et additionner des listes

taille = f_taille+m_taille ; taille = np.array(taille)

imc = poids/(taille/100)**2

sexe = ["F"]*20+["M"]*20

compil = {"Sexe" : sexe , "Poids" : poids, "Taille" : taille, "IMC" : imc}

compil = pd.DataFrame(compil) ; print(compil)

• 1) Méthode la plus simple : colorer avec seaborn

import seaborn as sns

• 4) Méthode plus subtile, paramétrage fin des caractéristiques de chaque catégorie :

• • 4.1) Définir les caractéristiques des points de chaque catégorie (Homme (M) et Femmes (F))

colors = {'F':'pink', 'M':'blue'} # Définition des colorations par catégories

cex = {'F':40, 'M':10} # Définition des tailles de points par catégories

pch = {'F':"o", 'M':"s"} # Définition des types de marqueurs par catégories

• Simuler des données (code à copier-coller) :

# Données

data = {'x': np.arange(50),

'y': np.arange(50) + 10 * np.random.randn(50),

'taille': np.abs(np.random.randn(50)*100),

'color': np.random.randint(0, 50, 50)}

• Tracer une droite de régression linéaire

Pour tracer des régressions linéaires, voir la page dédiée aux régression linéaires

• • 3) Réaliser une liste des couleurs et des formes de chaque point pour chaque catégorie

col_s = compil.Sexe.apply(lambda x: col[x])

cex_s = compil.Sexe.apply(lambda x: cex[x])

pch_s = compil.Sexe.apply(lambda x: pch[x])

category_s = compil.Sexe.apply(lambda x: category[x])

• • 4) Tracer. La seule façon d'avoir une légende qui prenne automatiquement en compte les caractéristiques de chaque catégorie est de les tracer les unes après les autres (boucle for ou n lignes à copier-coller)

fig, ax = plt.subplots(figsize=(10, 5))

for i in range(3) :

print("Voici la catégorie : ",i)

ax.scatter(compil.Poids[category_s==i],compil.Taille[category_s==i],

c=col_s[category_s==i], s=cex_s[category_s==i],

marker="o",label=list(cex.keys())[i])

ax.legend() ; ax.grid(True)

plt.show()

Un exemple de données : les données iris.

import seaborn as sns

print(sns.get_dataset_names())

iris = sns.load_dataset("iris") ; print(iris.head())

x_c = iris.iloc[:,0]

y_c = iris.iloc[:,1]

On peut entourer les nuages de points de chaque catégories ou d'un nuage de points simple lorsqu'on a trop de points à afficher. Une ellipse à 95% est tout aussi envisageable... cf. ci-dessus dans cette page...

En reprenant x_c et y_c de l'exemple ci-dessus des données iris.

Définir une variable de catégories :

cat = df.Series(iris.species).astype("category")

Importer les modules nécessaires et définir une couleur automatique pour chaque catégorie :

import numpy as np

from scipy.spatial import ConvexHull

# Définir les couleurs des nappes convexes

import matplotlib.cm as cm

import matplotlib as mpl

norm = mpl.colors.Normalize(vmin=0, vmax=(len(np.unique(cat.cat.codes)))) #-(len(np.unique(c)))

cmap = "viridis_r" # "YlGn"

m = cm.ScalarMappable(norm=norm, cmap=cmap)

Affichage

# Optionnel et à éviter si on a trop de points : affichage des points

plt.scatter(x_c,y_c, c = cat.cat.codes,cmap="viridis_r")

# Affichage des nappes convexes qui entourent chaque catégorie

for cat_temp in cat.cat.codes.unique() :

x_c_temp = [x_c[i] for i in range(len(x_c)) if (cat.cat.codes[i] == cat_temp)]

y_c_temp = [y_c[i] for i in range(len(y_c)) if (cat.cat.codes[i] == cat_temp)]

# Former pour chaque couple (X;Y) d'une catégorie, une nappe de points

points = [ [ None ] * len(x_c_temp) ] * 2

points = np.array(points)

points = points.reshape(len(x_c_temp),2)

points[:,0] = x_c_temp

points[:,1] = y_c_temp

# Déterminer les coordonnées de la nappe qui entoure ces points

hull = ConvexHull(points)

temp = 0

# Coloration puis tracé de la nappe convexe

for simplex in hull.simplices:

color_temp = m.to_rgba(cat_temp)

plt.plot(points[simplex, 0], points[simplex, 1],color=color_temp)#, linestyle='dashed')#linewidth=2,color=cat)

plt.show()

Même chose avec une ellipse de confiance : Pensez à télécharger la fonction confidence_ellipse()

#####

# ELLIPSE DE CONFIANCE

####

fig, ax = plt.subplots()

plt.scatter(diamonds.carat,diamonds.price,color="white")

for cat_temp in cat.cat.codes.unique() :

print("Patience...")

x_c_temp = [x_c[i] for i in range(len(x_c)) if (cat.cat.codes[i] == cat_temp)]

y_c_temp = [y_c[i] for i in range(len(y_c)) if (cat.cat.codes[i] == cat_temp)]

# Former pour chaque couple (X;Y) d'une catégorie, une nappe de points

points = [ [ None ] * len(x_c_temp) ] * 2

points = np.array(points)

points = points.reshape(len(x_c_temp),2)

points[:,0] = x_c_temp

points[:,1] = y_c_temp

x_c_temp = np.array(x_c_temp)

y_c_temp = np.array(y_c_temp)

# Déterminer les coordonnées de la nappe qui entoure ces points

color_temp = m.to_rgba(cat_temp)

confidence_ellipse(x_c_temp , y_c_temp , ax, edgecolor=color_temp)

temp = 0

# Coloration puis tracé de la nappe convexe

# for simplex in hull.simplices:

# color_temp = m.to_rgba(cat_temp)

# plt.plot(points[simplex, 0], points[simplex, 1],color=color_temp)#, linestyle='dashed')#linewidth=2,color=cat)

plt.show()

• 1- Définir d'abord le répertoire source (répertoire de sauvegarde) - cf. aide à la gestion des sources/documents

import os as os

os.chdir("C:/Users/python") # remplacer \ par /

• 2- Tracer le graphique et sauvegarder dans la foulée

plt.scatter(hematies,vgm,marker="s",color="black")

plt.savefig("test.png", bbox_inches='tight')