Statistique descriptive pour des données bivariées

In [1]:
%matplotlib nbagg

import matplotlib
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Nuage des points

Pour tracer un nuage des points, dont les coordonnées sont données par x et y, vous pouvez utiliser la fonction plt.plot comme vu précédemment.

Alternativement, on peut utiliser la fonction plt.scatter.

Exemple :

In [2]:
x = (np.random.rand(100) - .5 )* 10
y = x ** 2  + np.random.randn(100)

plt.figure()
plt.subplot(121)
plt.plot(x,y,'k.')

plt.subplot(122)
plt.scatter(x,y)
Out[2]:
<matplotlib.collections.PathCollection at 0x53319b0>

Covariance et corrélation

Pour calculer la covariance ou le coefficient de corrélation de deux Series x et y, on peut utiliser les fonctions np.cov(x,y) et np.corrcoef(x,y), qui calculent les covariances/corrélations entre x et y, mais aussi de x avec x et y avec y.

In [3]:
print 'Cov(x,y) :\n', np.cov(x,y)
print 'Cor(x,y) :\n', np.corrcoef(x,y)
Cov(x,y) :
[[  8.25342843e+00  -5.96406768e-02]
 [ -5.96406768e-02   6.19151234e+01]]
Cor(x,y) :
[[ 1.         -0.00263832]
 [-0.00263832  1.        ]]

Avec le module pandas, on peut calculer toute la matrice de covariances ou de corrélations d'un DataFrame tab par les instructions tab.cov() et tab.corr().

In [4]:
z = np.abs(x) ** 2 + y 
tab = pd.DataFrame({'x' : x, 
                    'y' : y, 
                    'z' : z })

print 'Matrice de covariance :\n', tab.cov()
print 'Matrice de correlation :\n', tab.corr()
Matrice de covariance :
          x           y           z
x  8.253428   -0.059641   -0.136020
y -0.059641   61.915123  122.708044
z -0.136020  122.708044  244.112308
Matrice de correlation :
          x         y         z
x  1.000000 -0.002638 -0.003030
y -0.002638  1.000000  0.998113
z -0.003030  0.998113  1.000000

Fonctions pour gérér les strings

Parfois on a besoin d'extraire juste une partie d'une chaîne de caractères (d'un string) ou d'en supprimer une partie. Exemple: le string '10.16EUR' contient un prix, mais pour faire des calculs il faut le transformer en float et pour cela il faut d'abord supprimer la partie EUR de la chaîne de caractères. Cela ce fait par l'attribut strip de string. Exemple:

In [5]:
s = '10.16EUR'
print 's', s, type(s) 

s_strip = s.strip('EUR')
print 's_strip', s_strip, type(s_strip)

s_float = float(s_strip)
print 's_float', s_float, type(s_float)
s 10.16EUR <type 'str'>
s_strip 10.16 <type 'str'>
s_float 10.16 <type 'float'>

Date et heure

En statistique, on peut avoir des tableaux de données où une colonne indique des dates et/ou des horaires.

En important un tel tableau de données, les dates/heures sont en format string. Pour pouvoir travailler avec, il faut convertir ces chaînes de caractères en valeurs numériques.

Le module time permet de le faire assez facilement.

La fonction qui nous sera utile s'appelle time.strptime.

Exemple :

In [6]:
import time

jour_str = "30 Nov 00"
print 'jour_str', jour_str

jour = time.strptime(jour_str, "%d %b %y")   
print 'jour', jour
jour_str 30 Nov 00
jour time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

Comme vous voyez, la fonction strptime analyse le string date_str et en extrait l'année (tm_year), le mois (tm_mon) etc. On peut accéder à ces informations par :

In [7]:
print 'Annee', jour.tm_year
print 'Mois', jour.tm_mon
print 'Heure', jour.tm_hour
Annee 2000
Mois 11
Heure 0

L'argument "%d %b %y" de time.strptime ci-dessus, indique à Python le format de la date en date_str.

Ici, "%d %b %y" indique que date_str est composé du jour, suivi par le mois (abrégé) et l'année (abrégé).

Voyons un autre exemple :

In [8]:
date_heure_str = "30 November 2000, 13:05:22"
print 'date_heure_str', date_heure_str

date_heure = time.strptime(date_heure_str, "%d %B %Y, %H:%M:%S")   
print 'date_heure', date_heure
date_heure_str 30 November 2000, 13:05:22
date_heure time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=13, tm_min=5, tm_sec=22, tm_wday=3, tm_yday=335, tm_isdst=-1)
In [9]:
print 'Annee', date_heure.tm_year
print 'Mois', date_heure.tm_mon
print 'Heure', date_heure.tm_hour
Annee 2000
Mois 11
Heure 13

Vous trouverez plus de détails sur la fonction time.strptime et notamment la façon dont il faut indiquer le format de la date/heure ici : https://docs.python.org/2/library/time.html

Exercice

Dans cet exercice, nous allons analyser des données du trafic internet du site web de la ville de Los Angeles :

https://www.lacity.org

fournies par Google Analytics.

Ce type de données permet au propriétaire d'un site internet, de comprendre le comportement des visiteurs du site. Elles reseignent sur le nombre total de visites du site, et plus précisément, de chaque page du site. De plus, on peut analyser la façon dont les personnes se baladent sur le site, pour comprendre p.ex. quelles sont les pages qui attirent les gens sur le site (quelles sont les "pages d'entrée" ou de première visite du site), mais aussi, quelles sont des "pages de sortie", c'est-à-dire les visiteurs ont tendance à quitter le site après la visite de cette page.

Notre tableau de données contient les informations suivantes sur le trafic internet pour le mois de février 2015. Pour chaque page du site https://www.lacity.org on connaît :

  • le titre de la page

  • le nombre total de visites de cette page

  • le nombre de visites uniques de la page (c'est-à-dire le nombre de sessions où l'utilisateur à visiter cette page exactement une fois)

  • la durée moyenne de visite de la page

  • le nombre d'entrées sur le site par cette page (c'est-à-dire, le nombre de sessions qui ont commencé la visite du site par cette page)

  • le pourcentage de personnes qui entrent sur le site par cette page et qui quittent ce site directement après, sans visiter d'autres pages du site (bounce rate).

  • le pourcentage de personnes qui abondonne ce site après la visite de cette page (exit rate). La différence entre bounce rate et exit rate est que le premier est le taux de sortie calculé sur le nombre de personnes qui viennent d'entrer sur le site, alors que le dernier est le taux de sortie calculé sur tous les visiteurs de la page.

Le but de cet exercice est de tracer des nuages des points pour des couples de variables et de calculer les covariances et le coefficients de corrélation entre les variables, afin de comprendre les relations entre les différentes variables.

  1. Les données sont disponible à l'adresse http://www.proba.jussieu.fr/pageperso/rebafka/Web_Analytics_Lacity_February_2015.csv. Importer les sous forme d'un dataframe.

  2. Familiariser vous avec le tableau des données : Vérifier la taille du tableau, regarder le type des différentes variables etc. Changer les noms de variable en : titre, nb_visites, nb_unique, duree, nb_entree, sortie_imm, sortie_total

    • Tracer le nuage des points des variables nb_visites et nb_unique.

    • Pour comparaison, calculer le logarithme des variables nb_visites et nb_unique, ajouter ces valeurs comme deux nouvelles colonnes au tableau des données (avec comme noms de variable log_visites et log_unique).

    • Tracer le nuage des points de ces deux nouvelles variables. Lequel des deux graphiques vous paraît plus pertinents ?

    • Calculer la covariance et la corrélation des variables nb_visites et nb_unique, et comparer avec les valeurs associées aux variables log_visites et log_unique.

    • Pour la variable nb_entree on fera (presque) pareil : on va travailler plutôt avec le logarithme de la variable. En revanche, il faut faire plus attention car parfois la variable nb_entree prend la valeur 0. Pour éviter d'avoir des log(0) = -inf dans le tableau, la nouvelle variable log_entree contiendra les valeurs log(nb_entree + 1).

  3. Les éléments des colonnes sortie_imm et sortie_total sont des chaînes de caractères (des strings) de la forme '31.6%'. Pour pouvoir analyser ces variables, il faut les convertir en valeurs numériques.

    • Ecrivez une fonction nommée convert_pourcent_float qui prend en argument une Series dont les éléments sont des pourcentages (des chaînes de caractères de la forme '31.6%'). La fonction renvoie une Series dont les éléments sont des pourcentages de type float (31.6). Pour ce faire, utiliser l'attribut strip de string et la fonction float.

    • Utiliser cette fonction convert_pourcent_float, pour remplacer dans le tableau les colonnes sortie_imm et sortie_total par des valeurs numériques.

    • Tracer le nuages de points de sortie_imm et sortie_total, et comparer au coefficient de corrélation.

  4. La variable duree sont des durées en format '0:02:33'.

    • Convertissez ces temps en durées en secondes. Pour cela il faut utiliser le module time et la fonction time.strptime.

    • Tracer le nuages de points de duree et sortie_total, et comparer au coefficient de corrélation.

  5. Supprimer les colonnes inutiles du tableau (c'est-à-dire les variables titre, nb_visites, nb_unique et nb_entree).

  6. Tracer les nuages des points de log_visites avec toutes les autres variables, et comparer avec les covariances et corrélations correspondantes. Interpréter la relation du (log du) nombre de visites par page avec les autres variables.

  7. Ecrire une fonction scatter_matrix qui trace les nuages de points de toutes les variables du tableau de données passé à la fonction en argument, où les graphiques sont organisés en forme de matrice. Appliquer cette fonction à votre tableau de données et comparer à la matrice de corrélations.

  8. Interpréter les relations des différentes variables les unes avec les autres.

In [ ]: