Archives Wild Code School
Python

Introduction to Cookiecutter for Data Science Projects

Quête 39 sur 66

1.1. Qu'est-ce que Cookiecutter ?

Cookiecutter est un outil open-source en ligne de commande (command-line tool : outil qui s'utilise au clavier dans un terminal) écrit en Python qui aide les développeurs et les data scientists (spécialistes de l'analyse de données) à créer rapidement et efficacement des projets structurés à partir de modèles. Il agit comme un outil de squelette de projet (scaffolding tool : outil qui génère automatiquement l'ossature de dossiers et de fichiers d'un projet), ce qui permet d'amorcer (bootstrap : démarrer à partir d'une base toute prête) de nouveaux projets en générant des structures de fichiers et de dossiers prédéfinies, adaptées à des besoins précis.

Fondamentalement, Cookiecutter simplifie les tâches répétitives en permettant de définir des templates (modèles de projet réutilisables) avec des placeholders (espaces réservés qui seront remplacés par une valeur). Ces placeholders sont remplacés dynamiquement par des informations fournies par l'utilisateur, comme le nom du projet, les coordonnées de l'auteur, ou d'autres informations personnalisées. Les templates peuvent contenir n'importe quoi, de simples dossiers à des fichiers entièrement préconfigurés avec du contenu variable.

Fonctionnalités clés :

  • Flexibilité : personnalise les templates pour s'adapter à divers types de projets (data science, développement web, etc.).
  • Simplicité : l'utilisateur interagit via des invites (prompts : questions affichées dans le terminal auxquelles tu réponds) pour remplir les variables du template, sans aucune connaissance préalable en programmation.
  • Évolutivité : les templates peuvent être partagés et réutilisés entre équipes, ce qui garantit une uniformité dans la mise en place des projets.

Pourquoi est-ce important ?

  • Des structures de projet standardisées sont essentielles pour maintenir la cohérence, surtout dans les environnements collaboratifs.
  • Les templates prédéfinis éliminent les tâches de mise en place manuelles et répétitives, ce qui te permet de te concentrer sur des tâches à plus forte valeur comme le code et l'analyse.

1.2. Pourquoi utiliser Cookiecutter en data science ?

Les projets de data science comportent souvent des composants structurels similaires, comme des dossiers de données brutes et traitées, des dossiers de code source et des fichiers de documentation. Mettre en place ces composants manuellement pour chaque projet peut être fastidieux et source d'erreurs. Cookiecutter répond à ce défi en offrant une manière cohérente et automatisée de créer de telles structures de projet.

Avantages de Cookiecutter en data science :

  1. Cohérence :

    • Tous les projets suivent le même agencement de dossiers, ce qui assure l'uniformité entre les équipes et dans le temps.
    • Facilite la navigation des collaborateurs dans le travail des autres.
  2. Reproductibilité :

    • Les templates incluent des fichiers essentiels comme requirements.txt, ce qui garantit que les environnements de projet sont bien documentés et faciles à reproduire.
    • Des structures claires favorisent une meilleure gestion de versions et de meilleures pratiques de gestion des données.
  3. Gain de temps :

    • Au lieu de passer du temps à créer des dossiers, des fichiers README ou du code de base, tu peux commencer ton analyse ou ta modélisation immédiatement.
    • Libère de l'énergie mentale pour les tâches liées aux données plutôt que pour la mise en place répétitive.

Comparaison avec une mise en place manuelle :

Aspect Mise en place manuelle Cookiecutter
Efficacité Chronophage, source d'erreurs. La mise en place entièrement automatisée réduit le temps et l'effort.
Personnalisation Nécessite des modifications manuelles à chaque projet. Les invites automatiques gèrent la personnalisation sans effort.
Reproductibilité Peut manquer de standards cohérents entre projets. Impose une structure uniforme et inclut les bonnes pratiques par défaut.
Collaboration Plus dur pour les équipes de comprendre des mises en place qui varient. Les équipes partagent une structure commune, ce qui améliore la communication et l'intégration.

En utilisant Cookiecutter, les équipes de data science peuvent accélérer l'initialisation des projets, réduire les erreurs humaines et maintenir des standards de qualité élevés sur tous les projets, de l'analyse exploratoire aux pipelines de production.

1.3. Prérequis

Pour utiliser Cookiecutter avec succès dans tes projets de data science, il est important de vérifier que tu remplis quelques prérequis de base. Ces conditions t'aideront à mettre en place Cookiecutter et à travailler avec lui efficacement, même en tant que débutante.


1. Connaissances de base en Python

Cookiecutter est écrit en Python et repose sur l'écosystème Python. Tu n'as pas besoin de compétences Python avancées pour utiliser Cookiecutter, mais être à l'aise avec les concepts suivants rendra les choses plus fluides :

  • Installer des packages Python avec pip ou conda.
  • Lancer des scripts Python simples et comprendre la syntaxe Python.
  • Utiliser des éditeurs de texte pour voir et modifier des fichiers de configuration comme le JSON.

2. Aisance avec l'interface en ligne de commande (CLI)

Cookiecutter fonctionne via la ligne de commande (CLI, Command-Line Interface : la fenêtre où tu tapes des commandes au clavier), donc être à l'aise avec les commandes CLI de base est essentiel. Si tu débutes avec la ligne de commande, voici quelques concepts clés à comprendre :

  • Naviguer dans les dossiers : des commandes comme cd (changer de dossier) et ls/dir (lister le contenu d'un dossier).
  • Lancer des commandes : exécuter des commandes dans un terminal ou une invite de commande, comme python ou cookiecutter.
  • Gestion de base des fichiers : créer, supprimer et déplacer des fichiers ou des dossiers.

Si tu n'es pas encore à l'aise avec la CLI, c'est une excellente occasion de pratiquer ces compétences fondamentales !


3. Installation de Python

Suis ces étapes pour installer Python sur ton système :

Étape 1 : Installer Python
  1. Télécharger Python :

    • Va sur le site officiel de Python.
    • Télécharge la dernière version compatible avec ton système d'exploitation (Windows, macOS ou Linux).
  2. Installer Python :

    • Lance l'installateur et sélectionne l'option pour ajouter Python à ton PATH (PATH : la liste des dossiers où le système va chercher les programmes à exécuter) (important pour utiliser Python dans la CLI).
    • Termine le processus d'installation.
  3. Vérifier l'installation :

    • Ouvre ton terminal ou ton invite de commande et tape :
      bash
      python --version
      
    • Tu devrais voir s'afficher la version de Python installée.
Configuration optionnelle : créer un environnement général

Il peut être utile de maintenir un environnement Python polyvalent où Cookiecutter est toujours disponible :

  • Utilise conda ou venv pour créer un environnement dédié à Cookiecutter et aux autres outils que tu utilises souvent.
  • Active l'environnement avant de commencer toute mise en place de projet.

2.1. Installer Cookiecutter

Avec pip (le gestionnaire de packages de Python)

  1. Ouvre un terminal ou une invite de commande.
  2. Lance la commande suivante :
    bash
    pip install cookiecutter
    
  3. Vérifie l'installation :
    bash
    cookiecutter --version
    

Avec conda (si tu utilises Anaconda)

  1. Ouvre ton terminal Anaconda.
  2. Lance la commande suivante :
    bash
    conda install -c conda-forge cookiecutter
    
  3. Confirme l'installation :
    bash
    cookiecutter --version
    

2.2. Explorer les templates existants

Où trouver des templates

On trouve des templates Cookiecutter dans divers dépôts (repositories : espaces de stockage de code, souvent sur GitHub), notamment :

  • GitHub : un large éventail de templates pour des projets Python, des frameworks web et la data science.
  • Index des templates Cookiecutter : une liste sélectionnée de templates populaires.

Exemple : le template Cookiecutter Data Science

L'un des templates les plus populaires pour les projets de data science est Cookiecutter Data Science (CCDS). Il fournit une structure de projet logique, standardisée et pourtant flexible, qui s'aligne sur les bonnes pratiques des workflows (workflow : enchaînement des étapes de travail) de data science. Cette structure comprend des dossiers prédéfinis pour les données brutes, les données traitées, les notebooks, les modèles, les rapports, et plus encore.

Pour en savoir plus sur la philosophie de CCDS et ses mises à jour, consulte son dépôt GitHub.

Structure typique générée par ce template :

project-name/
├── data/
│   ├── raw/                <- Original data
│   ├── processed/          <- Finalized datasets
│   └── external/           <- Data from third parties
├── notebooks/              <- Jupyter notebooks
├── src/                    <- Source code for project logic
├── reports/
│   └── figures/            <- Generated visualizations
├── README.md               <- Project overview
├── .gitignore              <- Git configuration
└── requirements.txt        <- Python dependencies

Utiliser un template comme celui-ci garantit la cohérence entre les projets, ce qui facilite la collaboration des équipes et la reproduction des résultats.

Dans cette section, nous allons apprendre à utiliser un template Cookiecutter existant pour mettre en place rapidement un nouveau projet de data science. Nous utiliserons le template cookiecutter-data-science mis à jour (version 2), qui fournit une structure de dossiers bien organisée intégrant les bonnes pratiques des projets de data science.

3.1. Créer un nouveau projet

Déroulons les étapes pour créer un nouveau projet de data science avec la dernière version du template cookiecutter-data-science.

Étape 1 : Installer Cookiecutter Data Science

Le template cookiecutter-data-science a été mis à jour en version 2. Cette version nécessite d'installer le package Python cookiecutter-data-science, qui étend les fonctionnalités de l'utilitaire Cookiecutter. Nous utiliserons le programme en ligne de commande ccds fourni, au lieu de la commande cookiecutter.

Prérequis :

  • Python 3.8 ou supérieur.

Options d'installation :

Avec pipx (recommandé) :

pipx est un outil qui t'aide à installer et à lancer des applications Python dans des environnements isolés.

bash
pipx install cookiecutter-data-science

Avec pip :

Si tu préfères utiliser pip, tu peux installer le package directement :

bash
pip install cookiecutter-data-science

Note : comme cookiecutter-data-science est un utilitaire valable pour plusieurs projets, il est recommandé de l'installer dans un environnement polyvalent.

Étape 2 : Choisir un emplacement pour tes projets

Décide où tu veux stocker tes projets de data science. Pour cet exemple, nous allons créer un dossier appelé AllProjects.

bash
# Create the directory if it doesn't exist
mkdir AllProjects

# Navigate into the directory
cd AllProjects

Étape 3 : Générer un nouveau projet à partir du template

Maintenant, nous allons utiliser la commande ccds (fournie par cookiecutter-data-science) pour générer un nouveau projet.

bash
ccds

Étape 4 : Répondre aux invites

Après avoir lancé la commande ccds, des invites te demanderont de fournir des informations pour personnaliser ton projet.

Exemple d'invites :

project_name [Default Project]: Customer Churn Analysis
module_name [customer_churn_analysis]:
author_name [Your Name]: Alex Johnson
author_email [your.email@example.com]: alex.johnson@example.com
description [A short description of the project.]: Analyzing factors contributing to customer churn.
open_source_license [MIT]:

Explication des invites :

  • project_name : le nom de ton projet. Ce sera aussi le nom du dossier racine.
  • module_name : le nom du module Python pour le code source de ton projet. Par défaut, c'est une version nettoyée de project_name.
  • author_name : ton nom ou le nom de ton organisation.
  • author_email : ton adresse e-mail.
  • description : une brève description de ton projet.
  • open_source_license : la licence open-source de ton projet (MIT par défaut).

Appuie sur Entrée après chaque invite pour accepter la valeur par défaut, ou saisis la tienne.

Étape 5 : Examiner le projet créé

Une fois que tu as fourni les informations demandées, cookiecutter-data-science va générer un nouveau dossier contenant ton projet. Liste le contenu de ton dossier AllProjects :

bash
ls

Tu devrais voir un nouveau dossier nommé customer-churn-analysis (ou le nom que tu as fourni pour project_name).

Étape 6 : Aller dans ton nouveau projet

Place-toi dans le dossier de ton projet :

bash
cd customer-churn-analysis

Bravo ! Tu as réussi à créer un nouveau projet de data science avec le template cookiecutter-data-science.

3.2. Explorer la structure du template

Maintenant que nous avons créé le projet, explorons la structure des dossiers pour comprendre comment elle est organisée et comment l'utiliser dans ton workflow de data science.

Comprendre la structure des dossiers

Voici à quoi ressemble la structure des dossiers :

customer-churn-analysis/
├── LICENSE
├── Makefile
├── README.md
├── data
│   ├── external
│   ├── interim
│   ├── processed
│   └── raw
├── docs
│   └── mkdocs.yml
├── models
├── notebooks
├── pyproject.toml
├── references
├── reports
│   └── figures
├── requirements.txt
├── setup.cfg
└── customer_churn_analysis
    ├── __init__.py
    ├── config.py
    ├── dataset.py
    ├── features.py
    ├── modeling
    │   ├── __init__.py
    │   ├── predict.py
    │   └── train.py
    └── plots.py

Composants clés de la structure

Passons en revue chaque partie du dossier pour comprendre son rôle.

Dossier racine
  • LICENSE : le fichier de licence de ton projet (par exemple la licence MIT).
  • README.md : un fichier markdown qui donne une vue d'ensemble de ton projet. C'est là que tu décris les objectifs de ton projet, les instructions d'installation, l'utilisation et toute autre information pertinente.
  • Makefile : contient des commandes pratiques pour automatiser des tâches comme la mise en place de l'environnement ou le lancement des scripts d'entraînement. Tu peux utiliser des commandes comme make data ou make train.
  • pyproject.toml : un fichier de configuration qui contient les métadonnées de ton projet et la configuration d'outils comme Black (code formatter : formateur de code, outil qui met ton code en forme automatiquement).
  • requirements.txt : liste toutes les dépendances Python requises pour ton projet. Tu peux les installer avec pip install -r requirements.txt.
  • setup.cfg : fichier de configuration pour des outils comme Flake8 (qui vérifie le respect des règles de style du code).
data/

Ce dossier est structuré pour organiser tes données à différentes étapes :

  • data/raw/ : le dépôt de données d'origine, immuable (immutable : qui ne doit jamais être modifié). Ne modifie pas ces fichiers directement.
  • data/interim/ : données intermédiaires qui ont été transformées pendant les étapes de traitement.
  • data/processed/ : les jeux de données finaux, propres et prêts pour la modélisation.
  • data/external/ : données provenant de sources tierces.
docs/

Contient la documentation de ton projet. Le template inclut un projet MkDocs par défaut pour t'aider à créer la documentation de ton projet.

  • docs/mkdocs.yml : fichier de configuration de MkDocs.
models/

Ce dossier sert à stocker les modèles entraînés, les modèles sérialisés, les prédictions des modèles ou les résumés de modèles.

notebooks/

Un endroit pour garder tes notebooks Jupyter :

  • Convention de nommage : utilise un système de numérotation et des initiales pour garder tes notebooks organisés.
    • Exemple : 1.0-aj-initial-data-exploration.ipynb
references/

Comprend les dictionnaires de données, les manuels et autres documents explicatifs.

reports/

Analyses générées au format HTML, PDF ou autres.

  • reports/figures/ : contient les graphiques et figures générés à utiliser dans les rapports.
customer_churn_analysis/

C'est le dossier principal du code source de ton projet (nommé d'après module_name).

  • init.py : un fichier vide qui indique à Python de traiter ce dossier comme un package.
  • config.py : un endroit pour stocker les variables utiles et les réglages de configuration de ton projet.
  • dataset.py : scripts pour télécharger ou générer des données.
  • features.py : code pour créer des caractéristiques (features : variables d'entrée utilisées par un modèle) adaptées à la modélisation.
  • plots.py : scripts pour créer des visualisations.
modeling/

Un sous-package pour le code lié aux modèles.

  • init.py : initialise le sous-package modeling.
  • train.py : scripts pour entraîner des modèles de machine learning (apprentissage automatique).
  • predict.py : scripts pour faire des prédictions à l'aide des modèles entraînés.
tests/

(Non représenté ci-dessus, mais tu peux ajouter un dossier tests/.)

  • Contient les tests unitaires du code de ton projet.

Avantages de cette structure

  • Cohérence : fournit une structure standardisée entre différents projets.
  • Organisation : sépare données, code, documentation et rapports, ce qui facilite la navigation et la maintenance.
  • Reproductibilité : encourage les pratiques qui aident à reproduire les résultats, comme garder les données brutes immuables et documenter les transformations de données.
  • Collaboration : permet aux membres de l'équipe de comprendre plus facilement l'agencement du projet et de contribuer efficacement.

Explorer les fichiers

Regardons de plus près quelques fichiers clés.

README.md

Ce fichier sert de page d'accueil au dépôt de ton projet. Il présente le projet et fournit les informations essentielles.

Exemple de contenu :

markdown
# Customer Churn Analysis

Analyzing factors contributing to customer churn.

## Project Overview

This project aims to identify patterns and factors that lead to customer churn using historical data.

## Installation

To install the required packages:

```bash
pip install -r requirements.txt

Project Organization

...


##### **Makefile**

Un `Makefile` contient des commandes qui automatisent des tâches courantes. Par exemple :

```makefile
install:
	pip install -r requirements.txt

data:
	python customer_churn_analysis/dataset.py

train:
	python customer_churn_analysis/modeling/train.py

Tu peux lancer ces commandes avec make <commande>, comme make install.

pyproject.toml

Ce fichier inclut les métadonnées du projet et la configuration des outils de développement.

Exemple de contenu :

toml
[tool.black]
line-length = 88
target-version = ['py38']

[tool.isort]
profile = "black"
customer_churn_analysis/config.py

Un endroit central pour stocker les variables de configuration, comme les chemins de fichiers ou les paramètres de modèles.

Exemple de contenu :

python
DATA_PATH = 'data'
RAW_DATA_PATH = f'{DATA_PATH}/raw'
PROCESSED_DATA_PATH = f'{DATA_PATH}/processed'
customer_churn_analysis/dataset.py

Scripts pour l'ingestion des données et leur traitement initial.

Exemple de contenu :

python
import pandas as pd
from config import RAW_DATA_PATH, PROCESSED_DATA_PATH

def load_raw_data():
    # Implement code to load raw data
    pass

def preprocess_data():
    # Implement preprocessing steps
    pass

if __name__ == '__main__':
    load_raw_data()
    preprocess_data()
customer_churn_analysis/modeling/train.py

Scripts pour entraîner tes modèles.

Exemple de contenu :

python
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib
from customer_churn_analysis.features import prepare_features
from config import MODELS_PATH

def train_model():
    X, y = prepare_features()
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    model = RandomForestClassifier()
    model.fit(X_train, y_train)
    joblib.dump(model, f'{MODELS_PATH}/random_forest.pkl')

if __name__ == '__main__':
    train_model()

Démarrer avec ton projet

  1. Installer les dépendances : installe les packages Python requis.

    bash
    pip install -r requirements.txt
    
  2. Ingestion des données : utilise dataset.py pour charger et prétraiter tes données.

    bash
    python customer_churn_analysis/dataset.py
    
  3. Feature engineering (création des variables d'entrée du modèle) : implémente la création des features dans features.py.

  4. Entraînement du modèle : entraîne tes modèles avec train.py.

    bash
    python customer_churn_analysis/modeling/train.py
    
  5. Prédiction du modèle : utilise predict.py pour faire des prédictions avec ton modèle entraîné.

  6. Visualisation : génère des visualisations avec plots.py et enregistre-les dans reports/figures/.

  7. Documentation : mets à jour ton README.md et utilise MkDocs pour créer une documentation détaillée du projet.

    bash
    mkdocs serve
    

Exemple de workflow

  • Étape 1 : place tes fichiers de données brutes dans data/raw/.
  • Étape 2 : écris le code de traitement des données dans dataset.py pour nettoyer et prétraiter les données.
  • Étape 3 : explore les données avec des notebooks dans notebooks/.
  • Étape 4 : implémente le feature engineering dans features.py.
  • Étape 5 : entraîne les modèles avec train.py.
  • Étape 6 : évalue les modèles et visualise les résultats avec plots.py.
  • Étape 7 : documente tes conclusions et les changements de code dans README.md et avec MkDocs.

Personnaliser le template

N'hésite pas à modifier la structure des dossiers ou les fichiers pour les adapter aux besoins de ton projet. Tu peux :

  • Ajouter de nouveaux dossiers (par exemple scripts/ pour des scripts utilitaires).
  • Mettre à jour les fichiers de configuration.
  • Inclure des outils supplémentaires ou ajuster les réglages dans pyproject.toml.

Dans cette section, nous allons voir comment créer ton propre template Cookiecutter à partir de zéro. Cela te permet de mettre en place de nouveaux projets de data science rapidement, de façon cohérente et avec tous les composants nécessaires que tu préfères. Les templates personnalisés peuvent te faire gagner du temps et garantir que tous tes projets suivent la même structure et les mêmes bonnes pratiques.

4.1. Les bases des templates personnalisés

Avant de nous lancer dans la construction d'un template, il est essentiel de comprendre la structure d'un template Cookiecutter et le rôle du fichier cookiecutter.json.

Structure d'un template Cookiecutter

Un template Cookiecutter est un dossier qui contient tous les fichiers et dossiers que tu veux inclure dans tes nouveaux projets. Les caractéristiques clés d'un template sont :

  • Variables : des placeholders qui seront remplacés par des valeurs fournies par l'utilisateur lors de la génération d'un nouveau projet.
  • Noms de fichiers et de dossiers avec variables : utiliser des variables dans les noms de fichiers et de dossiers pour les personnaliser par projet.
  • Contenu de fichiers avec variables : inclure des variables dans le contenu des fichiers pour les personnaliser.

La structure générale ressemble à ceci :

your-template-name/
├── cookiecutter.json
├── {{cookiecutter.variable_name}}/
│   ├── file1.txt
│   └── subfolder/
│       └── file2.txt
└── other_files_or_folders/

Le rôle de cookiecutter.json

Le fichier cookiecutter.json est au cœur de ton template. Il définit les variables et les invites que Cookiecutter utilisera lors de la génération d'un nouveau projet. Chaque paire clé-valeur dans cookiecutter.json représente :

  • Clé : le nom de la variable utilisée dans ton template.
  • Valeur : la valeur par défaut ou une liste d'options pour la variable.

Exemple de cookiecutter.json :

json
{
    "project_name": "my_project",
    "author_name": "Your Name",
    "email": "your.email@example.com",
    "description": "A short description of the project."
}

Quand tu lances le template, Cookiecutter lit cookiecutter.json et te demande de fournir une valeur pour chaque variable, en utilisant les valeurs par défaut si tu appuies sur Entrée sans rien taper.

4.2. Guide pas à pas pour construire un template

Créons un template Cookiecutter simple, étape par étape.

Étape 1 : Créer le dossier racine

D'abord, décide où tu veux stocker ton template. Tu peux avoir un dossier où tu gardes tous tes templates, comme cookiecutter-templates/.

Crée un nouveau dossier pour ton template :

bash
# Navigate to your templates directory
cd path/to/cookiecutter-templates/

# Create a new folder for your template
mkdir my-cookiecutter-template
cd my-cookiecutter-template

Étape 2 : Ajouter un dossier avec variable

À l'intérieur de ton dossier de template, crée le dossier racine de tes projets. Nous utiliserons une variable pour le nom du projet afin de pouvoir le personnaliser.

Crée un dossier nommé {{cookiecutter.project_name}} :

bash
mkdir "{{cookiecutter.project_name}}"

Les doubles accolades {{ }} désignent une variable que Cookiecutter remplacera par la valeur que tu fournis lors de la génération d'un projet.

Ton dossier de template ressemble maintenant à ceci :

my-cookiecutter-template/
└── {{cookiecutter.project_name}}/

Étape 3 : Écrire un fichier cookiecutter.json

Ensuite, crée le fichier cookiecutter.json dans my-cookiecutter-template/ :

bash
# Inside my-cookiecutter-template/
touch cookiecutter.json

Ouvre cookiecutter.json dans ton éditeur de texte et ajoute les variables :

json
{
    "project_name": "my_data_science_project",
    "author_name": "Your Name",
    "email": "your.email@example.com",
    "description": "A short description of the project."
}
  • project_name : le nom de ton projet.
  • author_name : ton nom complet.
  • email : ton adresse e-mail.
  • description : une brève description du projet.

Enregistre le fichier.

À ce stade, la structure de ton dossier de template est :

my-cookiecutter-template/
├── cookiecutter.json
└── {{cookiecutter.project_name}}/

4.3. Ajouter des fichiers et des dossiers

Maintenant, ajoutons des fichiers et des dossiers au template et personnalisons-les à l'aide de variables.

Comment inclure et personnaliser le contenu des fichiers

Tous les fichiers et dossiers que tu ajoutes dans {{cookiecutter.project_name}}/ seront inclus dans le projet généré. Tu peux aussi utiliser des variables dans les noms de fichiers et dans le contenu des fichiers pour les personnaliser.

Exemple : ajouter un README.md personnalisé

Ajoutons un fichier README.md qui inclut le nom du projet, sa description et les informations sur l'auteur.

Étape 1 : Créer le fichier README.md

Crée un nouveau fichier README.md dans {{cookiecutter.project_name}}/ :

bash
# Inside my-cookiecutter-template/{{cookiecutter.project_name}}/
touch README.md

Étape 2 : Personnaliser README.md avec des variables

Ouvre README.md et ajoute le contenu suivant :

markdown
# {{cookiecutter.project_name}}

{{cookiecutter.description}}

## Project Structure

- **data/**: Data used in the project.
- **notebooks/**: Jupyter notebooks.
- **src/**: Source code files.

## Author

**{{cookiecutter.author_name}}**  
Email: {{cookiecutter.email}}

Dans ce README.md :

  • Nous utilisons {{cookiecutter.project_name}} pour inclure le nom du projet comme titre principal.
  • Nous incluons {{cookiecutter.description}} pour la description du projet.
  • Nous listons quelques dossiers typiques que tu pourrais avoir dans un projet de data science.
  • Nous incluons le nom et l'e-mail de l'auteur avec {{cookiecutter.author_name}} et {{cookiecutter.email}}.

Étape 3 : Ajouter des dossiers supplémentaires

Ajoutons quelques-uns des dossiers mentionnés dans le README.md :

bash
# Inside my-cookiecutter-template/{{cookiecutter.project_name}}/
mkdir data notebooks src

Tu peux aussi créer des sous-dossiers si besoin. Par exemple :

bash
# Inside data directory
mkdir data/raw data/processed

Maintenant, la structure de ton dossier de template est :

my-cookiecutter-template/
├── cookiecutter.json
└── {{cookiecutter.project_name}}/
    ├── README.md
    ├── data/
    │   ├── raw/
    │   └── processed/
    ├── notebooks/
    └── src/

Personnaliser d'autres fichiers

Tu peux ajouter d'autres fichiers et les personnaliser à l'aide des variables. Par exemple, tu pourrais vouloir ajouter un fichier requirements.txt pour les dépendances ou un script Python dans src/.

Ajouter requirements.txt

Crée requirements.txt :

bash
# Inside {{cookiecutter.project_name}}/
touch requirements.txt

En option, tu peux ajouter quelques packages courants :

# requirements.txt

pandas
numpy
matplotlib

Ajouter un script Python

Crée un script Python main.py dans src/ :

bash
# Inside src/
touch main.py

Tu peux personnaliser main.py avec un en-tête :

python
# main.py

"""
Project: {{cookiecutter.project_name}}
Author: {{cookiecutter.author_name}}
Description: {{cookiecutter.description}}
"""

def main():
    print("Hello, world!")

if __name__ == "__main__":
    main()

Utiliser le template

Maintenant, voyons comment utiliser ce template pour créer un nouveau projet.

Étape 1 : Lancer Cookiecutter

Place-toi dans le dossier où tu veux créer ton projet et lance :

bash
cookiecutter path/to/my-cookiecutter-template

Remplace path/to/my-cookiecutter-template par le vrai chemin vers ton dossier de template.

Étape 2 : Fournir les variables

Cookiecutter va te demander chaque variable :

project_name [my_data_science_project]:
author_name [Your Name]:
email [your.email@example.com]:
description [A short description of the project.]:

Tu peux accepter les valeurs par défaut en appuyant sur Entrée ou saisir les tiennes.

Exemple de saisie :

project_name [my_data_science_project]: heart-disease-analysis
author_name [Your Name]: Alice Smith
email [your.email@example.com]: alice.smith@example.com
description [A short description of the project.]: Analysis of heart disease dataset.

Étape 3 : Explorer ton nouveau projet

Cookiecutter va créer un nouveau dossier nommé heart-disease-analysis avec la structure suivante :

heart-disease-analysis/
├── README.md
├── data/
│   ├── raw/
│   └── processed/
├── notebooks/
├── requirements.txt
└── src/
    └── main.py
  • README.md inclura le nom de ton projet, sa description et les informations sur l'auteur.
  • main.py aura l'en-tête personnalisé.

Contenu de README.md :

markdown
# heart-disease-analysis

Analysis of heart disease dataset.

## Project Structure

- **data/**: Data used in the project.
- **notebooks/**: Jupyter notebooks.
- **src/**: Source code files.

## Author

**Alice Smith**  
Email: alice.smith@example.com

Contenu de main.py :

python
"""
Project: heart-disease-analysis
Author: Alice Smith
Description: Analysis of heart disease dataset.
"""

def main():
    print("Hello, world!")

if __name__ == "__main__":
    main()

Prochaines étapes

  • Enrichir ton template : ajoute d'autres fichiers, comme des fichiers de configuration, des dossiers de tests ou des scripts de traitement de données.
  • Utiliser plus de variables : introduis des variables supplémentaires dans cookiecutter.json pour personnaliser encore plus tes projets.
  • Partager ton template : envisage de partager ton template avec d'autres en l'hébergeant sur une plateforme comme GitHub.

En créant et en personnalisant tes propres templates Cookiecutter, tu te donnes, à toi et à ton équipe, les moyens de simplifier la mise en place des projets et de te concentrer sur les parties importantes de ton travail de data science.

5.1. Logique conditionnelle avec Jinja2

Les templates Cookiecutter prennent en charge des fonctionnalités avancées grâce au moteur de templates Jinja2 (templating engine : moteur qui remplit un modèle avec des valeurs et gère la logique de génération), ce qui te permet d'inclure de la logique conditionnelle et des boucles.

Ajouter du contenu dynamique avec des instructions If

Comment ça marche

  • Syntaxe Jinja2 : utilise {% if condition %} et {% endif %} pour inclure ou exclure du contenu selon des conditions.

  • Variables et comparaisons : tu peux comparer des variables définies dans cookiecutter.json ou issues de la saisie de l'utilisateur.

Exemple : choisir une équipe parmi des options prédéfinies

Supposons que tu veuilles que le template adapte son contenu selon l'équipe choisie par l'utilisateur.

Guide pas à pas

  1. Définir des variables avec des options dans cookiecutter.json :

    json
    {
        "project_name": "My Project",
        "author_name": "Your Name",
        "author_email": "your.email@example.com",
        "team": ["Data Team", "AI Team", "Research Team"]
    }
    
  2. Modifier les fichiers du template avec de la logique conditionnelle :

    Dans README.md, ajoute :

    markdown
    # {{cookiecutter.project_name}}
    
    **Author**: {{cookiecutter.author_name}}  
    **Email**: <{{cookiecutter.author_email}}>
    
    ## Team Members
    
    {% if cookiecutter.team == 'Data Team' %}
    - Data Team Member 1
    - Data Team Member 2
    {% elif cookiecutter.team == 'AI Team' %}
    - AI Team Member A
    - AI Team Member B
    {% elif cookiecutter.team == 'Research Team' %}
    - Researcher X
    - Researcher Y
    {% endif %}
    
    ## Overview
    
    This project is about...
    

Utiliser le template

Pendant la génération du template :

bash
$ cookiecutter path/to/data_science_template
project_name [My Project]: Sales Forecast
author_name [Your Name]: Bob Johnson
author_email [your.email@example.com]: bob.johnson@example.com
team:
1 - Data Team
2 - AI Team
3 - Research Team
Choose from 1, 2, 3 [1]: 2
  • Note : Cookiecutter présente automatiquement les options sous forme de liste.

Le README.md généré inclura les membres de l'AI Team :

markdown
# Sales Forecast

**Author**: Bob Johnson  
**Email**: <bob.johnson@example.com>

## Team Members

- AI Team Member A
- AI Team Member B

## Overview

This project is about...

Avantages de la logique conditionnelle

  • Contenu dynamique : adapte les fichiers et le contenu selon les choix de l'utilisateur.

  • Flexibilité : crée des templates polyvalents, adaptés à divers scénarios, sans dupliquer de code.

Construis ton propre template Cookiecutter

Objectif : créer un template Cookiecutter qui génère une structure de base de projet de data science avec les éléments suivants :

  • Structure de dossiers :
    • data/raw/
    • data/processed/
    • src/
    • notebooks/
  • Fichiers personnalisés :
    • README.md qui inclut le nom et la description du projet.
    • requirements.txt qui liste les dépendances du projet.

Instructions :

  1. Mettre en place le dossier du template

    • Crée un nouveau dossier pour ton template appelé basic_data_science_template.
  2. Créer le fichier cookiecutter.json

    • Dans basic_data_science_template, crée un fichier nommé cookiecutter.json.
    • Ce fichier définira les variables qui seront remplacées dans ton template.
  3. Définir les variables du template

    • Ouvre cookiecutter.json et ajoute du contenu pour définir des variables pour :
      • Le nom du projet
      • Le nom de l'auteur
      • La description du projet
  4. Créer la structure de dossiers du projet

    • Dans basic_data_science_template, crée un dossier nommé {{cookiecutter.project_name}}.
    • Dans {{cookiecutter.project_name}}, crée les dossiers requis :
      • data/raw/
      • data/processed/
      • src/
      • notebooks/
  5. Ajouter un fichier README.md personnalisé

    • Dans {{cookiecutter.project_name}}, crée un fichier README.md.
    • Utilise les variables de cookiecutter.json pour inclure le nom du projet, l'auteur et la description.
  6. Ajouter un fichier requirements.txt

    • Dans {{cookiecutter.project_name}}, crée un fichier requirements.txt.
    • Inclus quelques bibliothèques courantes de data science comme pandas, numpy et matplotlib.
  7. Tester ton template

    • Utilise Cookiecutter pour générer un nouveau projet à partir de ton template.
    • Vérifie que le projet généré a la bonne structure et que les fichiers contiennent le contenu attendu.

1. Mettre en place le dossier du template

D'abord, nous allons créer un nouveau dossier pour notre template.

  • Commande :

    bash
    mkdir basic_data_science_template
    

Ce dossier contiendra tous les fichiers et dossiers qui définissent notre template.


2. Créer le fichier cookiecutter.json

Place-toi dans ton dossier de template et crée le fichier cookiecutter.json.

  • Commandes :

    bash
    cd basic_data_science_template
    touch cookiecutter.json
    

3. Définir les variables du template

Ouvre cookiecutter.json dans ton éditeur de texte préféré (comme Notepad, VSCode ou n'importe quel éditeur que tu préfères) et ajoute le contenu suivant :

json
{
  "project_name": "my_data_science_project",
  "author_name": "Your Name",
  "description": "A short description of the project"
}
  • Explication :
    • Les clés ("project_name", "author_name", "description") sont les variables pour lesquelles Cookiecutter te demandera de fournir des valeurs.
    • Les valeurs ("my_data_science_project", "Your Name", etc.) sont les valeurs par défaut qui seront utilisées si tu te contentes d'appuyer sur Entrée pendant les invites.

4. Créer la structure de dossiers du projet

Maintenant, nous allons créer la structure de dossiers de notre projet.

a. Créer le dossier racine du projet

  • Commande :

    bash
    mkdir "{{cookiecutter.project_name}}"
    
  • Note : les doubles accolades {{ }} sont utilisées par Cookiecutter pour indiquer des variables. Ici, nous créons un dossier nommé d'après le project_name que tu saisis.

b. Aller dans le dossier du projet

  • Commande :

    bash
    cd "{{cookiecutter.project_name}}"
    

c. Créer les sous-dossiers

  • Commandes :

    bash
    mkdir -p data/raw
    mkdir -p data/processed
    mkdir src
    mkdir notebooks
    
  • Explication :

    • mkdir -p crée un dossier ainsi que tous les dossiers parents nécessaires.
    • Nous avons créé la structure suivante :
      • data/raw/
      • data/processed/
      • src/
      • notebooks/

5. Ajouter un fichier README.md personnalisé

Crée un fichier README.md dans {{cookiecutter.project_name}}.

  • Commande :

    bash
    touch README.md
    

Ouvre README.md avec ton éditeur de texte et ajoute le contenu suivant :

markdown
# {{cookiecutter.project_name}}

**Author**: {{cookiecutter.author_name}}

## Description

{{cookiecutter.description}}

## Project Structure

{{cookiecutter.project_name}}/ ├── data/ │ ├── raw/ │ └── processed/ ├── notebooks/ ├── src/ ├── README.md └── requirements.txt


  • Explication :
    • Nous avons utilisé les variables {{cookiecutter.project_name}}, {{cookiecutter.author_name}} et {{cookiecutter.description}} pour personnaliser le README de chaque nouveau projet.

6. Ajouter un fichier requirements.txt

Crée un fichier requirements.txt dans {{cookiecutter.project_name}}.

  • Commande :

    bash
    touch requirements.txt
    

Ouvre requirements.txt et ajoute les lignes suivantes :

txt
pandas
numpy
matplotlib
scikit-learn
  • Explication :
    • Ce sont des bibliothèques Python courantes utilisées dans les projets de data science.
    • Tu peux personnaliser cette liste selon tes préférences ou les besoins de ton projet.

7. Tester ton template

Maintenant, voyons notre template en action !

a. Revenir au dossier parent

  • Commande :

    bash
    cd ../../
    
  • Cela te ramène au dossier qui contient basic_data_science_template.

b. Utiliser Cookiecutter pour générer un nouveau projet

  • Commande :

    bash
    cookiecutter basic_data_science_template
    
  • Explication :

    • Quand tu lances cette commande, Cookiecutter va chercher le fichier cookiecutter.json dans basic_data_science_template et te demander chaque variable.

c. Remplir les invites

Tu verras des invites comme celle-ci :

project_name [my_data_science_project]:
author_name [Your Name]:
description [A short description of the project]:
  • Exemple de saisie :

    • Pour project_name, tu pourrais saisir : customer_segmentation
    • Pour author_name, saisis ton nom : Jane Doe
    • Pour description, par exemple : Analyzing customer data to identify segments.
  • Astuce : si tu te contentes d'appuyer sur Entrée, la valeur par défaut entre crochets sera utilisée.

d. Vérifier le projet généré

Après avoir répondu aux invites, Cookiecutter va générer un nouveau dossier nommé d'après ton project_name.

  • Commande :

    bash
    ls
    
  • Résultat attendu :

    basic_data_science_template/  customer_segmentation/
    

Ton nouveau dossier de projet customer_segmentation devrait avoir la structure suivante :

customer_segmentation/
├── data/
│   ├── raw/
│   └── processed/
├── notebooks/
├── src/
├── README.md
└── requirements.txt

1.1. What is Cookiecutter?

Cookiecutter is an open-source command-line tool written in Python that helps developers and data scientists create structured, templated projects quickly and efficiently. It acts as a project scaffolding tool, enabling users to bootstrap new projects by generating pre-defined file and folder structures tailored to specific needs.

At its core, Cookiecutter simplifies repetitive tasks by allowing users to define templates with placeholders. These placeholders are dynamically replaced with user-provided inputs, such as project names, author details, or other custom information. Templates can include anything from simple directories to fully pre-configured files with variable content.

Key Features:

  • Flexibility: Customize templates to fit diverse project types (e.g., data science, web development, etc.).
  • Simplicity: Users interact via prompts to fill in the template variables, requiring no prior programming knowledge.
  • Scalability: Templates can be shared and reused across teams, ensuring uniformity in project setups.

Why is this important?

  • Standardized project structures are essential for maintaining consistency, especially in collaborative environments.
  • Pre-defined templates eliminate repetitive, manual setup tasks, allowing users to focus on higher-value tasks like coding and analysis.

1.2. Why Use Cookiecutter in Data Science?

Data science projects often involve similar structural components, such as raw and processed data folders, source code directories, and documentation files. Setting up these components manually for every project can be tedious and error-prone. Cookiecutter addresses this challenge by providing a consistent and automated way to create such project structures.

Benefits of Cookiecutter in Data Science:

  1. Consistency:

    • All projects follow the same directory layout, ensuring uniformity across teams and time.
    • Makes it easier for collaborators to navigate each other's work.
  2. Reproducibility:

    • Templates include essential files like requirements.txt, ensuring project environments are well-documented and easy to replicate.
    • Clear structures promote better version control and data handling practices.
  3. Time-Saving:

    • Instead of spending time creating directories, README files, or boilerplate code, users can start their analysis or modeling immediately.
    • Frees up mental energy for data-related tasks rather than repetitive setup.

Comparison with Manual Setup:

Aspect Manual Setup Cookiecutter
Efficiency Time-intensive, error-prone. Fully automated setup reduces time and effort.
Customization Requires manual edits for every new project. Automated prompts handle customization effortlessly.
Reproducibility May lack consistent standards across projects. Enforces a uniform structure and includes best practices by default.
Collaboration Harder for teams to understand varying setups. Teams share a common structure, improving communication and onboarding.

By using Cookiecutter, data science teams can accelerate project initialization, reduce human errors, and maintain high-quality standards across all projects, from exploratory analysis to production-grade pipelines.

1.3. Prerequisites

To successfully use Cookiecutter for data science projects, it's important to ensure you meet a few basic prerequisites. These requirements will help you set up and work with Cookiecutter efficiently, even as a beginner.


1. Basic Python Knowledge

Cookiecutter is written in Python and relies on Python's ecosystem. While you don't need advanced Python skills to use Cookiecutter, familiarity with the following concepts will make the process smoother:

  • Installing Python packages using pip or conda.
  • Running basic Python scripts and understanding Python syntax.
  • Using text editors to view and edit configuration files like JSON.

2. Command-Line Interface (CLI) Familiarity

Cookiecutter operates via the command line, so being comfortable with basic CLI commands is essential. If you're new to the command line, here are some key concepts to understand:

  • Navigating Directories: Commands like cd (change directory) and ls/dir (list contents of a directory).
  • Running Commands: Executing commands in a terminal or command prompt, such as python or cookiecutter.
  • Basic File Management: Creating, deleting, and moving files or directories.

If you're not yet familiar with the CLI, this is a great opportunity to practice these fundamental skills!


3. Installation of Python

Follow these steps to install Python on your system:

Step 1: Install Python
  1. Download Python:

    • Visit the official Python website.
    • Download the latest version compatible with your operating system (Windows, macOS, or Linux).
  2. Install Python:

    • Run the installer and select the option to add Python to your PATH (important for using Python in the CLI).
    • Complete the installation process.
  3. Verify Installation:

    • Open your terminal or command prompt and type:
      bash
      python --version
      
    • You should see the installed Python version displayed.
Optional Setup: Create a General Environment

It can be helpful to maintain a general-purpose Python environment where Cookiecutter is always available:

  • Use conda or venv to create an environment dedicated to Cookiecutter and other tools you frequently use.
  • Activate the environment before starting any project setup.

2.1. Installing Cookiecutter

Using pip (Python's Package Manager)

  1. Open a terminal or command prompt.
  2. Run the following command:
    bash
    pip install cookiecutter
    
  3. Verify installation:
    bash
    cookiecutter --version
    

Using conda (if using Anaconda)

  1. Open your Anaconda terminal.
  2. Run the following command:
    bash
    conda install -c conda-forge cookiecutter
    
  3. Confirm installation:
    bash
    cookiecutter --version
    

2.2. Exploring Existing Templates

Where to Find Templates

Cookiecutter templates can be found in various repositories, including:

Example: Cookiecutter Data Science Template

One of the most popular templates for data science projects is Cookiecutter Data Science (CCDS). It provides a logical, standardized, yet flexible project structure that aligns with best practices for data science workflows. This structure includes predefined folders for raw data, processed data, notebooks, models, reports, and more.

To learn about CCDS's philosophy and updates, visit its GitHub repository.

Typical structure generated by this template:

project-name/
├── data/
│   ├── raw/                <- Original data
│   ├── processed/          <- Finalized datasets
│   └── external/           <- Data from third parties
├── notebooks/              <- Jupyter notebooks
├── src/                    <- Source code for project logic
├── reports/
│   └── figures/            <- Generated visualizations
├── README.md               <- Project overview
├── .gitignore              <- Git configuration
└── requirements.txt        <- Python dependencies

Using a template like this ensures consistency across projects, making it easier for teams to collaborate and reproduce results.

In this section, we'll learn how to use an existing Cookiecutter template to quickly set up a new data science project. We'll use the updated cookiecutter-data-science template (version 2), which provides a well-organized directory structure that incorporates best practices for data science projects.

3.1. Creating a New Project

Let's walk through the steps to create a new data science project using the latest cookiecutter-data-science template.

Step 1: Install Cookiecutter Data Science

The cookiecutter-data-science template has been updated to version 2. This version requires installing the cookiecutter-data-science Python package, which extends the functionality of the Cookiecutter utility. We'll use the provided ccds command-line program instead of the cookiecutter command.

Requirements:

  • Python 3.8 or higher.

Installation Options:

Using pipx (recommended):

pipx is a tool to help you install and run Python applications in isolated environments.

bash
pipx install cookiecutter-data-science

Using pip:

If you prefer to use pip, you can install the package directly:

bash
pip install cookiecutter-data-science

Note: Since cookiecutter-data-science is a cross-project utility application, it's recommended to install it in a general-purpose environment.

Step 2: Choose a Location for Your Projects

Decide where you want to store your data science projects. For this example, we'll create a directory called AllProjects.

bash
# Create the directory if it doesn't exist
mkdir AllProjects

# Navigate into the directory
cd AllProjects

Step 3: Generate a New Project Using the Template

Now, we'll use the ccds command (provided by cookiecutter-data-science) to generate a new project.

bash
ccds

Step 4: Respond to the Prompts

After running the ccds command, you'll be prompted to provide information to customize your project.

Example Prompts:

project_name [Default Project]: Customer Churn Analysis
module_name [customer_churn_analysis]:
author_name [Your Name]: Alex Johnson
author_email [your.email@example.com]: alex.johnson@example.com
description [A short description of the project.]: Analyzing factors contributing to customer churn.
open_source_license [MIT]:

Explanation of the Prompts:

  • project_name: The name of your project. This will also be the name of the root directory.
  • module_name: The Python module name for your project's source code. By default, it's a sanitized version of project_name.
  • author_name: Your name or your organization's name.
  • author_email: Your email address.
  • description: A brief description of your project.
  • open_source_license: The open-source license for your project (default is MIT).

Press Enter after each prompt to accept the default value or provide your own.

Step 5: Review the Created Project

Once you've provided the required information, cookiecutter-data-science will generate a new directory with your project. List the contents of your AllProjects directory:

bash
ls

You should see a new folder named customer-churn-analysis (or the name you provided for project_name).

Step 6: Navigate to Your New Project

Change into your project directory:

bash
cd customer-churn-analysis

Great job! You've successfully created a new data science project using the cookiecutter-data-science template.

3.2. Exploring the Template Structure

Now that we've created the project, let's explore the directory structure to understand how it's organized and how you can use it in your data science workflow.

Understanding the Directory Structure

Here's what the directory structure looks like:

customer-churn-analysis/
├── LICENSE
├── Makefile
├── README.md
├── data
│   ├── external
│   ├── interim
│   ├── processed
│   └── raw
├── docs
│   └── mkdocs.yml
├── models
├── notebooks
├── pyproject.toml
├── references
├── reports
│   └── figures
├── requirements.txt
├── setup.cfg
└── customer_churn_analysis
    ├── __init__.py
    ├── config.py
    ├── dataset.py
    ├── features.py
    ├── modeling
    │   ├── __init__.py
    │   ├── predict.py
    │   └── train.py
    └── plots.py

Key Components of the Structure

Let's walk through each part of the directory to understand its purpose.

Root Directory
  • LICENSE: The license file for your project (e.g., MIT License).
  • README.md: A markdown file that provides an overview of your project. This is where you describe your project's objectives, installation instructions, usage, and other relevant information.
  • Makefile: Contains convenience commands to automate tasks like setting up the environment or running training scripts. You can use commands like make data or make train.
  • pyproject.toml: A configuration file that contains metadata for your project and configuration for tools like Black (code formatter).
  • requirements.txt: Lists all the Python dependencies required for your project. You can install these with pip install -r requirements.txt.
  • setup.cfg: Configuration file for tools like Flake8 (style guide enforcement).
data/

This directory is structured to organize your data at different stages:

  • data/raw/: The original, immutable data dump. Do not edit these files directly.
  • data/interim/: Intermediate data that has been transformed during the data processing steps.
  • data/processed/: The final, clean data sets ready for modeling.
  • data/external/: Data from third-party sources.
docs/

Contains documentation for your project. The template includes a default MkDocs project to help you create project documentation.

  • docs/mkdocs.yml: Configuration file for MkDocs.
models/

This directory is for storing trained models, serialized models, model predictions, or model summaries.

notebooks/

A place to keep your Jupyter notebooks:

  • Naming Convention: Use a numbering system and initials to keep notebooks organized.
    • Example: 1.0-aj-initial-data-exploration.ipynb
references/

Includes data dictionaries, manuals, and other explanatory materials.

reports/

Generated analysis as HTML, PDF, or other formats.

  • reports/figures/: Contains generated graphics and figures to use in reporting.
customer_churn_analysis/

This is the main source code directory for your project (named after module_name).

  • init.py: An empty file that tells Python to treat this directory as a package.
  • config.py: A place to store useful variables and configuration settings for your project.
  • dataset.py: Scripts to download or generate data.
  • features.py: Code to create features suitable for modeling.
  • plots.py: Scripts to create visualizations.
modeling/

A subpackage for model-related code.

  • init.py: Initializes the modeling subpackage.
  • train.py: Scripts to train machine learning models.
  • predict.py: Scripts to make predictions using trained models.
tests/

(Not shown above, but you can add a tests/ directory.)

  • Contains unit tests for your project code.

Benefits of This Structure

  • Consistency: Provides a standardized structure across different projects.
  • Organization: Separates data, code, documentation, and reports, making it easy to navigate and maintain.
  • Reproducibility: Encourages practices that help in reproducing results, such as keeping raw data immutable and documenting data transformations.
  • Collaboration: Makes it easier for team members to understand the project's layout and contribute effectively.

Exploring the Files

Let's take a closer look at some key files.

README.md

This file serves as the front page of your project repository. It introduces the project and provides essential information.

Example content:

markdown
# Customer Churn Analysis

Analyzing factors contributing to customer churn.

## Project Overview

This project aims to identify patterns and factors that lead to customer churn using historical data.

## Installation

To install the required packages:

```bash
pip install -r requirements.txt

Project Organization

...


##### **Makefile**

A `Makefile` contains commands that automate common tasks. For example:

```makefile
install:
	pip install -r requirements.txt

data:
	python customer_churn_analysis/dataset.py

train:
	python customer_churn_analysis/modeling/train.py

You can run these commands using make <command>, such as make install.

pyproject.toml

This file includes project metadata and configuration for development tools.

Example content:

toml
[tool.black]
line-length = 88
target-version = ['py38']

[tool.isort]
profile = "black"
customer_churn_analysis/config.py

A central place to store configuration variables, such as file paths or model parameters.

Example content:

python
DATA_PATH = 'data'
RAW_DATA_PATH = f'{DATA_PATH}/raw'
PROCESSED_DATA_PATH = f'{DATA_PATH}/processed'
customer_churn_analysis/dataset.py

Scripts for data ingestion and initial processing.

Example content:

python
import pandas as pd
from config import RAW_DATA_PATH, PROCESSED_DATA_PATH

def load_raw_data():
    # Implement code to load raw data
    pass

def preprocess_data():
    # Implement preprocessing steps
    pass

if __name__ == '__main__':
    load_raw_data()
    preprocess_data()
customer_churn_analysis/modeling/train.py

Scripts to train your models.

Example content:

python
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib
from customer_churn_analysis.features import prepare_features
from config import MODELS_PATH

def train_model():
    X, y = prepare_features()
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    model = RandomForestClassifier()
    model.fit(X_train, y_train)
    joblib.dump(model, f'{MODELS_PATH}/random_forest.pkl')

if __name__ == '__main__':
    train_model()

Getting Started with Your Project

  1. Install Dependencies: Install the required Python packages.

    bash
    pip install -r requirements.txt
    
  2. Data Ingestion: Use dataset.py to load and preprocess your data.

    bash
    python customer_churn_analysis/dataset.py
    
  3. Feature Engineering: Implement feature creation in features.py.

  4. Model Training: Train your models using train.py.

    bash
    python customer_churn_analysis/modeling/train.py
    
  5. Model Prediction: Use predict.py to make predictions with your trained model.

  6. Visualization: Generate visualizations using plots.py and save them in reports/figures/.

  7. Documentation: Update your README.md and use MkDocs to create detailed project documentation.

    bash
    mkdocs serve
    

Example Workflow

  • Step 1: Place your raw data files into data/raw/.
  • Step 2: Write data processing code in dataset.py to clean and preprocess data.
  • Step 3: Explore data using notebooks in notebooks/.
  • Step 4: Implement feature engineering in features.py.
  • Step 5: Train models using train.py.
  • Step 6: Evaluate models and visualize results with plots.py.
  • Step 7: Document findings and code changes in README.md and with MkDocs.

Customizing the Template

Feel free to modify the directory structure or files to fit your project's needs. You can:

  • Add new directories (e.g., scripts/ for utility scripts).
  • Update configuration files.
  • Include additional tools or adjust settings in pyproject.toml.

In this section, we'll explore how to create your own Cookiecutter template from scratch. This allows you to set up new data science projects quickly, consistently, and with all the necessary components you prefer. Custom templates can save you time and ensure that all your projects follow the same structure and best practices.

4.1. Basics of Custom Templates

Before we dive into building a template, it's essential to understand the structure of a Cookiecutter template and the role of the cookiecutter.json file.

Structure of a Cookiecutter Template

A Cookiecutter template is a directory (folder) that contains all the files and folders you want to include in your new projects. The key features of a template include:

  • Variables: Placeholders that will be replaced with user-provided values when generating a new project.
  • Templatized File and Folder Names: Using variables in file and folder names to customize them per project.
  • Templatized File Content: Including variables within file content to personalize the files.

The general structure looks like this:

your-template-name/
├── cookiecutter.json
├── {{cookiecutter.variable_name}}/
│   ├── file1.txt
│   └── subfolder/
│       └── file2.txt
└── other_files_or_folders/

The Role of cookiecutter.json

The cookiecutter.json file is at the heart of your template. It defines the variables and prompts that Cookiecutter will use when generating a new project. Each key-value pair in cookiecutter.json represents:

  • Key: The variable name used in your template.
  • Value: The default value or a list of options for the variable.

Example cookiecutter.json:

json
{
    "project_name": "my_project",
    "author_name": "Your Name",
    "email": "your.email@example.com",
    "description": "A short description of the project."
}

When you run the template, Cookiecutter reads cookiecutter.json and asks you to provide values for each variable, using the defaults if you press enter without typing anything.

4.2. Step-by-Step Guide to Build a Template

Let's create a simple Cookiecutter template step by step.

Step 1: Creating the Root Folder

First, decide where you want to store your template. You might have a folder where you keep all your templates, like cookiecutter-templates/.

Create a new directory for your template:

bash
# Navigate to your templates directory
cd path/to/cookiecutter-templates/

# Create a new folder for your template
mkdir my-cookiecutter-template
cd my-cookiecutter-template

Step 2: Adding a Templatized Directory

Inside your template folder, create the root directory for your projects. We'll use a variable for the project name so it can be customized.

Create a directory named {{cookiecutter.project_name}}:

bash
mkdir "{{cookiecutter.project_name}}"

The double braces {{ }} denote a variable that Cookiecutter will replace with the value you provide when generating a project.

Your template directory now looks like:

my-cookiecutter-template/
└── {{cookiecutter.project_name}}/

Step 3: Writing a cookiecutter.json File

Next, create the cookiecutter.json file inside my-cookiecutter-template/:

bash
# Inside my-cookiecutter-template/
touch cookiecutter.json

Open cookiecutter.json in your text editor and add the variables:

json
{
    "project_name": "my_data_science_project",
    "author_name": "Your Name",
    "email": "your.email@example.com",
    "description": "A short description of the project."
}
  • project_name: The name of your project.
  • author_name: Your full name.
  • email: Your email address.
  • description: A brief description of the project.

Save the file.

At this point, your template directory structure is:

my-cookiecutter-template/
├── cookiecutter.json
└── {{cookiecutter.project_name}}/

4.3. Adding Files and Folders

Now, let's add files and folders to the template and customize them using variables.

How to Include and Customize Content in Files

Any files and folders you add inside {{cookiecutter.project_name}}/ will be included in the generated project. You can also use variables in file names and within file contents to personalize them.

Example: Adding a Personalized README.md

Let's add a README.md file that includes the project's name, description, and author information.

Step 1: Create the README.md File

Create a new file README.md inside {{cookiecutter.project_name}}/:

bash
# Inside my-cookiecutter-template/{{cookiecutter.project_name}}/
touch README.md

Step 2: Customize README.md with Variables

Open README.md and add the following content:

markdown
# {{cookiecutter.project_name}}

{{cookiecutter.description}}

## Project Structure

- **data/**: Data used in the project.
- **notebooks/**: Jupyter notebooks.
- **src/**: Source code files.

## Author

**{{cookiecutter.author_name}}**  
Email: {{cookiecutter.email}}

In this README.md:

  • We use {{cookiecutter.project_name}} to include the project's name as the main heading.
  • We include {{cookiecutter.description}} for the project description.
  • We list some typical folders you might have in a data science project.
  • We include the author's name and email using {{cookiecutter.author_name}} and {{cookiecutter.email}}.

Step 3: Add Additional Folders

Let's add some of the folders mentioned in the README.md:

bash
# Inside my-cookiecutter-template/{{cookiecutter.project_name}}/
mkdir data notebooks src

You can also create subdirectories if needed. For example:

bash
# Inside data directory
mkdir data/raw data/processed

Now, your template directory structure is:

my-cookiecutter-template/
├── cookiecutter.json
└── {{cookiecutter.project_name}}/
    ├── README.md
    ├── data/
    │   ├── raw/
    │   └── processed/
    ├── notebooks/
    └── src/

Customizing Other Files

You can add more files and customize them using the variables. For instance, you might want to add a requirements.txt file for dependencies or a Python script in src/.

Adding requirements.txt

Create requirements.txt:

bash
# Inside {{cookiecutter.project_name}}/
touch requirements.txt

Optionally, you can add some common packages:

# requirements.txt

pandas
numpy
matplotlib

Adding a Python Script

Create a Python script main.py inside src/:

bash
# Inside src/
touch main.py

You can customize main.py with a header:

python
# main.py

"""
Project: {{cookiecutter.project_name}}
Author: {{cookiecutter.author_name}}
Description: {{cookiecutter.description}}
"""

def main():
    print("Hello, world!")

if __name__ == "__main__":
    main()

Using the Template

Now, let's see how to use this template to create a new project.

Step 1: Run Cookiecutter

Navigate to the directory where you want to create your project and run:

bash
cookiecutter path/to/my-cookiecutter-template

Replace path/to/my-cookiecutter-template with the actual path to your template directory.

Step 2: Provide the Variables

Cookiecutter will prompt you for each variable:

project_name [my_data_science_project]:
author_name [Your Name]:
email [your.email@example.com]:
description [A short description of the project.]:

You can accept the default values by pressing Enter or type in your own.

Example Input:

project_name [my_data_science_project]: heart-disease-analysis
author_name [Your Name]: Alice Smith
email [your.email@example.com]: alice.smith@example.com
description [A short description of the project.]: Analysis of heart disease dataset.

Step 3: Explore Your New Project

Cookiecutter will create a new directory named heart-disease-analysis with the following structure:

heart-disease-analysis/
├── README.md
├── data/
│   ├── raw/
│   └── processed/
├── notebooks/
├── requirements.txt
└── src/
    └── main.py
  • README.md will include your project name, description, and author information.
  • main.py will have the customized header.

Content of README.md:

markdown
# heart-disease-analysis

Analysis of heart disease dataset.

## Project Structure

- **data/**: Data used in the project.
- **notebooks/**: Jupyter notebooks.
- **src/**: Source code files.

## Author

**Alice Smith**  
Email: alice.smith@example.com

Content of main.py:

python
"""
Project: heart-disease-analysis
Author: Alice Smith
Description: Analysis of heart disease dataset.
"""

def main():
    print("Hello, world!")

if __name__ == "__main__":
    main()

Next Steps

  • Expand Your Template: Add more files, such as configuration files, test directories, or data processing scripts.
  • Use More Variables: Introduce additional variables in cookiecutter.json to further customize your projects.
  • Share Your Template: Consider sharing your template with others by hosting it on a platform like GitHub.

By creating and customizing your own Cookiecutter templates, you empower yourself and your team to streamline project setup and focus on the important parts of your data science work.

5.1. Conditional Logic with Jinja2

Cookiecutter templates support advanced features through the Jinja2 templating engine, allowing you to include conditional logic and loops.

Adding Dynamic Content Using If Statements

How It Works

  • Jinja2 Syntax: Use {% if condition %} and {% endif %} to include or exclude content based on conditions.

  • Variables and Comparisons: You can compare variables defined in cookiecutter.json or derived from user input.

Example: Selecting a Team from Predefined Options

Suppose you want the template to adjust content based on the team selected by the user.

Step-by-Step Guide

  1. Define Variables with Options in cookiecutter.json:

    json
    {
        "project_name": "My Project",
        "author_name": "Your Name",
        "author_email": "your.email@example.com",
        "team": ["Data Team", "AI Team", "Research Team"]
    }
    
  2. Modify the Template Files Using Conditional Logic:

    In README.md, add:

    markdown
    # {{cookiecutter.project_name}}
    
    **Author**: {{cookiecutter.author_name}}  
    **Email**: <{{cookiecutter.author_email}}>
    
    ## Team Members
    
    {% if cookiecutter.team == 'Data Team' %}
    - Data Team Member 1
    - Data Team Member 2
    {% elif cookiecutter.team == 'AI Team' %}
    - AI Team Member A
    - AI Team Member B
    {% elif cookiecutter.team == 'Research Team' %}
    - Researcher X
    - Researcher Y
    {% endif %}
    
    ## Overview
    
    This project is about...
    

Using the Template

During template generation:

bash
$ cookiecutter path/to/data_science_template
project_name [My Project]: Sales Forecast
author_name [Your Name]: Bob Johnson
author_email [your.email@example.com]: bob.johnson@example.com
team:
1 - Data Team
2 - AI Team
3 - Research Team
Choose from 1, 2, 3 [1]: 2
  • Note: Cookiecutter automatically presents the options as a list.

The generated README.md will include the AI Team members:

markdown
# Sales Forecast

**Author**: Bob Johnson  
**Email**: <bob.johnson@example.com>

## Team Members

- AI Team Member A
- AI Team Member B

## Overview

This project is about...

Benefits of Using Conditional Logic

  • Dynamic Content: Tailor files and content based on user choices.

  • Flexibility: Create versatile templates suitable for various scenarios without duplicating code.

Build Your Own Cookiecutter Template

Objective: Create a Cookiecutter template that generates a basic data science project structure with the following:

  • Folder structure:
    • data/raw/
    • data/processed/
    • src/
    • notebooks/
  • Custom files:
    • README.md that includes the project name and description.
    • requirements.txt listing the project dependencies.

Instructions:

  1. Set Up the Template Directory

    • Create a new directory for your template called basic_data_science_template.
  2. Create the cookiecutter.json File

    • Inside basic_data_science_template, create a file named cookiecutter.json.
    • This file will define the variables that will be replaced in your template.
  3. Define Template Variables

    • Open cookiecutter.json and add content to define variables for:
      • Project name
      • Author name
      • Project description
  4. Create the Project Folder Structure

    • Inside basic_data_science_template, create a directory named {{cookiecutter.project_name}}.
    • Within {{cookiecutter.project_name}}, create the required folders:
      • data/raw/
      • data/processed/
      • src/
      • notebooks/
  5. Add a Custom README.md File

    • Inside {{cookiecutter.project_name}}, create a README.md file.
    • Use the variables from cookiecutter.json to include the project name, author, and description.
  6. Add a requirements.txt File

    • Inside {{cookiecutter.project_name}}, create a requirements.txt file.
    • Include some common data science libraries like pandas, numpy, and matplotlib.
  7. Test Your Template

    • Use Cookiecutter to generate a new project from your template.
    • Verify that the generated project has the correct structure and the files contain the appropriate content.

1. Set Up the Template Directory

First, we'll create a new directory for our template.

  • Command:

    bash
    mkdir basic_data_science_template
    

This directory will contain all the files and folders that define our template.


2. Create the cookiecutter.json File

Navigate into your template directory and create the cookiecutter.json file.

  • Commands:

    bash
    cd basic_data_science_template
    touch cookiecutter.json
    

3. Define Template Variables

Open cookiecutter.json in your favorite text editor (like Notepad, VSCode, or any text editor you prefer) and add the following content:

json
{
  "project_name": "my_data_science_project",
  "author_name": "Your Name",
  "description": "A short description of the project"
}
  • Explanation:
    • The keys ("project_name", "author_name", "description") are the variables that Cookiecutter will prompt you to provide values for.
    • The values ("my_data_science_project", "Your Name", etc.) are the default values that will be used if you just press Enter during the prompts.

4. Create the Project Folder Structure

Now, we'll create the directory structure for our project.

a. Create the Project Root Directory

  • Command:

    bash
    mkdir "{{cookiecutter.project_name}}"
    
  • Note: The double curly braces {{ }} are used by Cookiecutter to indicate variables. Here, we're creating a directory named after the project_name you input.

b. Navigate into the Project Directory

  • Command:

    bash
    cd "{{cookiecutter.project_name}}"
    

c. Create the Subdirectories

  • Commands:

    bash
    mkdir -p data/raw
    mkdir -p data/processed
    mkdir src
    mkdir notebooks
    
  • Explanation:

    • mkdir -p creates a directory and any necessary parent directories.
    • We've created the following structure:
      • data/raw/
      • data/processed/
      • src/
      • notebooks/

5. Add a Custom README.md File

Create a README.md file inside {{cookiecutter.project_name}}.

  • Command:

    bash
    touch README.md
    

Open README.md with your text editor and add the following content:

markdown
# {{cookiecutter.project_name}}

**Author**: {{cookiecutter.author_name}}

## Description

{{cookiecutter.description}}

## Project Structure

{{cookiecutter.project_name}}/ ├── data/ │ ├── raw/ │ └── processed/ ├── notebooks/ ├── src/ ├── README.md └── requirements.txt


  • Explanation:
    • We've used the variables {{cookiecutter.project_name}}, {{cookiecutter.author_name}}, and {{cookiecutter.description}} to personalize the README for each new project.

6. Add a requirements.txt File

Create a requirements.txt file inside {{cookiecutter.project_name}}.

  • Command:

    bash
    touch requirements.txt
    

Open requirements.txt and add the following lines:

txt
pandas
numpy
matplotlib
scikit-learn
  • Explanation:
    • These are common Python libraries used in data science projects.
    • You can customize this list based on your preferences or project needs.

7. Test Your Template

Now, let's see our template in action!

a. Navigate Back to the Parent Directory

  • Command:

    bash
    cd ../../
    
  • This brings you back to the directory containing basic_data_science_template.

b. Use Cookiecutter to Generate a New Project

  • Command:

    bash
    cookiecutter basic_data_science_template
    
  • Explanation:

    • When you run this command, Cookiecutter will look for the cookiecutter.json file in basic_data_science_template and prompt you for each variable.

c. Fill in the Prompts

You'll see prompts like this:

project_name [my_data_science_project]:
author_name [Your Name]:
description [A short description of the project]:
  • Example Input:

    • For project_name, you might enter: customer_segmentation
    • For author_name, enter your name: Jane Doe
    • For description, maybe: Analyzing customer data to identify segments.
  • Tip: If you just press Enter, the default value in the brackets will be used.

d. Check the Generated Project

After completing the prompts, Cookiecutter will generate a new directory named after your project_name.

  • Command:

    bash
    ls
    
  • Expected Output:

    basic_data_science_template/  customer_segmentation/
    

Your new project directory customer_segmentation should have the following structure:

customer_segmentation/
├── data/
│   ├── raw/
│   └── processed/
├── notebooks/
├── src/
├── README.md
└── requirements.txt