Prédire la survie du Titanic

Analysez les données du Titanic et évaluez un modèle prédictif en Python.

Introduction

Résumé en 30 Secondes

Une feuille remplie de noms, d’âges et de cases vides raconte rarement une histoire au premier regard. Pour comprendre qui a survécu au Titanic, il faut faire ressortir les tendances cachées dans ces lignes.

Dans ce projet, vous allez créer dans Google Colab un notebook en Python qui transforme les données brutes du Titanic en une prédiction de survie évaluée. Vous passerez de l’audit de données à la visualisation statistique, puis à une régression logistique évaluée.

Ce Que Vous Allez Construire

Quand vous exécuterez votre notebook, vous verrez une analyse complète progresser des défauts des données jusqu’aux erreurs d’un modèle de survie que vous pouvez expliquer.

À la fin de ce projet, vous aurez :

  • Un audit des données qui vous permet de repérer immédiatement les colonnes incomplètes et de contrôler les doublons du jeu Titanic.
  • Deux visualisations exploratoires qui vous permettent de comparer la survie selon la classe et d’observer la distribution des âges.
  • Un pipeline de classification que vous pouvez relancer pour traiter les données brutes et produire un rapport de métriques accompagné d’une matrice de confusion.
  • Mission secrète : un graphique de synthèse qui compare le taux de survie par classe et par sexe pour un public non technique.

Quels sont les prérequis ?

Vous devez connaître les bases de Python et avoir déjà utilisé pandas. Tout se déroule dans Google Colab depuis votre navigateur, sans installation locale.

Before We Start

This step gives your Titanic analysis a clear question before the hands-on work begins. It also identifies the non-technical audience or portfolio reviewer who should understand the result.

Set Up a Reproducible Colab Environment

Your analysis question gives the Titanic notebook a clear purpose. A hosted notebook can change underneath you when its runtime or packages update.

Google Colab runs your code in a hosted Jupyter notebook.

The 2026.07 runtime fixes the Python foundation. A pinned dependency file keeps the later analysis reproducible.

In this step, get ready to:
  • Prepare the planned analyse_titanic.ipynb notebook in Google Colab.
  • Pin the notebook to the 2026.07 runtime with Python 3.12.13.
  • Install the pinned dependencies for every project import.
Create the notebook and pin the runtime

The selected runtime controls the Python version behind every cell. Pinning it gives each later result a stable starting point.

  • Create a blank notebook by visiting https://colab.new in your browser.
  • Sign in with your Google account if Colab asks you to authenticate.

You will see a blank notebook connected to your Google account.

  • Select the current notebook title in the top-left header.
  • Enter analyse_titanic.ipynb as the new name.

The notebook header now shows analyse_titanic.ipynb. Google Drive stores the notebook under this name.

  • Open the Runtime menu at the top of Colab.
  • Select Change runtime type.

The runtime dialog shows the environment currently attached to your notebook.

  • Choose 2026.07 from the Runtime Version menu.
  • Confirm the runtime change in the dialog.

Colab reconnects the notebook using the selected runtime.

Before you run the check, make a quick prediction about the Python version the selected runtime reports.

  • Add a code cell at the top of analyse_titanic.ipynb.
  • Check the active Python version by running this code:
import sys; print(sys.version)

What does this check prove?

The sys.version value identifies the Python interpreter attached to the notebook. Its first number confirms whether Colab loaded the runtime you selected.

✔️ I see version 3.12.13

Your output starts with 3.12.13. The notebook now has the required Python foundation.

ⓧ I see another version

Colab connected the notebook to a different runtime version.

  • Return to the Runtime menu.
  • Select Change runtime type.

The runtime dialog shows the version that needs changing.

  • Choose 2026.07 from the Runtime Version menu.
  • Confirm the runtime change.

Colab reconnects the notebook with the pinned environment.

  • Rerun the version cell at the top of the notebook.

The new output should start with 3.12.13.

ⓧ I cannot find 2026.07

The historical runtime selector has not loaded the required version in your current view.

  • Confirm that Colab shows your Google account in the browser.
  • Refresh the notebook page.

The refreshed notebook reloads the available runtime versions.

  • Return to the Runtime menu.
  • Select Change runtime type.

The runtime dialog should now include the historical version menu.

  • Choose 2026.07 from the Runtime Version menu.
  • Confirm the runtime change.
  • Rerun the version cell.

Still missing the runtime?

Check that you are using the Google account that owns the notebook. A stale browser session can prevent Colab from refreshing the runtime list.

Review the official Colab runtime version guide for the current selection flow.

Help me find the 2026.07 runtime in Google Colab.

Install the pinned dependencies

The requirements.txt file records the exact library versions used by this project. Installing it before the imports prevents future package releases from changing the notebook unexpectedly.

  • Locate the provided requirements.txt file in your project materials.
  • Expand the file sidebar on the left side of Colab.

The sidebar gives the current runtime a place to receive the dependency file.

  • Select the file upload control in the sidebar.
  • Choose the provided requirements.txt file.

You will see requirements.txt listed in the runtime files.

  • Compare the uploaded dependency pins with this reference:
pandas==3.0.6
matplotlib==3.11.2
seaborn==0.13.2
scikit-learn==1.9.1

What does this file control?

  • pandas handles the tabular Titanic data.
  • Matplotlib creates the project figures.
  • seaborn produces the statistical visualizations.
  • scikit-learn supplies the preprocessing tools and classification model.

Dependency installation can keep the cell busy for a minute or two while Colab resolves the pinned packages. The activity indicator means the runtime is still working.

  • Install every pinned dependency by running this command in a new code cell:
%pip install -r requirements.txt

What does this command do?

The %pip magic installs packages into the active notebook kernel. The -r option reads every dependency from requirements.txt.

  • Accept the runtime restart if Colab requests one after installation.

The cell finishes with package installation output and no installation error. That is the dependency safeguard in place: each fresh runtime can recreate the same environment.

Dependency installation failed?

Confirm that requirements.txt appears in the Colab file sidebar. The command cannot read a file that was uploaded under another name.

Check your Internet connection if the installation stops while downloading packages. Rerun the cell after the connection recovers.

Help me troubleshoot the dependency installation in Colab.

✔️ Awesome, I've got everything!

Your uploaded requirements.txt file contains all four dependency pins.

ⓧ I'd like to double check the full code

pandas==3.0.6
matplotlib==3.11.2
seaborn==0.13.2
scikit-learn==1.9.1

What are you comparing?

Check each package name and version against your uploaded file. All four lines must match before the notebook imports them.

Add the project imports and verify the setup

Imports make each installed tool available under the names used by later cells. The aliases plt and sns keep the visualization code concise.

  • Add a new code cell below the dependency installation cell.
  • Load every project library by pasting and running this import group:
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

What do these imports prepare?

  • plt creates figures and displays plots.
  • sns builds the statistical charts used during exploration.
  • fetch_openml retrieves the Titanic dataset in the next step.
  • ColumnTransformer directs different preprocessing steps to different columns.
  • Pipeline chains preprocessing with the classifier.
  • classification_report and ConfusionMatrixDisplay reveal how the final predictions perform.

The cell finishes without a traceback. Your complete analysis toolkit is now loaded inside the notebook.

Seeing an import failure?

Confirm that the dependency installation cell finished before this import cell ran. Rerun the installation cell if it stopped early.

Restart the runtime if Colab requested a restart after changing package versions. Run the import cell again after Colab reconnects.

Help me troubleshoot a project import in Colab.

✔️ Awesome, I've got everything!

Your import cell has every name needed for the remaining Titanic analysis.

ⓧ I'd like to double check the full code

import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

What are you comparing?

Compare this reference with the import cell in analyse_titanic.ipynb. The order and imported names should match exactly.

Before the final check, predict whether the dependency installation kept the selected runtime unchanged.

  • Add a fresh code cell beneath the import cell.
  • Confirm the active Python version by running the verification code again:
import sys; print(sys.version)

What should you see?

The output starts with 3.12.13. The import cell above remains completed without a traceback.

Final check did not pass?

Reselect the 2026.07 runtime if the version output starts with another number. Rerun the dependency installation after Colab reconnects.

Rerun the import cell after the installation finishes. This confirms the packages are available in the current runtime session.

Help me complete the final Colab environment check.

Your Colab environment is pinned and proven to work. Next, you will load the Titanic dataset and expose its missing values before changing anything.

Load and Audit the Titanic Data

Your Google Colab runtime is ready. The project dependencies are installed.

The next job is to fetch the Titanic records from OpenML. You will preserve an untouched source for the audit.

A data audit exposes missing values before cleaning begins. It also counts duplicate rows that could weaken later analysis.

In this step, get ready to:
  • Fetch Titanic version 1 with integer survival labels.
  • Create a copy containing the five variables used throughout the project.
  • Audit the raw data for missing values and complete duplicate rows.
Load the raw Titanic data

The fetch_openml function separates the input columns from the survival target. The as_frame=True option keeps these values in pandas data structures.

The first fetch can take a short while because OpenML downloads the dataset into the Colab runtime.

  • Add a code cell directly beneath the import cell from earlier.
  • Paste the data-loading code below into the new cell.
  • Run the cell using the play icon on its left.
# Charger les données brutes et convertir la cible en entiers.
X_raw, y = fetch_openml(
    "titanic",
    version=1,
    as_frame=True,
    return_X_y=True,
)
y = y.astype(int)

numeric_features = ["age", "fare"]
categorical_features = ["embarked", "sex", "pclass"]
selected_features = numeric_features + categorical_features
X = X_raw[selected_features].copy()

What does this code prepare?

  • The fetch_openml call stores the input columns in X_raw.
  • The same call stores the survival target in y.
  • The y.astype(int) line converts the survival labels into integers.
  • The feature lists separate numerical variables from categorical variables.
  • The copy() call creates X with only the five selected columns.

Good progress. Your notebook now holds the untouched source in X_raw plus the five-column working copy in X.

Did the dataset fail to load?

  • Confirm that your browser still has an Internet connection.
  • Rerun the cell after the connection returns.

Help me troubleshoot a Titanic dataset download failure in Google Colab.

Audit missing values and duplicates

The audit reads from X to inspect the five selected variables. It counts complete duplicates in X_raw so the result still describes the full raw dataset.

Before you run the audit, which of the five columns do you expect to contain missing values?

  • Add a code cell directly beneath the data-loading cell.
  • Paste the audit code below into the new cell.
  • Run the audit cell using the play icon on its left.
# Auditer avant toute modification.
print("Aperçu des données :")
print(X.head())
print("\nValeurs manquantes :")
print(X.isna().sum())
print("\nDoublons complets dans le jeu brut :")
print(X_raw.duplicated().sum())

What does the audit show?

  • The X.head() call displays the first five rows of the selected variables.
  • The X.isna().sum() call counts missing values in each selected column.
  • The X_raw.duplicated().sum() call counts complete duplicate rows in the raw dataset.

You'll see the first five selected rows. Below them, you'll see one missing-value count for each column.

The final line shows the number of complete duplicate rows in X_raw. You now have a visible baseline for every cleaning decision that follows.

Missing some audit output?

  • Confirm that the data-loading cell completed before the audit cell.
  • Check that every print line matches the reference code below.

Help me troubleshoot missing Titanic audit output in Google Colab.

✔️ Awesome, I've got everything!

Your loading cell and audit cell are complete. Confirm that Google Colab has saved the latest notebook changes.

ⓧ I'd like to double check the full code

Compare your notebook cells with this cumulative project code.

import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# Charger les données brutes et convertir la cible en entiers.
X_raw, y = fetch_openml(
    "titanic",
    version=1,
    as_frame=True,
    return_X_y=True,
)
y = y.astype(int)

numeric_features = ["age", "fare"]
categorical_features = ["embarked", "sex", "pclass"]
selected_features = numeric_features + categorical_features
X = X_raw[selected_features].copy()

# Auditer avant toute modification.
print("Aperçu des données :")
print(X.head())
print("\nValeurs manquantes :")
print(X.isna().sum())
print("\nDoublons complets dans le jeu brut :")
print(X_raw.duplicated().sum())

Your raw Titanic dataset is loaded with its data quality issues exposed. Next, you'll clean a separate copy and turn these records into visual evidence.

Clean Data and Visualize Distributions

Votre audit dans Google Colab a rendu visibles les valeurs manquantes du Titanic. Ces trous faussent les comparaisons entre les distributions.

Une copie dédiée à l’analyse exploratoire vous donne des graphiques fondés sur des colonnes complètes. Les données brutes dans X restent intactes pour la modélisation.

In this step, get ready to:
  • Créer une copie distincte des cinq variables pour l’exploration.
  • Remplacer les âges, les tarifs et les ports d’embarquement manquants.
  • Produire deux graphiques sur la classe, l’âge et la survie.
Nettoyer une copie pour l’exploration

Avec pandas, la médiane fournit une valeur centrale pour les colonnes numériques. Le mode fournit la valeur la plus fréquente pour le port d’embarquement.

  • Ajoutez une cellule de code sous la cellule d’audit dans le notebook déjà ouvert.
  • Collez le bloc de nettoyage suivant dans cette nouvelle cellule :
# Préparer une copie nettoyée uniquement pour l'exploration.
data_clean = X.copy()
data_clean["age"] = data_clean["age"].fillna(data_clean["age"].median())
data_clean["fare"] = data_clean["fare"].fillna(data_clean["fare"].median())
data_clean["embarked"] = data_clean["embarked"].fillna(
    data_clean["embarked"].mode().iloc[0]
)
data_clean["survived"] = y

print("\nValeurs manquantes après nettoyage exploratoire :")
print(data_clean.isna().sum())

Ce que fait ce code

  • La ligne data_clean = X.copy() crée la copie réservée à l’exploration.
  • Les colonnes age et fare utilisent leur médiane respective comme valeur de remplacement.
  • La colonne embarked utilise son mode comme valeur de remplacement.
  • La colonne survived associe chaque passager à son étiquette de survie.
  • Le contrôle avec isna().sum() compte les valeurs encore absentes dans chaque colonne.

Avant l’exécution, demandez-vous si le contrôle affichera encore une valeur supérieure à zéro.

  • Exécutez la cellule de nettoyage avec le bouton d’exécution placé à sa gauche.

Vous verrez chaque colonne de data_clean accompagnée de la valeur 0. Votre copie exploratoire est maintenant complète.

Une colonne affiche encore une valeur manquante

  • Vérifiez que vous avez exécuté toute la cellule de nettoyage.
  • Confirmez que les noms age, fare et embarked correspondent exactement aux colonnes de data_clean.
  • Relancez la cellule d’audit si X n’est plus disponible dans le runtime.

Aidez-moi à comprendre pourquoi data_clean contient encore des valeurs manquantes.

Tracer les distributions de classe et d’âge

Le premier graphique de seaborn compare les effectifs de chaque classe selon la survie. Le second utilise Matplotlib pour afficher une distribution empilée des âges.

  • Ajoutez une cellule de code sous la cellule de nettoyage.
  • Collez les deux visualisations suivantes dans cette cellule :
# Visualiser les classes et la distribution des âges.
fig, ax = plt.subplots(figsize=(7, 4))
sns.countplot(data=data_clean, x="pclass", hue="survived", ax=ax)
plt.show()

fig, ax = plt.subplots(figsize=(7, 4))
sns.histplot(
    data=data_clean,
    x="age",
    hue="survived",
    multiple="stack",
    ax=ax,
)
plt.show()

Comment les graphiques sont construits

  • Chaque appel à plt.subplots(figsize=(7, 4)) prépare une figure avec son axe.
  • Le countplot compte les passagers dans chaque valeur de pclass.
  • La couleur définie par survived sépare les deux résultats de survie.
  • Le histplot répartit les âges sur l’axe horizontal.
  • La valeur multiple="stack" empile les groupes de survie dans chaque intervalle d’âge.

Avant d’exécuter la cellule, anticipez la différence entre une comparaison par classe et une distribution continue des âges.

  • Exécutez la cellule des visualisations avec le bouton placé à sa gauche.

Vous verrez d’abord un graphique de classes coloré par survie. Vous verrez ensuite un histogramme empilé des âges coloré par survie.

Les graphiques ne s’affichent pas

  • Exécutez la cellule de nettoyage pour rendre data_clean disponible.
  • Vérifiez que chaque graphique est suivi de plt.show().
  • Confirmez que la cellule d’imports a chargé plt et sns.

Aidez-moi à corriger des graphiques seaborn qui ne s’affichent pas dans Google Colab.

Confirmer les sorties de l’analyse

Avant le contrôle final, demandez-vous quelles sorties prouvent que les données exploratoires sont complètes et comparables.

  • Revenez au résultat de la cellule de nettoyage pour contrôler les comptes affichés.
  • Confirmez que chaque ligne du contrôle affiche 0.
  • Examinez le premier graphique pour comparer les classes selon la survie.
  • Examinez le second graphique pour comparer les distributions d’âge selon la survie.

Beau progrès. Votre notebook transforme maintenant des données incomplètes en deux visualisations que vous pouvez interpréter.

✔️ Awesome, I've got everything!

Parfait. Vérifiez que toutes les cellules du notebook sont enregistrées.

ⓧ I'd like to double check the full code

import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# Charger les données brutes et convertir la cible en entiers.
X_raw, y = fetch_openml(
    "titanic",
    version=1,
    as_frame=True,
    return_X_y=True,
)
y = y.astype(int)

numeric_features = ["age", "fare"]
categorical_features = ["embarked", "sex", "pclass"]
selected_features = numeric_features + categorical_features
X = X_raw[selected_features].copy()

# Auditer avant toute modification.
print("Aperçu des données :")
print(X.head())
print("\nValeurs manquantes :")
print(X.isna().sum())
print("\nDoublons complets dans le jeu brut :")
print(X_raw.duplicated().sum())

# Préparer une copie nettoyée uniquement pour l'exploration.
data_clean = X.copy()
data_clean["age"] = data_clean["age"].fillna(data_clean["age"].median())
data_clean["fare"] = data_clean["fare"].fillna(data_clean["fare"].median())
data_clean["embarked"] = data_clean["embarked"].fillna(
    data_clean["embarked"].mode().iloc[0]
)
data_clean["survived"] = y

print("\nValeurs manquantes après nettoyage exploratoire :")
print(data_clean.isna().sum())

# Visualiser les classes et la distribution des âges.
fig, ax = plt.subplots(figsize=(7, 4))
sns.countplot(data=data_clean, x="pclass", hue="survived", ax=ax)
plt.show()

fig, ax = plt.subplots(figsize=(7, 4))
sns.histplot(
    data=data_clean,
    x="age",
    hue="survived",
    multiple="stack",
    ax=ax,
)
plt.show()

Votre copie exploratoire est complète. Ensuite, vous testerez ce qui arrive lorsqu’un modèle reçoit directement les données brutes.

Test the Naive Model

Votre notebook Google Colab affiche maintenant des données nettoyées ainsi que deux graphiques exploratoires. La prochaine question consiste à vérifier si les données brutes peuvent alimenter directement une prédiction.

La régression logistique attend des entrées numériques exploitables. Le jeu brut contient encore des catégories textuelles ainsi que des valeurs manquantes.

In this step, get ready to:
  • Séparer les données brutes en ensembles d’entraînement et de test.
  • Tester une régression logistique directement sur l’ensemble d’entraînement.
  • Observer l’échec contrôlé sans modifier le jeu de test.
Séparer les données brutes

La séparation entraînement-test réserve une partie des données pour l’évaluation finale. Cette frontière empêche les informations du jeu de test d’influencer l’entraînement.

  • Ajoutez une cellule de code sous l’histogramme des âges.
  • Créez les quatre ensembles en exécutant le code ci-dessous dans cette cellule:
# Séparer les données brutes avant tout prétraitement prédictif.
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=0,
    stratify=y,
)

Que fait cette séparation ?

  • La fonction train_test_split() crée les ensembles d’entraînement et de test à partir de X ainsi que de y.
  • Le paramètre test_size=0.2 réserve 20 % des lignes pour le test.
  • Le paramètre random_state=0 rend la séparation reproductible.
  • Le paramètre stratify=y conserve la répartition des classes de survie.
  • La variable X reste brute. La copie data_clean ne participe pas à cette séparation.

Vous voyez que la cellule se termine sans message d’erreur. Les quatre ensembles sont maintenant disponibles dans la session.

Vous avez bien posé les bases. Le jeu de test reste isolé pour produire une évaluation honnête.

La séparation ne se termine pas ?

  • Réexécutez la cellule d’audit si X ou y n’existe plus dans la session.
  • Vérifiez que la cellule utilise X à la place de data_clean.

Aidez-moi à corriger la séparation de mes données Titanic dans Colab.

Tester l’entraînement direct

Le modèle naïf reçoit exactement les colonnes brutes de X_train. Le bloc contrôlé permet d’observer sa réaction sans interrompre le reste du notebook.

  • Ajoutez une cellule de code sous la cellule de séparation.

Avant de lancer ce test, anticipez mentalement si l’entraînement réussira ou déclenchera l’exception.

  • Lancez l’entraînement naïf dans cette cellule avec le code ci-dessous:
# Obstacle volontaire : le modèle naïf reçoit encore textes et valeurs manquantes.
try:
    naive_model = LogisticRegression()
    naive_model.fit(X_train, y_train)
except (ValueError, TypeError) as error:
    print("\nÉchec attendu du modèle naïf :", type(error).__name__)

Comment fonctionne ce test contrôlé ?

  • Le bloc try tente d’entraîner naive_model directement sur X_train.
  • Le bloc except intercepte ValueError ou TypeError pour permettre au notebook de continuer.
  • L’expression type(error).__name__ affiche uniquement le nom du type d’erreur rencontré.

Vous voyez Échec attendu du modèle naïf : suivi de ValueError ou TypeError.

Bien joué. Cet échec contrôlé prouve que les catégories textuelles et les valeurs manquantes bloquent l’entraînement direct.

Le message attendu ne s’affiche pas ?

  • Vérifiez que l’appel à fit() utilise X_train à la place de data_clean.
  • Réexécutez la cellule de séparation si X_train n’existe plus dans la session.
  • Comparez les lignes try et except avec le bloc fourni pour repérer un problème d’indentation.

Aidez-moi à comprendre pourquoi l’échec contrôlé du modèle naïf ne s’affiche pas.

✔️ Tout est en place

Votre notebook contient maintenant la séparation reproductible ainsi que le test contrôlé du modèle naïf.

ⓧ Je veux vérifier le code complet

import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# Charger les données brutes et convertir la cible en entiers.
X_raw, y = fetch_openml(
    "titanic",
    version=1,
    as_frame=True,
    return_X_y=True,
)
y = y.astype(int)

numeric_features = ["age", "fare"]
categorical_features = ["embarked", "sex", "pclass"]
selected_features = numeric_features + categorical_features
X = X_raw[selected_features].copy()

# Auditer avant toute modification.
print("Aperçu des données :")
print(X.head())
print("\nValeurs manquantes :")
print(X.isna().sum())
print("\nDoublons complets dans le jeu brut :")
print(X_raw.duplicated().sum())

# Préparer une copie nettoyée uniquement pour l'exploration.
data_clean = X.copy()
data_clean["age"] = data_clean["age"].fillna(data_clean["age"].median())
data_clean["fare"] = data_clean["fare"].fillna(data_clean["fare"].median())
data_clean["embarked"] = data_clean["embarked"].fillna(
    data_clean["embarked"].mode().iloc[0]
)
data_clean["survived"] = y

print("\nValeurs manquantes après nettoyage exploratoire :")
print(data_clean.isna().sum())

# Visualiser les classes et la distribution des âges.
fig, ax = plt.subplots(figsize=(7, 4))
sns.countplot(data=data_clean, x="pclass", hue="survived", ax=ax)
plt.show()

fig, ax = plt.subplots(figsize=(7, 4))
sns.histplot(
    data=data_clean,
    x="age",
    hue="survived",
    multiple="stack",
    ax=ax,
)
plt.show()

# Séparer les données brutes avant tout prétraitement prédictif.
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=0,
    stratify=y,
)

# Obstacle volontaire : le modèle naïf reçoit encore textes et valeurs manquantes.
try:
    naive_model = LogisticRegression()
    naive_model.fit(X_train, y_train)
except (ValueError, TypeError) as error:
    print("\nÉchec attendu du modèle naïf :", type(error).__name__)

La limite du modèle naïf est maintenant visible. Dans l’étape suivante, vous préparerez chaque type de variable avant de relancer l’entraînement.

Build and Evaluate the Pipeline

Votre notebook dans Google Colab contient maintenant une séparation reproductible entre entraînement et test. Vous avez aussi vu une régression logistique échouer sur les catégories textuelles et les valeurs manquantes.

Un pipeline de scikit-learn corrige ce blocage en apprenant l’imputation, la standardisation et l’encodage one-hot uniquement sur les données d’entraînement. Il applique ensuite les mêmes transformations aux données de test.

In this step, get ready to:
  • Construire une branche de prétraitement pour chaque type de variable.
  • Assembler les transformations avec le classificateur dans un pipeline reproductible.
  • Mesurer la précision, le rappel et le score F1 avant d’afficher une matrice de confusion.
Construire les branches de prétraitement

Les colonnes numériques et catégorielles ont des besoins différents. Chaque branche prépare un type de variable avant son passage dans le modèle.

  • Ajoutez la branche dédiée à age et fare dans une nouvelle cellule de code en copiant ce bloc:
# Construire les deux branches de prétraitement.
numeric_transformer = Pipeline(
    steps=[
        ("imputer", SimpleImputer(strategy="median")),
        ("scaler", StandardScaler()),
    ]
)

Comment fonctionne la branche numérique ?

  • Le SimpleImputer(strategy="median") apprend une valeur médiane pour remplacer les nombres manquants.
  • Le StandardScaler() place les variables numériques sur des échelles comparables.
  • Le Pipeline conserve l’ordre de ces deux transformations.
  • Exécutez la cellule de la branche numérique.

Premier maillon en place. La cellule se termine sans erreur et numeric_transformer est prêt à traiter les nombres.

La branche numérique ne se crée pas ?

Vérifiez que la cellule d’importation du notebook a bien été exécutée. Contrôlez aussi les parenthèses qui ferment Pipeline et la liste steps.

Vous pouvez demander de l’aide pour corriger la branche numérique.

  • Ajoutez la branche dédiée à embarked, sex et pclass dans une nouvelle cellule de code en copiant ce bloc:
categorical_transformer = Pipeline(
    steps=[
        ("imputer", SimpleImputer(strategy="most_frequent")),
        ("encoder", OneHotEncoder(handle_unknown="ignore")),
    ]
)

Comment fonctionne la branche catégorielle ?

  • Le SimpleImputer(strategy="most_frequent") apprend la catégorie la plus fréquente pour combler les valeurs manquantes.
  • Le OneHotEncoder(handle_unknown="ignore") convertit les catégories en colonnes numériques utilisables par le modèle.
  • Le réglage handle_unknown="ignore" permet de transformer une catégorie inédite dans le jeu de test.
  • Exécutez la cellule de la branche catégorielle.

Voilà les deux familles de colonnes couvertes. La cellule se termine sans erreur et categorical_transformer est disponible pour les catégories.

La branche catégorielle échoue ?

Comparez les noms SimpleImputer et OneHotEncoder avec leurs imports en haut du notebook. Vérifiez aussi les guillemets autour de most_frequent et ignore.

Vous pouvez demander de l’aide pour corriger la branche catégorielle.

Assembler le prétraitement et entraîner le modèle

Le ColumnTransformer dirige chaque colonne vers la branche appropriée. Cette structure garde les règles de traitement attachées aux variables concernées.

  • Reliez les deux branches aux listes de variables dans une nouvelle cellule de code en copiant ce bloc:
preprocessor = ColumnTransformer(
    transformers=[
        ("numeric", numeric_transformer, numeric_features),
        ("categorical", categorical_transformer, categorical_features),
    ]
)

Que fait le préprocesseur ?

  • L’entrée numeric applique numeric_transformer aux colonnes de numeric_features.
  • L’entrée categorical applique categorical_transformer aux colonnes de categorical_features.
  • Le modèle reçoit ensuite une seule table numérique issue des deux branches.
  • Exécutez la cellule du préprocesseur.

Le routage des colonnes est maintenant défini. La cellule se termine sans erreur et preprocessor rassemble les deux branches.

Le préprocesseur ne se crée pas ?

Exécutez d’abord les deux cellules qui définissent numeric_transformer et categorical_transformer. Vérifiez ensuite que numeric_features et categorical_features existent toujours dans la session.

Vous pouvez demander de l’aide pour vérifier le ColumnTransformer.

  • Ajoutez le classificateur au préprocesseur dans une nouvelle cellule de code en copiant ce bloc:
model = Pipeline(
    steps=[
        ("preprocessor", preprocessor),
        ("classifier", LogisticRegression()),
    ]
)

model.fit(X_train, y_train)
y_pred = model.predict(X_test)

Comment le modèle évite-t-il la fuite de données ?

  • L’étape preprocessor apprend les remplacements et les transformations à partir de X_train.
  • L’étape classifier ajuste LogisticRegression() sur les données transformées.
  • L’appel model.predict(X_test) applique les transformations apprises avant de produire les prédictions.
  • Le jeu de test reste extérieur à l’apprentissage des valeurs de remplacement.
  • Exécutez la cellule d’entraînement et de prédiction.

Le passage clé est franchi. La cellule se termine sans exception et y_pred contient une prédiction pour chaque ligne de X_test.

L’entraînement du pipeline échoue ?

Vérifiez que les cellules de séparation des données et de prétraitement ont été exécutées dans l’ordre. Une session Colab redémarrée doit exécuter les cellules précédentes avant de retrouver X_train et preprocessor.

Vous pouvez demander de l’aide pour diagnostiquer l’entraînement du pipeline.

Évaluer les prédictions

Le rapport de classification mesure le comportement du modèle pour chaque classe. Il permet de comparer les performances sur la non-survie et la survie.

  • Ajoutez le rapport de classification dans une nouvelle cellule de code en copiant ce bloc:
print("\nRapport de classification :")
print(
    classification_report(
        y_test,
        y_pred,
        target_names=["Non-survie", "Survie"],
    )
)

Comment lire le rapport ?

  • La précision indique la part de prédictions d’une classe qui sont correctes.
  • Le rappel indique la part des cas réels d’une classe que le modèle retrouve.
  • Le score F1 équilibre la précision et le rappel dans une seule mesure.

Avant l’exécution, pensez-vous que les deux classes obtiendront des résultats identiques ? Gardez votre hypothèse en tête.

  • Exécutez la cellule du rapport de classification.

Votre modèle devient mesurable. Vous voyez un rapport avec des lignes pour Non-survie et Survie ainsi que leurs mesures de précision, de rappel et de score F1.

Le rapport ne s’affiche pas ?

Vérifiez que la cellule précédente a créé y_pred. Contrôlez aussi que l’import de classification_report a été exécuté au début du notebook.

Vous pouvez demander de l’aide pour afficher le rapport de classification.

  • Ajoutez la matrice de confusion dans une nouvelle cellule de code en copiant ce bloc:
ConfusionMatrixDisplay.from_predictions(
    y_test,
    y_pred,
    display_labels=["Non-survie", "Survie"],
    cmap="Blues",
)
plt.show()

Que montre la matrice ?

  • Les cases diagonales regroupent les prédictions qui correspondent aux classes réelles.
  • Les autres cases regroupent les confusions entre survie et non-survie.
  • Les étiquettes permettent d’identifier la direction de chaque erreur.

Avant d’exécuter cette dernière cellule, où pensez-vous voir le plus grand nombre d’observations ? Comparez ensuite votre intuition avec la diagonale.

  • Exécutez la cellule de la matrice de confusion.

Vous voyez une matrice bleue de 2 × 2 avec les étiquettes Non-survie et Survie sur les deux axes. Chaque case contient le nombre de prédictions correspondant à cette combinaison.

La matrice ne s’affiche pas ?

Vérifiez que ConfusionMatrixDisplay et plt ont été importés. Exécutez aussi la cellule qui crée y_pred avant de relancer le graphique.

Vous pouvez demander de l’aide pour afficher la matrice de confusion.

✔️ Awesome, I've got everything!

Votre code cumulatif correspond au pipeline complet. Le rapport et la matrice confirment que le modèle peut maintenant être évalué.

ⓧ I'd like to double check the full code

import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# Charger les données brutes et convertir la cible en entiers.
X_raw, y = fetch_openml(
    "titanic",
    version=1,
    as_frame=True,
    return_X_y=True,
)
y = y.astype(int)

numeric_features = ["age", "fare"]
categorical_features = ["embarked", "sex", "pclass"]
selected_features = numeric_features + categorical_features
X = X_raw[selected_features].copy()

# Auditer avant toute modification.
print("Aperçu des données :")
print(X.head())
print("\nValeurs manquantes :")
print(X.isna().sum())
print("\nDoublons complets dans le jeu brut :")
print(X_raw.duplicated().sum())

# Préparer une copie nettoyée uniquement pour l'exploration.
data_clean = X.copy()
data_clean["age"] = data_clean["age"].fillna(data_clean["age"].median())
data_clean["fare"] = data_clean["fare"].fillna(data_clean["fare"].median())
data_clean["embarked"] = data_clean["embarked"].fillna(
    data_clean["embarked"].mode().iloc[0]
)
data_clean["survived"] = y

print("\nValeurs manquantes après nettoyage exploratoire :")
print(data_clean.isna().sum())

# Visualiser les classes et la distribution des âges.
fig, ax = plt.subplots(figsize=(7, 4))
sns.countplot(data=data_clean, x="pclass", hue="survived", ax=ax)
plt.show()

fig, ax = plt.subplots(figsize=(7, 4))
sns.histplot(
    data=data_clean,
    x="age",
    hue="survived",
    multiple="stack",
    ax=ax,
)
plt.show()

# Séparer les données brutes avant tout prétraitement prédictif.
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=0,
    stratify=y,
)

# Obstacle volontaire : le modèle naïf reçoit encore textes et valeurs manquantes.
try:
    naive_model = LogisticRegression()
    naive_model.fit(X_train, y_train)
except (ValueError, TypeError) as error:
    print("\nÉchec attendu du modèle naïf :", type(error).__name__)

# Construire les deux branches de prétraitement.
numeric_transformer = Pipeline(
    steps=[
        ("imputer", SimpleImputer(strategy="median")),
        ("scaler", StandardScaler()),
    ]
)

categorical_transformer = Pipeline(
    steps=[
        ("imputer", SimpleImputer(strategy="most_frequent")),
        ("encoder", OneHotEncoder(handle_unknown="ignore")),
    ]
)

preprocessor = ColumnTransformer(
    transformers=[
        ("numeric", numeric_transformer, numeric_features),
        ("categorical", categorical_transformer, categorical_features),
    ]
)

model = Pipeline(
    steps=[
        ("preprocessor", preprocessor),
        ("classifier", LogisticRegression()),
    ]
)

model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("\nRapport de classification :")
print(
    classification_report(
        y_test,
        y_pred,
        target_names=["Non-survie", "Survie"],
    )
)

ConfusionMatrixDisplay.from_predictions(
    y_test,
    y_pred,
    display_labels=["Non-survie", "Survie"],
    cmap="Blues",
)
plt.show()

Votre notebook couvre maintenant tout le parcours prédictif. Les données brutes sont transformées sans fuite avant d’alimenter un modèle évalué avec plusieurs métriques.

Secret mission

Mission secrète : Créer le graphique de synthèse du portfolio

Transformez votre analyse en une conclusion visuelle accessible à un public non technique. Vous allez comparer le taux moyen de survie par classe et par sexe avant de rédiger deux observations fondées sur le graphique.

Clean Up Your Resources

Clean Up Your Resources

Vous pouvez conserver votre travail, déconnecter le runtime pour revenir plus tard ou supprimer les ressources du projet. Ce projet utilise l’offre gratuite de Google Colab et ne crée aucun coût récurrent.

Resources you used:

  • Le notebook analyse_titanic.ipynb enregistré dans Google Drive.
  • Le runtime temporaire Google Colab utilisé pour exécuter l’analyse.
  • Le cache temporaire du jeu de données Titanic dans le runtime.
  • Les dépendances du projet installées dans le runtime temporaire.

Keep everything running

Aucune action n’est nécessaire. Cette option convient si vous poursuivez l’analyse.

  • Conservez analyse_titanic.ipynb dans Google Drive.
  • Utilisez le runtime Colab déjà connecté pour poursuivre vos essais.
  • Gardez les cellules Markdown finales avec vos observations.

Pause - I'll come back to this later

La pause libère le runtime Colab. Le notebook reste enregistré dans Google Drive.

  • Dans l’onglet Colab déjà ouvert, ouvrez le menu du runtime.
  • Utilisez l’option de déconnexion du runtime actuel.
  • Vérifiez que Colab indique que le runtime est déconnecté.
  • Laissez analyse_titanic.ipynb dans Google Drive.

Les fichiers temporaires du runtime peuvent disparaître pendant la pause. Votre notebook reste disponible pour une prochaine session.

Delete - I don't want to use this again

Cette option supprime le notebook du projet ainsi que le runtime temporaire. Votre compte Google reste intact.

Supprimer le runtime Colab :

  • Dans l’onglet Colab déjà ouvert, ouvrez le menu du runtime.
  • Utilisez la commande dédiée à la suppression du runtime actuel.
  • Vérifiez que Colab indique qu’aucun runtime n’est connecté.

Supprimer le notebook :

  • Accédez à Google Drive avec le compte utilisé pour Colab.
  • Recherchez analyse_titanic.ipynb dans votre espace Drive.
  • Sélectionnez analyse_titanic.ipynb dans les résultats.
  • Utilisez le menu contextuel du fichier pour le placer dans la corbeille.
  • Accédez à la corbeille de Google Drive.
  • Sélectionnez de nouveau analyse_titanic.ipynb.
  • Utilisez l’option de suppression définitive du fichier.
  • Recherchez une dernière fois analyse_titanic.ipynb dans Google Drive.

Vous ne devriez plus voir le notebook dans les résultats. Les ressources créées pour ce projet sont maintenant supprimées.

Nice Work!

Nice Work!

Bravo ! Vous avez construit un notebook d’analyse complet dans Google Colab pour étudier les facteurs associés à la survie sur le Titanic.

Vous avez appris à :

  • Réaliser un audit de données sur le jeu Titanic. Vous savez repérer les valeurs manquantes. Vous savez aussi mesurer les doublons complets.
  • Préparer une copie nettoyée pour l’exploration. Vous avez produit un graphique des classes par survie. Vous avez aussi visualisé la distribution des âges par survie.
  • Construire un pipeline reproductible après avoir observé la limite du modèle naïf. Vous avez évalué une régression logistique avec un rapport de classification. Vous avez ensuite interprété sa matrice de confusion.
  • Secret Mission : créer un graphique de synthèse comparant le taux moyen de survie par classe. Votre graphique sépare aussi les résultats par sexe. Vous avez formulé deux observations fondées sur ce résultat visible.

Votre notebook est prêt à être relancé dans Google Colab. Il présente un parcours complet depuis les données brutes jusqu’à l’évaluation des prédictions.

Prêt à tester vos connaissances ?