Nuages de points : retour sur le sujet

Un nuage de points (scatterplot) est une méthode graphique pour les données bivariées, c'est-à-dire des données appariées dans lesquelles chaque valeur d'une première variable est associée à une valeur d'une seconde variable, qui trace les données $(x,y)$ de deux grandeurs numériques, le but étant de déterminer s'il existe une corrélation ou une dépendance entre ces deux grandeurs. Les nuages de points ont été abordés en détail dans Statistiques inférentielles et analyse de régression comme un élément clé de l'analyse de corrélation et de régression. Rappelons que dans un nuage de points, la grandeur indépendante, ou explicative, correspond à la variable x, et la grandeur dépendante, ou réponse, correspond à la variable y.

Lors de la génération de nuages de points dans Statistiques inférentielles et analyse de régression, la fonction plt.scatter() a été utilisée, qui fait partie de la bibliothèque Python matplotlib. Dans Analyse de corrélation et de régression linéaire, un exemple de nuage de points a été généré pour représenter les revenus en fonction des dépenses publicitaires d'une entreprise.

Le code Python de cet exemple est reproduit ci-dessous :

Code Python

    import matplotlib.pyplot as plt
    import matplotlib.ticker as ticker
    
    # Define the x-data, which is the amount spent on advertising
    x = [49, 145, 57, 153, 92, 83, 117, 142, 69, 106, 109, 121]
    
    # Define the y-data, which is revenue
    y = [12210, 17590, 13215, 19200, 14600, 14100, 17100, 18400, 14100, 15500, 16300, 17020]
    
    # Use the scatter function to generate a time series graph
    plt.scatter(x, y)
    
    # Add a title using the title function
    plt.title("Revenue versus Advertising for a Company")
    
    # Add labels to the x and y axes by using xlabel and ylabel functions
    plt.xlabel("Advertising $000")
    plt.ylabel("Revenue $000")
    
    # Define a function to format the ticks with commas as thousands separators
    def format_ticks(value, tick_number):
        return f'{value:,.0f}'
    
    # Apply the custom formatter to the y-axis
    plt.gca().yaxis.set_major_formatter(ticker.FuncFormatter(format_ticks))
    
    # Show the plot
    plt.show()
    

Le résultat obtenu ressemble à ceci :

Nous pouvons enrichir ce nuage de points en ajoutant de la couleur pour indiquer le niveau de revenus (valeur de y).

Pour ce faire, utilisez le paramètre c de la fonction plt.scatter pour spécifier que la couleur des points sera basée sur la valeur de y du point de données. Le paramètre cmap permet à l'utilisateur de spécifier la palette de couleurs à utiliser, telle que « hot », « coolwarm », etc.

De plus, une barre de couleur peut être ajoutée au nuage de points afin que l'utilisateur puisse interpréter l'échelle de couleurs.

Voici un code Python révisé et le nuage de points correspondant incluant l'amélioration par la couleur des points de données :

Code Python

    import matplotlib.pyplot as plt
    import matplotlib.ticker as ticker
    
    # Define the x-data, which is the amount spent on advertising
    x = [49, 145, 57, 153, 92, 83, 117, 142, 69, 106, 109, 121]
    
    # Define the y-data, which is revenue
    y = [12210, 17590, 13215, 19200, 14600, 14100, 17100, 18400, 14100, 15500, 16300, 17020]
    
    # Use the scatter function to generate a scatterplot
    # Specify that the color of the data point will be based on revenue (y)
    # Specify the 'coolwarm' color palette
    plt.scatter(x, y, c=y, cmap='coolwarm')
    
    # Plot a color bar so the user can interpret the color scale
    cbar = plt.colorbar()
    
    # Define a function to format the color bar ticks with commas as thousands separators
    def format_colorbar_ticks(value, tick_number):
        return f'{value:,.0f}'
    
    # Apply the custom formatter to the color bar ticks
    cbar.ax.yaxis.set_major_formatter(ticker.FuncFormatter(format_colorbar_ticks))
    
    # Add a title using the title function
    plt.title("Revenue versus Advertising for a Company")
    
    # Add labels to the x and y axes using xlabel and ylabel functions
    plt.xlabel("Advertising $000")
    plt.ylabel("Revenue $000")
    
    # Define a function to format the y-axis ticks with commas as thousands separators
    def format_ticks(value, tick_number):
        return f'{value:,.0f}'
    
    # Apply the custom formatter to the y-axis
    plt.gca().yaxis.set_major_formatter(ticker.FuncFormatter(format_ticks))
    
    # Show the plot
    plt.show()
    

Le résultat obtenu ressemble à ceci :

Une application typique de cette fonctionnalité consiste à faire dépendre la couleur du point de données sur un nuage de points de la valeur d'une troisième variable. Par exemple, un professionnel de l'immobilier peut s'intéresser à la corrélation entre le prix du logement, la superficie en pieds carrés de la maison et l'emplacement en termes de distance en milles par rapport au centre-ville. Le nuage de points peut être créé à partir des données $(x,y)$, où x est la superficie du logement, y est le prix du logement et z est la distance par rapport au centre-ville, représentée par la couleur du point.

Code Python

    # import the matplotlib library
    import matplotlib.pyplot as plt
    
    # define the x-data, which is square footage of a home
    x = [2100, 2378, 1983, 1422, 2764, 1901, 1198, 1785, 1556, 2931, 3071, 1688]
    
    # define the y-data, which is the corresponding home price in 000
    y = [390, 427, 350, 285, 479, 299, 250, 310, 290, 495, 515, 284]
    
    # define the z-data, which is the corresponding distance from city center
    z = [4.8, 0.5, 0.9, 1.5, 0.8, 4.2, 3.1, 0.1, 2.2, 1.5, 4.1, 0.7]
    
    # use the scatter function to generate a time series graph
    # specify that the color of the data point will be based on revenue (y)
    # specify the hot color palette
    plt.scatter(x, y, c = z, cmap='hot')
    
    # also plot a color bar so user can interpret the color scale
    plt.colorbar()
    
    # Add a title using the title function
    plt.title("Home Price versus Square Footage (Color = Miles from Center City)")
    
    # Add labels to the x and y axes by using xlabel and ylabel functions
    plt.xlabel("Square Footage")
    plt.ylabel ("Home Price $000")
    
    # Define a function to format the ticks with commas as thousands separators
    def format_ticks(value, tick_number):
        return f'{value:,.0f}'
    
    # Apply the custom formatter to the x-axis
    plt.gca().xaxis.set_major_formatter(ticker.FuncFormatter(format_ticks))
    

Le résultat obtenu ressemble à ceci :

Cartes thermiques de corrélation

Rappelez-vous d'Analyse de corrélation et de régression linéaire que l'analyse de corrélation (correlation analysis) est utilisée pour déterminer si une grandeur est liée ou corrélée à une autre. Par exemple, vous savez que la valeur d'une voiture est corrélée à son âge : en général, plus la voiture est ancienne, plus sa valeur diminue. Un coefficient de corrélation numérique (r) a été calculé, fournissant des informations à la fois sur la force et le sens de la corrélation.

La valeur de r nous donne ces informations :

• La valeur de r est toujours comprise entre $-1$ et $+1$. L'amplitude de la corrélation r indique la force de la relation linéaire entre les deux variables. Des valeurs de r proches de $-1$ ou de $+1$ indiquent une relation linéaire plus forte. Des valeurs de r proches de zéro indiquent une corrélation faible.

Le signe de r nous donne ces informations :

• Une valeur positive de r signifie que lorsque x augmente, y a tendance à augmenter, et lorsque x diminue, y a tendance à diminuer (corrélation positive).
• Une valeur négative de r signifie que lorsque x augmente, y a tendance à diminuer, et lorsque x diminue, y a tendance à augmenter (corrélation négative).

Les scientifiques des données recueillent souvent des données sur plus de deux variables et s'intéressent ensuite aux diverses corrélations entre ces variables. Les paires de variables présentant des corrélations plus fortes suscitent un intérêt particulier. Un moyen pratique de visualiser ces données est d'utiliser une carte thermique de corrélation (correlation heatmap), qui attribue une palette de couleurs aux différentes valeurs du coefficient de corrélation pour les deux variables.

Python fournit un mécanisme pour calculer une matrice de corrélation, qui montre la valeur de r pour chaque paire de variables d'un jeu de données à l'aide de corr(). Cette matrice de corrélation est couramment utilisée par les chercheurs pour identifier les variables présentant les plus fortes corrélations. Une carte thermique de corrélation est une représentation visuelle de la matrice de corrélation qui utilise un code couleur pour visualiser les variables présentant des corrélations plus fortes et celles présentant des corrélations plus faibles.

Généralement, des couleurs plus sombres sont utilisées pour indiquer des variables ayant des corrélations plus fortes et des couleurs plus claires pour indiquer des variables ayant des corrélations plus faibles.

Comme exemple de carte thermique de corrélation, nous pouvons utiliser un jeu de données disponible dans la bibliothèque Seaborn portant sur les accidents de la route, accessible ici via le jeu de données sur les accidents de la route ; les champs du jeu de données sont présentés dans le Tableau 9.5.

Il y a 50 enregistrements dans le jeu de données (un enregistrement par État). Les cinq premières lignes du jeu de données figurent dans le Tableau 9.6.

Le court programme Python qui suit peut être utilisé pour générer une carte thermique de corrélation pour les variables du jeu de données ; il utilise la fonction heatmap disponible dans la bibliothèque Seaborn (voir également Prise de décision à l'aide des bases de l'apprentissage automatique).

Code Python

    import seaborn as sns
    import matplotlib.pyplot as plt
    
    # Load the car_crashes dataset from seaborn library
    dataset = sns.load_dataset("car_crashes")
    
    # Select only numeric columns
    numeric_columns = dataset.select_dtypes(include=['number'])
    
    # Calculate the correlation matrix
    correlation_matrix = numeric_columns.corr()
    
    # Generate the correlation heatmap using the Reds color palette
    sns.heatmap(correlation_matrix, cmap='Reds', annot=True, fmt=".2f")
    
    # Add a Title to the plot
    plt.title('Correlation Heatmap for Variables in Car Crashes Dataset')
    
    # Show the plot
    plt.show()
    

Le résultat obtenu ressemble à ceci :

Remarquez que dans la carte thermique de corrélation, une coloration rouge foncé est visible sur la diagonale allant du coin supérieur gauche au coin inférieur droit de la matrice. Cette nuance sombre représente un coefficient de corrélation de 1,0, car toute variable est considérée comme parfaitement corrélée avec elle-même.

Visualisation de données tridimensionnelles

Supposons que vous suiviez un cours d'anatomie et qu'un enseignant tente de décrire verbalement le système nerveux humain. Comparez cela à un modèle 3D interactif du système nerveux humain, où un étudiant peut visualiser le système nerveux en trois dimensions, faire pivoter l'image 3D et observer le système nerveux sous différents angles et perspectives. Supposons à présent qu'un mécanicien automobile doive réparer la transmission d'une voiture et tente de lire le manuel d'entretien technique rédigé pour comprendre comment débuter la réparation. Comparez cela à un modèle 3D interactif de la transmission de la voiture, où le mécanicien peut visualiser l'emplacement exact de la réparation et interagir avec le modèle 3D.

Ces exemples illustrent les avantages et la puissance des perspectives tridimensionnelles. La visualisation de données tridimensionnelles offre de nombreux avantages, tels que la perception spatiale, la perception de la profondeur et une meilleure capacité à illustrer les regroupements et les motifs inhérents au jeu de données. La visualisation 3D (3D visualization) est également utile dans les applications de simulation et de modélisation.

La visualisation tridimensionnelle est également utilisée dans le cadre de l'analyse de régression linéaire multiple pour afficher un nuage de points en trois dimensions et observer le plan de régression correspondant (voir Apprentissage automatique dans l'analyse de régression).

Python comprend plusieurs outils et bibliothèques pour faciliter la visualisation et l'analyse 3D ; certains outils permettent une interactivité, comme la possibilité de zoomer/dézoomer, d'effectuer un panoramique et de faire pivoter des images tridimensionnelles. Voici quelques modules Python qui prennent en charge la visualisation 3D :

• Matplotlib propose des fonctionnalités pour la visualisation 3D telles que mpl.toolkits.mplot3d.
• Plotly est une bibliothèque qui comprend des fonctionnalités de tracé 3D, des graphiques de surface et bien plus encore.
• VTK est une bibliothèque de graphiques 3D et de traitement d'images (VTK signifie Visualization Toolkit).

Pour illustrer un exemple de nuage de points 3D en Python à l'aide de Matplotlib, écrivons du code Python pour tracer les données « Iris » de Seaborn, téléchargeables depuis le dépôt Seaborn. (Nous avons également utilisé ce jeu de données dans Que sont les données et la science des données ? et Notions de base sur l'apprentissage profond et l'IA.) Le jeu de données contient 150 lignes de données relatives à des mesures pour différentes variétés de fleurs d'iris, mais nous n'en utiliserons que quelques lignes (voir le Tableau 9.7).

Nous utiliserons la fonction mpl_toolkits.mplot3d() pour générer le nuage de points tridimensionnel. Tout d'abord, nous chargerons le jeu de données « iris » depuis la bibliothèque Seaborn. Ensuite, le nuage de points 3D est créé à l'aide de la fonction fig.add.subplot(). La fonction ax.scatter() est ensuite utilisée pour tracer les points de données.

Voici le code Python :

Code Python

    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    import seaborn as sns
    import matplotlib.cm as cm
    import matplotlib.colors as mcolors
    from matplotlib.patches import Rectangle
    
    # Load the iris dataset from Seaborn data repository
    flower = sns.load_dataset('iris')
    
    # Create a blank figure with a white background
    fig = plt.figure(figsize=(9, 8), facecolor='white')
    
    # Add a subplot to the figure
    ax = fig.add_subplot(111, projection='3d')
    
    # Set the background color of the axes to white
    ax.set_facecolor('white')
    
    # Plot data points
    scatter = ax.scatter(flower['sepal_length'], flower['sepal_width'], flower['petal_length'], 
                         c=flower['species'].astype('category').cat.codes, cmap='viridis', marker='o')
    
    # Set labels and title
    ax.set_xlabel('Sepal Length (cm)')
    ax.set_ylabel('Sepal Width (cm)')
    ax.set_zlabel('Petal Length (cm)')
    ax.set_title('3D Scatterplot of Iris Dataset by Species')
    
    # Map numerical codes to actual species names
    species_names = {0: 'setosa', 1: 'versicolor', 2: 'virginica'}
    
    # Create a ScalarMappable object
    norm = plt.Normalize(flower['species'].astype('category').cat.codes.min(), 
                         flower['species'].astype('category').cat.codes.max())
    sm = plt.cm.ScalarMappable(cmap='viridis', norm=norm)
    sm.set_array([])
    
    # Create the colorbar and adjust its spacing
    cbar = plt.colorbar(sm, ticks=[0, 1, 2], label='Species', fraction=0.02, pad=0.1)
    
    # Adjust colorbar position to increase space between colorbar and plot
    cbar.ax.tick_params(labelsize=10)  # Adjust the colorbar tick label size if needed
    
    # Adjust figure layout to provide appropriate space around the plot
    fig.subplots_adjust(left=0.1, right=0.85, top=0.9, bottom=0.1)  # Adjust margins as needed
    
    # Add legend
    ax.legend(handles=scatter.legend_elements()[0], 
              labels=[species_names[name] for name in flower['species'].astype('category').cat.codes.unique()], 
              title='Species')
    
    plt.show()
    

Le résultat obtenu ressemble à ceci :