train.csv et test.csv dans l'onglet datainputLancer votre notebook grâce à la commande dans votre terminal
jupyter notebook
In [2]:
# Importer les lib python
import pandas as pd
Petit rappel pour lire un fichier en local, utiliser la fonction read_csv
Si vous avez des difficultés à utiliser une fonction, vous pouvez taper le nom de la fonction + "?" :
pd.read_csv?Pour fermer la fenêtre d'aide, cliquez sur la croix en haut à gauche de la fenêtre d'aide
In [295]:
# Lire un fichier Train
train = pd.read_csv('input/train.csv')
Pour regarder un fichier, vous pouvez taper :
- le nom du DataFrame --> Afficher l'ensemble du DataFrame
- Utiliser ".head()" --> Affiche les 5 premières lignes
- Utiliser ".tail()" --> Affiche les 5 dernières lignes
In [296]:
# Regarder le début d'un DataFrame
train.head(17)
Out[296]:
Signification des colonnes :
- Survived : indique la mort ou la survie du passager pour les données d'apprentissage. C'est ce que l'on doit prédire sur fichier test. Cette valeur est booléene (0 ou 1) : 1 pour survie, 0 pour la mort
- Pclass : La classe des chambres du navire (3 niveaux), 1 étant la meilleure classe et 3 la classe "éco". C'est une variable texte qui va falloir transformer en faisant attention car il y a une notion d'ordre.
- Name : Nom de la personne
- Sex : Sexe du passager
- Age : âge du passager
- SisbSp : (Sibling and Spouse) : le nombre de membres de la famille du passager de type frère, soeur, demi-frère, demi-soeur, époux, épouse...
- Parch : (Parent and Child) : le nombre de membres de la famille du passager du type père, mère, fils, fille, beau-fils, etc...
- Ticket : Numéro du ticket
- Fare : le prix du ticket
- Cabin : numéro de cabine
- Embarked : le port d'embarquement du passager : C -> Cherbourg; Q -> Queenstown; S -> Southampton
In [297]:
train.count()
Out[297]:
count() permet de voir qu'il y a des données qui sont manquantes / absentes
On va crée un function python afin de faciler le reproduction par la suite
Target est donc notre cible (ce que l'on essaye de prédire')
In [338]:
def parse_model(X):
"""
Parse mes données pour nourrir un algo.
- Return :
- X : features pour prédire le résutat
- target : si la personne à survécu ou est morte
"""
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch']]
return X, target
In [339]:
X, y = parse_model(train.copy())
X sont nos données afin de déviner si le passager est mort ou non
In [340]:
X.head()
Out[340]:
y est la valeur booléen de survit ou non du Titanic
In [301]:
y.head()
Out[301]:
In [302]:
# Permet de valider notre modèle
from sklearn.cross_validation import cross_val_score, train_test_split
# Modèle linéaire
from sklearn.linear_model import LogisticRegression
In [303]:
# Etape 1
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
In [304]:
print"X_train : " + str(X_train.shape)
print"X_test : " + str(X_test.shape)
print"y_train : " + str(y_train.shape)
print"y_test : " + str(y_test.shape)
In [305]:
ma_regression = LogisticRegression() # On initialise notre algo
ma_regression.fit(X_train, y_train)
Out[305]:
In [306]:
ma_regression?
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [307]:
ma_prediction = ma_regression.predict(X_test)
# ma_prediction est un array (= list)
ma_prediction[0:5] # On affiche les 5 premiers résultats
Out[307]:
In [308]:
# Mon score de précision sur mes données d'apprentissage
ma_regression.score(X_train, y_train)
Out[308]:
In [309]:
# Etape 2
# Function de score
from sklearn.metrics import accuracy_score
accuracy_score(y_test, ma_prediction)
Out[309]:
On peux voir en changeant le chiffre du paramêtre random_state de train_test_split (étape 1) que le résultat du score sur les données d'apprentissage et sur les données test change
D'ailleurs l'étape 2 est égal :
In [310]:
accuracy_score(y_train, ma_regression.predict(X_train))
Out[310]:
La méthode de validation Cross Validation permet de prendre en entrée X (nos features) et y (survie ou mort) et d'entrainer un algo sur 4/5 du jeu de données et de tester (le score) sur 1/5.
In [311]:
from sklearn.cross_validation import cross_val_score
def cross_validation_score(algo, X, y):
"""
Utilise une cross validation sur un algo et return tout ses scores
"""
score_cv = cross_val_score(algo, X, y, cv=5)
return score_cv
In [312]:
mon_score = cross_validation_score(ma_regression, X, y)
In [313]:
print "Voila le résultat de la CV " + str(mon_score)
In [314]:
print "Voila la moyenne de la CV " + str(mon_score.mean())
Charger le fichier test :
In [315]:
test = pd.read_csv("input/test.csv")
test.head()
Out[315]:
In [316]:
test.count()
Out[316]:
In [341]:
# Etape 3
# On fit notre algo
ma_regression.fit(X, y)
use_features = ['Fare', 'SibSp', 'Parch']
prediction = ma_regression.predict(test[use_features])
# Error
Il semble que nos données de test soient NaN (absentes)
In [318]:
pd.isnull(test[use_features]).sum()
Out[318]:
In [134]:
test[pd.isnull(test.Fare)][use_features]
Out[134]:
On va donc remplacer cette valeur manquante :
- Soit on choisit une valeur subjective
- On prend la valeur la plus adéquate sur notre jeux de données **train** (comme la médiane)
In [138]:
# Lib de calcul
import numpy as np
mediane_fare = np.median(train['Fare'])
print "La medianne de Fare dans notre jeu de données train est : " + str(mediane_fare)
Il faut donc remplacer la / les valeurs manquantes de Fare dans notre jeu de données test par la médiane calculé
In [142]:
test['Fare'] = test['Fare'].fillna(mediane_fare)
test[pd.isnull(test.Fare)][use_features] # Plus de Fare NaN
Out[142]:
On reprendre notre étape 3 :
In [143]:
# Etape 3 bis
# On fit notre algo
ma_regression.fit(X, y)
use_features = ['Fare', 'SibSp', 'Parch']
test['Fare'] = test['Fare'].fillna(mediane_fare)
prediction = ma_regression.predict(test[use_features])
In [144]:
print prediction
In [270]:
test.shape
Out[270]:
In [271]:
len(prediction)
Out[271]:
In [145]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[145]:
In [272]:
train.Survived.value_counts(normalize=True)
Out[272]:
In [277]:
fichier_prediction.Survived.value_counts(normalize=True)
Out[277]:
Créer un dossier "output" au même niveau que le dossier "input"
In [149]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/premier_test.csv', index=False)
Aller sur Kaggle et faite une submission afin de voir votre score :)
In [150]:
# 0.6555 est assez proche de notre CV
Comment faire mieux que notre premier modèle. Il faut garder en mémoire que l'on à utiliser seulement 3 features...
In [157]:
# Pour afficher des images (pas besoin de taper cet import)
from IPython.display import Image
Image(url="http://i.giphy.com/9ABgKHIu3acWA.gif")
Out[157]:
In [158]:
import seaborn as sns
import matplotlib.pyplot as plt
# Pour que les graphique s'affichent dans le notebook
%matplotlib inline
In [285]:
train.head()
Out[285]:
In [286]:
sns.countplot(train.Pclass, hue=train.Survived)
Out[286]:
In [287]:
pd.get_dummies(train.Pclass, prefix="split_Pclass").head()
Out[287]:
In [319]:
v
In [320]:
X, y = parse_model_1(train)
In [321]:
X.head()
Out[321]:
In [322]:
y.head()
Out[322]:
In [323]:
mon_score_2 = cross_validation_score(ma_regression, X, y)
In [324]:
mon_score_2
Out[324]:
In [325]:
print "Voila la moyenne de la CV " + str(mon_score_2.mean())
In [326]:
mon_score_2.mean()
Out[326]:
In [327]:
# 1er score = 0.674
In [329]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
In [330]:
# Etape 3 bis
ma_regression.fit(X, y)
#use_features = [['Fare', 'SibSp', 'Parch', 'Pclass']]
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass']]
mes_dummy_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_test)
mon_test = mon_test.drop('Pclass', axis=1)
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [218]:
mon_test.head()
Out[218]:
In [332]:
ma_regression.fit(X,y)
Out[332]:
In [333]:
prediction = ma_regression.predict(mon_test)
In [334]:
prediction
Out[334]:
In [335]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[335]:
In [336]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/dexieme_test.csv', index=False)
In [343]:
ma_regression.coef_[0]
Out[343]:
In [344]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
#mon_resultat['coef'] = ma_regression.coef_[0]
#mon_resultat['features'] = ['Fare', 'SibSp', 'Parch', 'Pclass']
In [345]:
mon_resultat
Out[345]:
In [235]:
plt.figure(figsize=(10,8))
sns.barplot(x='features', y='coef', data=mon_resultat)
Out[235]:
In [347]:
# 1 er modèle
plt.figure(figsize=(10,8))
sns.barplot(x='features', y='coef', data=mon_resultat)
Out[347]:
Un poid positif augmente la probalité de survie. Un poid négatif diminue la probabilité de survie.
In [349]:
train.head()
Out[349]:
In [350]:
def parse_model_2(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
return X, target
In [351]:
X, y = parse_model_2(train.copy())
In [352]:
X.head()
Out[352]:
In [353]:
mon_score_3 = cross_validation_score(ma_regression, X, y)
In [354]:
mon_score_3
Out[354]:
In [355]:
mon_score_3.mean()
Out[355]:
In [356]:
ma_regression.fit(X, y)
Out[356]:
In [358]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
#use_features = [['Fare', 'SibSp', 'Parch', 'Pclass']]
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex']]
# Pclass
mes_dummy_Pclass_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_Pclass_test)
mon_test = mon_test.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex_test = pd.get_dummies(mon_test.Sex, prefix="split_Sex")
mon_test = mon_test.join(mes_dummy_Sex_test)
mon_test = mon_test.drop('Sex', axis=1)
# Autres
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [359]:
mon_test.head()
Out[359]:
In [361]:
prediction = ma_regression.predict(mon_test)
In [362]:
prediction
Out[362]:
In [363]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[363]:
In [364]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/test_3.csv', index=False)
In [371]:
train.tail()
Out[371]:
In [379]:
def parse_model_3(X):
target = X.Survived
X = X[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex', 'Age']] # Ajout d'une features
# Pclass
mes_dummy_Pclass = pd.get_dummies(X.Pclass, prefix="split_Pclass")
X = X.join(mes_dummy_Pclass)
X = X.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex = pd.get_dummies(X.Sex, prefix="split_Sex")
X = X.join(mes_dummy_Sex)
X = X.drop('Sex', axis=1)
# Enfant oui ou non ?
X['enfant'] = 0
X.loc[X.Age <= 10, 'enfant'] = 1
X = X.drop('Age', axis=1)
return X, target
In [380]:
X, y = parse_model_3(train.copy())
In [377]:
X.head()
Out[377]:
In [378]:
X.enfant.value_counts(normalize=True)
Out[378]:
In [381]:
mon_score_4 = cross_validation_score(ma_regression, X, y)
In [382]:
mon_score_4
Out[382]:
In [383]:
mon_score_4.mean()
Out[383]:
In [384]:
# On recherche notre jeu de données test
mon_test = pd.read_csv("input/test.csv")
#use_features = [['Fare', 'SibSp', 'Parch', 'Pclass']]
mon_test = mon_test[['Fare', 'SibSp', 'Parch', 'Pclass', 'Sex','Age']]
# Pclass
mes_dummy_Pclass_test = pd.get_dummies(mon_test.Pclass, prefix="split_Pclass")
mon_test = mon_test.join(mes_dummy_Pclass_test)
mon_test = mon_test.drop('Pclass', axis=1)
# Sex
mes_dummy_Sex_test = pd.get_dummies(mon_test.Sex, prefix="split_Sex")
mon_test = mon_test.join(mes_dummy_Sex_test)
mon_test = mon_test.drop('Sex', axis=1)
# Enfant oui ou non ?
mon_test['enfant'] = 0
mon_test.loc[mon_test.Age <= 10, 'enfant'] = 1
mon_test = mon_test.drop('Age', axis=1)
# Autres
mon_test['Fare'] = mon_test['Fare'].fillna(mediane_fare)
In [385]:
mon_test.head()
Out[385]:
In [388]:
ma_regression.fit(X, y)
Out[388]:
In [389]:
prediction = ma_regression.predict(mon_test)
In [390]:
prediction
Out[390]:
In [391]:
# On ajoute notre prédiction sur notre jeux de données test
test['Survived'] = prediction
fichier_prediction = test[['PassengerId', 'Survived']]
fichier_prediction.head()
Out[391]:
In [393]:
# Ecrire un fichier à partir d'un DataFrame
fichier_prediction.to_csv('output/test_4.csv', index=False)
In [395]:
mon_resultat = pd.DataFrame({'coef' : ma_regression.coef_[0],
'features' : X.columns})
#mon_resultat['coef'] = ma_regression.coef_[0]
#mon_resultat['features'] = ['Fare', 'SibSp', 'Parch', 'Pclass']
In [396]:
plt.figure(figsize=(10,8))
sns.barplot(x='features', y='coef', data=mon_resultat)
Out[396]:
In [445]:
moi = pd.DataFrame()
moi['Fare']=30,
moi['SibSp']=1,
moi['Parch']=2,
moi['split_Pclass_1']=1,
moi['split_Pclass_2']=0,
moi['split_Pclass_3']=0,
moi['split_Sex_female']=0,
moi['split_Sex_male']=1,
moi['enfant']=1
In [446]:
moi
Out[446]:
In [447]:
moi_prediction = ma_regression.predict(moi)
In [449]:
# 1 = survie / 0 = mort
print 'je suis ....' + str(moi_prediction)
In [450]:
# Probabilité de survie
ma_regression.predict_proba(moi)[0][1]
Out[450]:
In [ ]:
In [ ]: