Matplotlib – Visualisation de données

La visualisation de données est une étape clé pour comprendre l’ensemble des données et en tirer des conclusions. Bien qu’il soit toujours possible d’inspecter de près les données ligne par ligne, cellule par cellule, c’est souvent une tâche fastidieuse qui ne met pas en évidence la vue d’ensemble. Les visuels, en revanche, définissent les données sous une forme facile à comprendre d’un simple coup d’œil et permettent de garder l’attention du public.

Matplotlib est une bibliothèque de traçage 2D avec Python 2D qui produit des tracés de qualité dans une variété de formats et d’environnements interactifs sur toutes les plateformes.

matplotlib.org

Matplotlib est une bibliothèque de base qui offre des options pour différents tracés ainsi que des personnalisations étendues sous forme d’étiquettes, de titres, de taille de police, etc.
Pour mieux comprendre Matplotlib, j’ai pris l’ensemble des données de densité de population de Kaggle et j’ai commencé à créer mes propres visualisations. Cet article met en évidence les tracés que j’ai obtenus, y compris les personnalisations et les conclusions/déductions que j’en ai tirées.

Importation des bibliothèques

import numpy as np
import pandas as pd

import matplotlib.pyplot as plt
import matplotlib.cm as cm
%matplotlib inline

Comme toujours, nous devons d’abord importer toutes les bibliothèques nécessaires. Nous importons les bibliothèques NumPy et Pandas pour le traitement des données. Nous importons ensuite Matplotlib et utilisons son module pyplot pour le tracé de nos données et cm pour la palette de couleurs. La commande %matplotlib inline garantit que tous les tracés apparaissent en ligne dans le notebook.

Importation du jeu de données

Les quatre premières lignes du fichier dataset.csv ne sont pas nécessaires pour que nous puissions importer les données dans la variable dataset. On peut sauter ces quatre premières lignes. Nous utilisons ensuite .head() pour vérifier les données.

dataset = pd.read_csv('dataset_world.csv')

dataset.head()

Nous voyons immédiatement certaines colonnes qui ne nous concernent pas. Tout d’abord, nous pouvons conserver le nom du pays (Country Name) mais nous pouvons supprimer le code du pays (Country Code). Comme nous savons que nous avons affaire à des densités de population, nous pouvons laisser tomber les colonnes de nom et code de l’indicateur (Indicator Name & Indicator Code). Ensuite, les colonnes pour les années 1960 et 2016 ont des valeurs manquantes NaN. NaN signifie “Not a Number”. Nous devrions donc supprimer ces colonnes car elles ne fournissent aucune information. Enfin, il y a une colonne sans nom qui a également des valeurs NaN, nous pouvons donc supprimer la colonne Unnamed : 61 également.

dataset.drop(['Country Code', 'Indicator Name', 'Indicator Code', '1960', '2016', 'Unnamed: 61'], axis = 1, inplace = True)

dataset.dropna(how = 'any', axis = 0, inplace = True)
dataset.isnull().sum()

Nous supprimons toutes les lignes où il peut y avoir des valeurs vides ou nulles en utilisant la méthode dropna. Puis nous vérifions si aucune colonne n’a de valeurs nulles en utilisant dataset.isull().sum(). Nous constatons que toutes les lignes présentent 0 valeur nulle.

Nous sommes maintenant prêts à visualiser nos données.

Visualisation de données

Maintenant, nous allons utiliser Matplotlib pour créer nos graphiques et utiliser ces visualisations pour en tirer des conclusions significatives.

Tracé linéaire

Nous commençons par analyser la densité de la population d’Aruba au cours des années en utilisant un graphique linéaire. Nous prenons les années sur l’axe des x et la densité de population sur l’axe des y.

Nous sélectionnons les valeurs x avec dataset.columns[1 :], ce qui sélectionne toutes les colonnes sauf la première car nous n’avons besoin que des années et non de la colonne Country Name.
Ensuite, nous sélectionnons les valeurs y avec dataset.iloc[0][1 :], ce qui sélectionne la première colonne, c’est-à-dire le pays Aruba et toutes les colonnes sauf la première. Le nom du pays peut être obtenu à l’aide de dataset.iloc[0][0]. Pour tracer le graphique, il suffit d’utiliser la fonction plot et de définir les paramètres comme x et y pour l’axe des x et l’axe des y respectivement.

x = dataset.columns[1:]
y = dataset.iloc[0][1:]
country = dataset.iloc[0][0]
plt.plot(x, y)

Félicitations ! Votre premier graphique est prêt ! !

Oui, il fait le taff mais il est très difficile de le comprendre. Il n’y a pas d’étiquettes et les valeurs des axes se chevauchent. C’est là que la capacité de personnalisation de matplotlib sera utile. Rendons-le un peu plus facile à interpréter.

plt.rcParams['figure.figsize'] = (30, 30)
plt.rcParams['font.size'] = '20'
plt.title('Densité de population ' + country + ' au cours des années')
plt.xlabel('Années')
plt.xticks(rotation = '90')
plt.ylabel('Densité de population (habitants par km2)')
plt.plot(x, y, linewidth = 4)

Les paramètres rcParams nous permettent de modifier la taille des chiffres, la taille des polices et bien plus encore. Nous ajoutons ensuite un titre, les étiquettes des axes avec xlabel et ylabel. xticks nous permet de définir l’angle de rotation de notre texte, que nous fixons à 90 degrés. Nous traçons ensuite à nouveau et définissons la largeur de la ligne à 4.

Nous pouvons maintenant voir que le graphique est beaucoup plus clair avec seulement quelques modifications.

Nous pouvons également utiliser des graphiques linéaires pour voir la tendance dans les différents pays. Nous prenons les 5 premiers pays et comparons la croissance de leur densité de population. Comme nous avons maintenant plusieurs lignes sur un seul graphique, nous devons utiliser des couleurs différentes pour chaque pays et définir une légende qui attribue une couleur unique à chaque pays.

x = dataset.columns[1:]
colors = cm.rainbow(np.linspace(0, 1, 5))

for index in range(5):
    y = dataset.iloc[index][1:]
    plt.plot(x, 
             y, 
             c = colors[index],
             label = dataset.iloc[index][0],
             linewidth = 4)
    plt.title('Comparaison de la densité de population de différents pays')
    plt.xlabel('Années')
    plt.xticks(rotation = '90')
    plt.ylabel('Densité de population')
    plt.legend(prop = {'size': 24})

Ici, nous faisons une boucle à travers les 5 premières lignes de l’ensemble de données et traçons les valeurs sous forme de graphique linéaire. Nous sélectionnons les couleurs en utilisant le paquet cm de matplotlib et sa méthode rainbow. Dans la méthode plot, nous devons spécifier le paramètre label car il garantit que lorsque la légende est activée, les noms sont affichés. La légende est activée en utilisant la méthode legend() où j’ai spécifié la propriété size à 24.

Nous pouvons constater que pour les 5 pays, Aruba, Andorre, l’Afghanistan, l’Angola et l’Albanie, il y a eu une augmentation de la densité de la population.

Diagramme en barres

Le diagramme en barres peut être facilement créé en utilisant la méthode bar() avec les arguments pertinents. Nous commençons par tracer la densité de population de tous les pays pour l’année 2015.

countries = dataset['Country Name']
populationDensity2015 = dataset['2015']
plt.xticks(rotation = '90')
plt.bar(countries, populationDensity2015, color = cm.rainbow(np.linspace(0, 1, len(countries))))

Puisque le graphique tente de fournir beaucoup d’informations en même temps, il ne fournit pas vraiment d’information utile. Les étiquettes de l’axe des x se chevauchent tellement que l’ensemble du graphique est inutile. Nous devons non seulement visualiser notre ensemble de données, mais aussi visualiser intelligemment les parties importantes de notre ensemble de données. Il est préférable de trier les 10 premiers pays avec la densité maximale et de les examiner.

top10 = dataset.sort_values('2015', ascending = False).head(10)
plt.xticks(rotation = '45')
plt.title("Densité de population des 10 pays les plus densément peuplés pour l'année 2015")
plt.xlabel('Pays')
plt.ylabel('Densité de Population')
plt.bar(top10['Country Name'],
        top10['2015'],
        color = cm.rainbow(np.linspace(0, 1, len(top10))))

Nous trions d’abord les pays en utilisant la méthode sort_values basée sur la densité de population de l’année 2015 et par ordre décroissant. Nous sélectionnons ensuite les 10 premiers pays en utilisant la méthode head(10). Nous traçons ensuite notre diagramme à barres avec ces nouvelles données.

L’information est bien claire maintenant. Les données sont espacées de manière égale et représentées distinctement par des couleurs différentes.

Diagramme de dispersion

Un diagramme de dispersion est un graphique qui affiche les données sous forme de points dans l’espace libre. Les diagrammes de dispersion sont très utiles car ils permettent de spécifier la taille de chaque point de données en fonction d’une certaine valeur et les données peuvent elles-mêmes représenter leur caractère distinctif par rapport aux autres points.

Nous analysons maintenant les pays où la densité moyenne de population est inférieure à 10 personnes par kilomètre carré (de surface terrestre) pour toutes les années.

total_columns = dataset.shape[1]
selected_data = dataset[dataset.sum(axis = 1).apply(lambda x: x/total_columns) <= 10]
consolidated_data = selected_data.sum(axis = 1).apply(lambda x: x/total_columns)
countries = selected_data['Country Name']
plt.rcParams['figure.figsize'] = (20, 20)
plt.rcParams['font.size'] = 14
plt.title('Densité moyenne de population pour différents pays')
plt.xlabel('Pays')
plt.ylabel('Densité moyenne de la population')
plt.xticks(rotation = '90')
plt.scatter(countries, 
            consolidated_data, 
            s = consolidated_data*20, 
            c = cm.rainbow(np.linspace(0, 1, len(countries))))

Tout d’abord, je fais la somme de toutes les données sur chaque ligne en utilisant dataset.sum(axis = 1) et ensuite j’utilise la méthode lambda pour dire que pour chaque valeur finale, il faut la diviser par le nombre de colonnes pour obtenir la moyenne. Je compare ensuite cette valeur à une valeur inférieure ou égale à 10 et je l’utilise comme indice pour l’ensemble de données. Il en résulte l’ensemble des pays dont la densité moyenne de population est inférieure ou égale à 10. Je calcule à nouveau cette valeur et je la stocke cette fois dans la variable consolidated_data. La méthode utilisée pour tracer un diagramme de dispersion est similaire à celle utilisée pour d’autres diagrammes, à une différence près. Nous pouvons maintenant définir la taille de chaque point de données à l’aide du paramètre s. J’ai conservé la taille pour qu’elle soit équivalente à la densité de population. Comme les valeurs étaient petites, j’ai multiplié la taille par 20 chacune, de sorte que la différence soit plus marquée.

Vous pouvez voir que chaque point de données est représenté sur le graphique avec sa propre taille en fonction de sa valeur de densité.

Analyse approfondie

Nous allons maintenant nous plonger plus profondément dans l’ensemble des données et voir si nous pouvons en tirer d’autres conclusions.

Analyse descriptive

Nous pouvons voir si les valeurs de densité maximale et minimale ont changé dans le monde entier. Il faudrait donc calculer la fourchette de valeurs.

minimum = dataset.loc[:, dataset.columns != 'Country Name'].min()
maximum = dataset.loc[:, dataset.columns != 'Country Name'].max()
diff = maximum - minimum
minOfMax = maximum.min()
plt.title('Intervalle de Densité de Population pour les années 1962-2015')
plt.xticks(rotation = '90')
plt.xlabel('Années')
plt.ylabel('Densité de Population')
plt.bar(dataset.columns[1:], diff.apply(lambda x: x-minOfMax), color = cm.rainbow(np.linspace(0, 1, dataset.shape[1])))

Nous utilisons les méthodes min() et max() pour calculer le minimum et le maximum dans chaque colonne, à l’exception de la colonne Country Name. Nous trouvons ensuite l’intervalle dans la variable diff. Nous calculons ensuite la valeur minimale des maximums de chaque colonne et l’enregistrons dans minOfMax. Lorsque nous traçons le graphique à barres, nous soustrayons cette valeur de toutes les fourchettes, ce qui permet de nous assurer que nous comparons toutes les intervalles avec l’année de l’intervalle la plus basse. Pour ce faire, nous utilisons la méthode apply(lambda x : x-minOfMax) à l’intérieur du diagramme à barres.

Population vs. Densité de la population

Il serait étonnant de voir si la densité de la population est effectivement une bonne mesure et si elle reflète également la population du pays. Comme cet ensemble de données n’a ni la population ni la superficie, nous devons le récupérer auprès d’une autre source. Ici, nous utiliserons BeautifulSoup pour extraire les superficies de cette page Wikipédia et l’utiliser pour calculer la population. Nous allons ensuite comparer la population et la densité de population. Vous pouvez vous référer à mon article sur le scraping de sites web pour un démarrage rapide.

from urllib.request import urlopen
from bs4 import BeautifulSoup

content = BeautifulSoup(urlopen('https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_area'), 'html.parser')

dataset['Area'] = 0.0
table = content.find_all('table')[0]
rows = table.find_all('tr')
for tr in rows:
    td = tr.find_all('td')
    a = tr.find('a')
    try:
        area = td[3].text.split('(')[0].replace(',', '')
        dataset.loc[dataset['Country Name'] == a.text, 'Area'] = int(area)
    except Exception:
        continue

dataset = dataset[dataset['Area'] != 0]
dataset.shape
# (170, 57)

L’ensemble final comprend une liste de 170 pays pour lesquels nous disposons d’informations complètes, y compris la superficie en km. Mais comme il sera difficile de comprendre et d’interpréter autant de pays à la fois, nous allons nous pencher sur les 20 premiers.

population = dataset['Area'].multiply(dataset['2015'], axis = 0)
countries = dataset['Country Name']

plt.subplot(2,2,1)
plt.title("Population des différents pays pour l'année 2015")
plt.xlabel('Pays')
plt.ylabel('Population')
plt.xticks(rotation = '90')
plt.bar(countries[:20], population[:20], color = 'b')

plt.subplot(2,2,2)
plt.title("Densité de Population des différents pays pour l'année 2015")
plt.xlabel('Pays')
plt.ylabel('Densité de Population')
plt.xticks(rotation = '90')
plt.bar(countries[:20], dataset['2015'][:20], color = 'r')

Nous comparons maintenant la population et la densité de population de 20 pays en traçant des graphiques à barres côte à côte pour ces pays. Nous trouvons la Population en multipliant la superficie (Area) par la densité de population pour l’année 2015. Nous pouvons diviser la figure en plusieurs sous-graphiques. La méthode subplot(rows, columns, index) est utilisée pour définir un subplot. Ici, nous créons un canevas de 4 parcelles identifiées par 2 lignes et 2 colonnes. Le troisième argument indique à quel graphique nous nous référons ici. Nous traçons les données pour 20 pays dans deux graphiques aux index 1 et 2.

Nous pouvons voir que la densité de population n’est pas toujours la mesure correcte pour décrire la population d’un pays, par exemple le pays Bahreïn.

Conclusion

Ici, nous avons utilisé le paquet matplotlib pour concevoir et créer des tracés qui nous ont permis de mieux comprendre notre ensemble de données.