Mémo Python Data Science

L'Écosystème Data

Jupyter, Anaconda, Colab

📖 Comprendre l'environnement Data

Contexte : En Data Science, on n'écrit pas le code comme pour le Web ou le backend classique. L'approche est exploratoire : on charge des données, on les visualise, on teste des hypothèses, on itère. C'est un processus interactif et non linéaire.

Le Notebook Jupyter : C'est l'outil roi (fichier .ipynb). Il alterne cellules de code (exécutables indépendamment) et cellules de texte (Markdown pour la documentation). On peut voir le résultat d'un graphique juste en dessous du code qui l'a généré. C'est idéal pour le prototypage, l'enseignement et le partage de travaux reproductibles.

Anaconda vs pip : La distribution Anaconda est recommandée car elle pré-installe toutes les librairies scientifiques complexes (Numpy, Pandas, Scikit-Learn) et gère les dépendances binaires (compilation C/C++/Fortran) automatiquement via conda. C'est un gain de temps énorme par rapport à pip seul, surtout sur Windows.

Concept clé : Environnements Virtuels. Chaque projet doit avoir son propre environnement isolé (conda create -n monprojet). Cela évite les conflits de versions entre projets et garantit la reproductibilité.

🪐

Jupyter Lab

L'IDE interactif standard. Parfait pour l'exploration et la visualisation.

🐍

Anaconda

Gestionnaire d'environnement robuste. Isole vos projets Data.

☁️

Google Colab

Jupyter hébergé dans le cloud avec accès GPU gratuit. Idéal pour partager.

Numpy : Le Socle

Tableaux multidimensionnels & Calcul matriciel

📖 Comprendre Numpy (Concepts Clés)

Le Problème : Les listes Python sont flexibles (on peut mélanger types et tailles), mais cette flexibilité a un coût : chaque élément est un objet Python complet, dispersé en mémoire. Pour des millions de calculs, c'est beaucoup trop lent.

La Solution Numpy : Numpy introduit les ndarray (N-dimensional arrays), des tableaux typés et homogènes. Tous les éléments ont le même type (int32, float64, etc.) et sont stockés dans un bloc mémoire contigu.

Contiguïté Mémoire : C'est le secret de la vitesse. Le CPU adore les données contiguës car il peut les charger par blocs dans le cache (principe de localité). Une boucle for Python est interprétée ; une opération Numpy est exécutée en C/Fortran optimisé.

Le Broadcasting : Permet d'appliquer des opérations entre tableaux de dimensions différentes sans boucle explicite. Numpy "étend" virtuellement le plus petit tableau pour correspondre au plus grand. C'est magique et ultra-performant.

Le Reshaping : Critique en Deep Learning. Une image 28x28 pixels devient un vecteur de 784 éléments pour un réseau de neurones (arr.reshape(-1)). Un batch de 100 images devient un tenseur de forme (100, 784).

Le Broadcasting évite les boucles `for` en propageant les dimensions plus petites sur les plus grandes.

💡 Contexte Réel : Dans une application d'IA, on reçoit souvent des milliers d'images. On les "stack" dans un seul tenseur Numpy pour les envoyer d'un coup au GPU. C'est l'essence du Batch Processing.

Indexing, Types & Performance

import numpy as np
from numpy.linalg import inv, det, eig

# 1. Optimisation Mémoire (Critical Big Data)
arr_opt = np.array([1, 2, 100], dtype='int8')

# 2. Slicing Avancé (Boolean Masking)
arr = np.arange(12).reshape(3, 4)
mask = (arr > 5) & (arr < 10)
filtered = arr[mask]

# 3. Nouvelle API Random (Recommendée 2025)
rng = np.random.default_rng(seed=42)
rand_vals = rng.standard_normal(10)

Algèbre Linéaire & Stats

A = np.array([[1, 2], [3, 4]])

# Algèbre Linéaire (Scikit-Learn internals)
determinant = det(A)       # -2.0
inverse = inv(A)           # [[-2, 1], [1.5, -0.5]]
vals, vecs = eig(A)        # Valeurs/Vecteurs propres

# Produit Matriciel (Dot Product)
dot = A @ A.T             # Multiplication par transposée

# Statistiques sur axes
avg_cols = A.mean(axis=0)  # [2, 3]
std_rows = A.std(axis=1)   # [0.5, 0.5]

Acquisition de Données

SQL, APIs, Fichiers, IoT, Web Scraping

📖 Comprendre l'Acquisition (Concepts Clés)

Définition : L'acquisition de données (Data Acquisition ou DAQ) va bien au-delà de la simple collecte. C'est un processus continu où les données sont constamment collectées, transformées, validées et valorisées pour l'analyse et la prise de décision.

Le Principe GIGO : "Garbage In, Garbage Out". De mauvaises données en entrée produisent de mauvais résultats. La qualité des données est fondamentale : inexactitudes, incohérences ou données obsolètes ruinent les modèles.

Sources Internes : Données des systèmes d'entreprise (ERP, CRM), logs applicatifs, bases de données transactionnelles. Souvent en silos, nécessitent désilottage.

Sources Externes : APIs REST (données en temps réel), Open Data, Web Scraping, capteurs IoT. Attention à la conformité (RGPD) et aux CGU.

Le Pipeline ETL/ELT : Extract (extraire des sources), Transform (nettoyer, normaliser, enrichir), Load (charger dans un Data Warehouse ou Data Lake). C'est l'étape cruciale de préparation qui peut représenter jusqu'à 90% du temps d'un projet.

Clés du Succès : Pertinence métier (collecter les bonnes données), Rigueur technique (les préparer correctement), Vigilance éthique/légale (RGPD, consentements, anonymisation).

💡 Contexte Réel : Dans un projet ML, la préparation des données (nettoyage, gestion des valeurs manquantes) peut représenter jusqu'à 90% du temps du Data Scientist. C'est l'étape ETL/ELT.

SQL & Bases de Données

from sqlalchemy import create_engine
import pandas as pd

# Connexion (URL: dialect://user:pass@host/db)
engine = create_engine("sqlite:///data.db")

# Lire une table ou requête SQL
df = pd.read_sql("SELECT * FROM users WHERE age > 18", engine)

# Écrire le DataFrame en table
df.to_sql("adults", engine, if_exists="replace")

APIs REST & Formats

import requests

# Consommer une API REST
res = requests.get("https://api.coincap.io/v2/assets")
data = res.json()['data']  # Liste de dicts

# Convertir JSON -> Pandas
df_crypto = pd.DataFrame(data)

# Formats de fichiers
df.to_csv("data.csv", index=False)     # Standard
df.to_parquet("data.parquet")          # Rapide & Compact (Pro)
df.to_excel("report.xlsx")             # Pour le business

Web Scraping (BeautifulSoup)

import requests
from bs4 import BeautifulSoup

# Récupérer le HTML d'une page
page = requests.get("https://example.com/products")
soup = BeautifulSoup(page.content, 'html.parser')

# Extraire des éléments (sélecteurs CSS)
titles = [h2.text for h2 in soup.select('.product-title')]
prices = [span.text for span in soup.select('.price')]

# Attention : Respecter robots.txt et CGU !
df = pd.DataFrame({'title': titles, 'price': prices})

Pandas : L'Analyse

DataFrames, Séries & Manipulation

📖 Comprendre Pandas (Concepts Clés)

La Structure de Base : Un DataFrame est essentiellement un tableau 2D avec des étiquettes (index pour les lignes, colonnes nommées). Chaque colonne est une Series (un array 1D avec un index). C'est l'équivalent Python d'une feuille Excel ou d'une table SQL.

Pourquoi Pandas ? Au-delà du simple chargement CSV, Pandas excelle dans la manipulation : filtrage conditionnel (df[df.age > 30]), agrégations (groupby), jointures SQL-style (merge), et gestion des Time Series (dates, resampling).

Le Data Cleaning : C'est souvent 80% du temps d'un projet ! Gestion des valeurs manquantes (fillna, dropna), correction de types (astype), suppression des doublons (drop_duplicates), normalisation des formats (dates, textes).

Le Concept de Chaînage (Method Chaining) : Pandas encourage un style fonctionnel où l'on enchaîne les opérations : df.dropna().query('x > 0').groupby('cat').mean(). C'est lisible, concis, et évite de créer des variables intermédiaires.

Attention à la Performance : Pour de très gros fichiers (> 1Go), Pandas peut être lent. Utilisez chunksize pour lire par morceaux, dtype pour optimiser la RAM, ou passez à des outils Big Data comme Polars ou Dask.

Big Data : Chunking & Performance

import pandas as pd

# 1. Lire des fichiers massifs (par morceaux)
reader = pd.read_csv("huge_data.csv", chunksize=10000)
for chunk in reader:
    process(chunk) # On ne charge pas tout en RAM

# 2. Filtrage haute performance (API C++)
high_sales = df.query("Ventes > 1000 and Region == 'Nord'")

# 3. Calculs complexes optimisés
df.eval("Marge = (Ventes - Cout) / Ventes", inplace=True)

# 4. Optimisation RAM (Categories)
df['Ville'] = df['Ville'].astype('category')

Time Series & Joins

# Manipulation de Dates
df['Date'] = pd.to_datetime(df['Date'])
df.set_index('Date', inplace=True)

# Resampling (Moyenne Mensuelle)
monthly = df.resample('M').mean()

# Merge Avancé (Proche du SQL)
full_data = pd.merge(
    commandes, clients, 
    on='client_id', 
    how='inner', 
    validate='m:1'  # Sécurité: many-to-one
)

# Pivot Table (Style Excel)
pivot = df.pivot_table(
    values='Total', index='Categ', columns='Mois', aggfunc='sum'
)

Visualisation de Données

Matplotlib & Seaborn

📖 Comprendre la Dataviz (Concepts Clés)

Pourquoi Visualiser ? Un tableau de 10 000 lignes est inexploitable à l'œil nu. Une visualisation révèle des patterns, des outliers, des corrélations. C'est l'outil de communication n°1 du Data Scientist, autant pour l'exploration que pour convaincre un décideur.

Matplotlib : La Fondation. C'est la librairie historique, très puissante mais parfois verbeuse. Elle offre deux API : l'API "state-based" (plt.plot(), simple mais limitée) et l'API Orientée Objet (fig, ax = plt.subplots(), recommandée pour du pro).

L'API OO Expliquée : fig est la "fenêtre" ou le "canvas". ax est un "axe", c'est-à-dire un graphique à l'intérieur de la figure. On peut avoir plusieurs ax (subplots). On appelle les méthodes sur ax (ax.plot(), ax.set_title()), pas directement sur plt.

Seaborn : La Surcouche Statistique. Seaborn est construit sur Matplotlib et offre des graphiques statistiques prêts à l'emploi (violin plots, pair plots, heatmaps de corrélation) avec une esthétique moderne par défaut. Idéal pour l'EDA (Exploratory Data Analysis).

Choisir le Bon Graphique : Distribution → Histogramme, Violin, Boxplot. Relation → Scatter, Ligne. Composition → Pie, Barres empilées. Comparaison → Barres. Évolution → Ligne avec le temps en abscisse.

Viz Professionnelle

import matplotlib.pyplot as plt
import seaborn as sns

# Style Global
sns.set_theme(style="darkgrid")

# Création Figure et Axes (2 graphiques)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Graph 1 : Distribution (Violin)
sns.violinplot(data=df, x="Class", y="Age", ax=ax1)
ax1.set_title("Distribution Age par Classe")

# Graph 2 : Relation (Scatter)
sns.scatterplot(data=df, x="Prix", y="Age", hue="Survie", ax=ax2)
ax2.set_title("Prix vs Age")

plt.tight_layout()
plt.show()

Scatter Plot Avancé

Heatmap Corrélation

Machine Learning

Scikit-Learn (Sklearn)

📖 Comprendre le Machine Learning (Concepts Fondamentaux)

Définition : Le Machine Learning (ML) est une branche de l'IA où les algorithmes apprennent des patterns à partir de données, sans être explicitement programmés. Contrairement à la programmation classique (règles → résultat), en ML on fournit des données et des résultats attendus, et l'algorithme déduit les règles.

Supervisé vs Non-Supervisé : En apprentissage supervisé, on a des labels (la "réponse" attendue) pour entraîner le modèle. En non-supervisé, on cherche des structures cachées dans les données sans labels (clustering, réduction de dimension).

Le Train/Test Split : On divise TOUJOURS les données en deux parties. Le modèle apprend sur le train set (80%) et est évalué sur le test set (20%) qu'il n'a jamais vu. C'est crucial pour mesurer la généralisation.

Overfitting vs Underfitting : Un modèle overfit quand il apprend "par cœur" le train set mais échoue sur le test (trop complexe). Un modèle underfit quand il est trop simple pour capturer les patterns. L'objectif est le juste milieu.

Preprocessing : Les modèles ne comprennent que les nombres. Il faut encoder le texte (OneHotEncoder), scaler les valeurs numériques (StandardScaler), et gérer les valeurs manquantes.

Workflow Industrialisé (Pipeline)

📖 Concepts Avancés (Overfitting, Métriques, GridSearch)

Cross-Validation : Pour un score plus robuste, on découpe les données en K parties (Folds). On entraîne K fois le modèle en utilisant à tour de rôle chaque fold comme test set. Le score final est la moyenne.

GridSearchCV : Teste automatiquement toutes les combinaisons d'hyperparamètres (ex: nombre d'arbres, profondeur max) pour trouver la meilleure configuration. Attention : computationnellement coûteux !

Pipelines : Encapsulent preprocessing + modèle dans un seul objet. Avantage : évite le "data leakage" (fuite d'information du test set) et simplifie le déploiement.

Métrique	Cas d'usage	Formule Intuitive
Accuracy	Classes équilibrées	(Vrai Pos + Vrai Neg) / Total
Recall (Rappel)	Détection fraude/maladie (Ne rien rater)	Vrai Pos / (Vrai Pos + Faux Neg)
Precision	Anti-Spam (Ne pas filtrer les bons emails)	Vrai Pos / (Vrai Pos + Faux Pos)
F1-Score	Compromis Précision/Rappel (Généraliste)	Moyenne harmonique

Validation Robuste (Cross-Validation)

from sklearn.model_selection import cross_val_score, KFold

# Preprocessing Pipeline (Déjà vu : Scaler + OneHot)
model_pipe = ... 

# Stratégie de découpage (5 Folds, mélange préalable)
cv = KFold(n_splits=5, shuffle=True, random_state=42)

# Évaluation sur 5 rounds
scores = cross_val_score(model_pipe, X, y, cv=cv, scoring='f1')

print(f"Score Moyen : {scores.mean():.3f} (+/- {scores.std()})")

Pipeline Complet : Nettoyage → Scaling → Modèle

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

# 1. Preprocessing Colonnes
numeric_transformer = Pipeline(steps=[('scaler', StandardScaler())])
categorical_transformer = Pipeline(steps=[('onehot', OneHotEncoder())])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, ['age', 'fare']),
        ('cat', categorical_transformer, ['embarked', 'sex'])
    ])

# 2. Pipeline Global
pipe = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier())
])

# 3. Grid Search (Optimisation)
param_grid = {
    'classifier__n_estimators': [50, 100],
    'classifier__max_depth': [None, 10, 20]
                print("Best score:", grid.best_score_)

Interprétabilité (SHAP) & XGBoost

import xgboost as xgb
import shap

# 1. XGBoost (Le standard des compétitions Kaggle)
model = xgb.XGBClassifier(n_estimators=100, learning_rate=0.05)
model.fit(X_train, y_train)

# 2. SHAP (Pourquoi le modèle a prédit ça ?)
explainer = shap.Explainer(model)
shap_values = explainer(X_test)
shap.summary_plot(shap_values, X_test)

Deep Learning

Réseaux de Neurones & Keras

📖 Comprendre le Deep Learning (Concepts Fondamentaux)

Définition : Le Deep Learning est une branche du Machine Learning utilisant des réseaux de neurones artificiels à plusieurs couches (d'où "deep"). Contrairement au ML classique où on conçoit manuellement les features, le DL apprend automatiquement des représentations de plus en plus abstraites.

Le Neurone Artificiel : C'est l'unité de base. Il reçoit des entrées (x₁, x₂, ...), les multiplie par des poids (w₁, w₂, ...), fait la somme, ajoute un biais, puis applique une fonction d'activation (non-linéarité). Formule : output = activation(Σ(wi * xi) + b)

Backpropagation : L'algorithme d'apprentissage. On calcule l'erreur (Loss) entre la prédiction et la vérité, puis on "propage" cette erreur en arrière dans le réseau pour ajuster les poids. C'est la descente de gradient appliquée couche par couche.

Pourquoi "Deep" ? Plus il y a de couches, plus le réseau peut apprendre des abstractions complexes. La 1ère couche détecte des bords, la 2ème des formes, la 3ème des objets, etc. C'est ce qui rend le DL si puissant pour les images, le texte et l'audio.

GPU / TPU : L'entraînement DL nécessite des millions de calculs matriciels. Les GPU (cartes graphiques) sont optimisés pour ce type de calcul parallèle. Sans GPU, l'entraînement peut prendre des jours au lieu d'heures.

Transfer Learning : Utiliser un modèle pré-entraîné (ex: ResNet, BERT) et ne ré-entraîner que la dernière couche. Gain de temps et de données colossal.

PyTorch vs Keras : Keras est idéal pour le prototypage rapide. PyTorch est privilégié par la recherche pour sa flexibilité et son mode impératif.

Cheat Sheet Architecture DL

Type Problème	Dernière Couche (Activation)	Loss Function (Erreur)
Régression (Prix)	`Linear` (Pas d'activ)	`MSE` (Mean Squared Error)
Binaires (Oui/Non)	`Sigmoid` (Proba 0-1)	`Binary Crossentropy`
Multiclasse (Chien/Chat/Oiseau)	`Softmax` (Somme probas = 1)	`Categorical Crossentropy`

Classification Image (Keras)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Modèle Séquentiel
model = keras.Sequential([
    # Input: Image 28x28 (Flatten -> Vecteur 784)
    layers.Flatten(input_shape=(28, 28)),
    
    # Hidden Layer 1 (Dense = Fully Connected)
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.2),  # Evite overfitting
    
    # Output Layer (10 classes probabilités)
    layers.Dense(10, activation='softmax')
])

# Compilation
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Entrainement
model.fit(x_train, y_train, epochs=5)

Epoch : Un passage complet de toutes les données dans le réseau.

Loss : L'erreur que le réseau essaie de minimiser (ex: MSE pour régression).

Optimizer : L'algorithme qui met à jour les poids pour réduire la Loss (Adam est le standard).

Mise en Production

MLOps, Persistance, Streamlit

📖 Comprendre le MLOps (Concepts Fondamentaux)

Définition : Le MLOps (Machine Learning Operations) est l'ensemble des pratiques pour déployer et maintenir des modèles ML en production de manière fiable. C'est le DevOps appliqué au Machine Learning.

Le Problème : Un modèle qui reste dans un Notebook n'a aucune valeur business. 87% des projets ML ne dépassent jamais le stade du prototype. Le MLOps vise à réduire ce "gap" entre expérimentation et production.

Serialisation : Sauvegarder un modèle entraîné (avec ses poids) pour le réutiliser sans ré-entraînement. joblib.dump() pour Sklearn, model.save() pour Keras, torch.save() pour PyTorch.

API vs Batch : Deux modes de déploiement. En temps réel (API REST, FastAPI) pour des prédictions à la demande. En batch pour traiter de gros volumes périodiquement (ex: scoring nocturne).

Docker : Conteneurise votre environnement (Python, libs, modèle) pour garantir que le code fonctionne identiquement partout. Plus de "ça marche sur ma machine".

Sauvegarder un Modèle

import joblib

# 1. Sauvegarder (Serialisation)
joblib.dump(model, 'mon_modele.pkl')

# ... dans un autre script ...

# 2. Charger (Deserialisation)
loaded_model = joblib.load('mon_modele.pkl')

# 3. Prédiction
prediction = loaded_model.predict(new_data)

App Streamlit (app.py)

import streamlit as st
import pandas as pd

st.title("Démo IA Prix Immo")

# Widgets Interactifs
surface = st.slider("Surface (m2)", 10, 200, 50)
quartier = st.selectbox("Quartier", ["Centre", "Sud"])

if st.button("Estimer"):
    # Appel du modèle...
    prix = 250000  # fake
    st.success(f"Prix estimé : {prix} €")

FastAPI & Docker (Industrialisation)

# FastAPI (API Haute Performance)
from fastapi import FastAPI
app = FastAPI()

@app.post("/predict")
def predict(data: dict):
    return {"res": model.predict(data)}

# Dockerfile (Reproductibilité)
# FROM python:3.10-slim
# RUN pip install pandas scikit-learn fastapi
# COPY . /app
# CMD uvicorn main:app --host 0.0.0.0

NLP & Traitement du Texte

Tokenisation, Embeddings, spaCy

📖 Comprendre le NLP (Concepts Fondamentaux)

Définition : Le NLP (Natural Language Processing) permet aux machines de comprendre, interpréter et générer du langage humain. C'est le pont entre le texte brut et les algorithmes de Machine Learning.

Tokenisation : Première étape critique. Découper le texte en unités (mots, sous-mots, caractères). "J'aime Python" → ["J'", "aime", "Python"] ou avec BERT → ["J", "'", "aime", "Py", "##thon"].

Stop Words : Mots très fréquents sans valeur sémantique (le, la, de, et...). Souvent retirés pour réduire le bruit, mais attention avec les LLMs modernes qui en ont besoin.

Lemmatisation vs Stemming : Ramener les mots à leur forme canonique. "mangeait" → "manger" (lemme) ou "mang" (stem). La lemmatisation est plus précise mais plus lente.

Embeddings : Représenter les mots comme des vecteurs denses où la proximité reflète la similarité sémantique. "roi" - "homme" + "femme" ≈ "reine". Révolution depuis Word2Vec (2013) puis BERT (2018).

spaCy (NLP Industriel)

import spacy

# Charger le modèle français
nlp = spacy.load("fr_core_news_md")

doc = nlp("Paris est la capitale de la France.")

# Entités nommées (NER)
for ent in doc.ents:
    print(ent.text, ent.label_)
# Paris → LOC, France → LOC

# Lemmatisation
[token.lemma_ for token in doc]

Sklearn TF-IDF

from sklearn.feature_extraction.text import TfidfVectorizer

corpus = [
    "Le chat mange la souris",
    "Le chien court dans le jardin"
]

# Vectorisation TF-IDF
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)

# X est maintenant une matrice sparse
# Chaque ligne = un document vectorisé
print(vectorizer.get_feature_names_out())

💡 Conseil : Pour du NLP moderne, privilégiez spaCy (rapide, production-ready) ou Hugging Face Transformers (état de l'art, modèles pré-entraînés). NLTK est plus académique et vieillissant.

Generative AI & LLMs

OpenAI, LangChain, Prompt Engineering

📖 Comprendre l'IA Générative (Concepts Fondamentaux)

Définition : L'IA Générative crée du nouveau contenu (texte, image, code, audio) plutôt que de simplement classifier ou prédire. Les LLMs (Large Language Models) comme GPT-4, Claude ou Llama sont les stars de cette révolution.

Tokens : Les LLMs ne lisent pas des mots mais des "tokens" (sous-mots). "Bonjour" = 1-2 tokens. Important car le coût et les limites de contexte sont en tokens.

Prompt Engineering : L'art de formuler ses requêtes pour obtenir les meilleures réponses. Zero-shot, Few-shot, Chain-of-Thought... La qualité du prompt détermine 80% de la qualité du résultat.

RAG (Retrieval Augmented Generation) : Pattern clé en entreprise. On injecte dans le prompt des morceaux de documents pertinents récupérés d'une base vectorielle. Le LLM répond en se basant sur VOS données, pas juste son entraînement.

Fine-tuning vs RAG : Le fine-tuning ré-entraîne le modèle sur vos données (coûteux, figé). Le RAG est plus flexible : vos données sont à jour et le modèle reste généraliste.

Utilisation API (OpenAI)

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
  model="gpt-4o",
  messages=[
    {"role": "system", "content": "Tu es un expert Data."},
    {"role": "user", "content": "Analyse ce CSV..."}
  ]
)

print(response.choices[0].message.content)

Hugging Face & Local

from transformers import pipeline

# Sentiment Analysis en local
classifier = pipeline("sentiment-analysis")
res = classifier("J'adore Pandas !")

# Zero-shot Classification
zs = pipeline("zero-shot-classification")
zs("Débit de 50€", candidate_labels=["banque", "sport"])

Référence Rapide

Cheat Sheet des commandes vitales

📖 Comment utiliser cette référence

Cette section regroupe les commandes les plus utilisées en Data Science Python. Gardez-la sous la main pour vos projets !

Conseil : Utilisez Ctrl+F pour rechercher rapidement une commande.

📊 Pandas - Manipulation de Données

Commande	Description	Exemple
`pd.read_csv()`	Lire un fichier CSV	`df = pd.read_csv('data.csv')`
`df.head()`	Afficher les premières lignes	`df.head(10)`
`df.info()`	Résumé du DataFrame	`df.info()`
`df.describe()`	Statistiques descriptives	`df.describe()`
`df.groupby()`	Agrégation par groupe	`df.groupby('cat').mean()`
`df.merge()`	Jointure SQL-style	`pd.merge(df1, df2, on='id')`
`df.fillna()`	Remplir valeurs manquantes	`df.fillna(0)`
`df.drop_duplicates()`	Supprimer doublons	`df.drop_duplicates()`
`df.to_csv()`	Exporter en CSV	`df.to_csv('out.csv', index=False)`

🔢 Numpy - Calcul Numérique

Commande	Description	Exemple
`np.array()`	Créer un array	`np.array([1, 2, 3])`
`np.zeros() / ones()`	Tableaux remplis	`np.zeros((3, 3))`
`np.arange()`	Séquence	`np.arange(0, 10, 2)`
`np.linspace()`	N points équidistants	`np.linspace(0, 1, 100)`
`arr.reshape()`	Changer la forme	`arr.reshape(3, 4)`
`np.random.normal()`	Distribution normale	`np.random.normal(0, 1, 100)`
`arr @ arr2`	Produit matriciel	`A @ B`

🤖 Scikit-Learn - Machine Learning

Commande	Description	Exemple
`train_test_split()`	Séparer train/test	`X_train, X_test, y_train, y_test = train_test_split(X, y)`
`model.fit()`	Entraîner le modèle	`model.fit(X_train, y_train)`
`model.predict()`	Faire des prédictions	`y_pred = model.predict(X_test)`
`cross_val_score()`	Validation croisée	`cross_val_score(model, X, y, cv=5)`
`StandardScaler()`	Normaliser les données	`scaler.fit_transform(X)`
`Pipeline()`	Enchaîner les étapes	`Pipeline([('scaler', StandardScaler()), ('clf', SVC())])`

💾 Persistance & APIs

Commande	Description	Exemple
`joblib.dump()`	Sauvegarder un modèle	`joblib.dump(model, 'model.pkl')`
`joblib.load()`	Charger un modèle	`model = joblib.load('model.pkl')`
`pd.read_sql()`	Lire depuis SQL	`pd.read_sql(query, engine)`
`requests.get()`	Appel API GET	`requests.get(url).json()`

🧠 Deep Learning (Keras / PyTorch)

TensorFlow / Keras

import tensorflow as tf

# Modèle séquentiel
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(X_train, y_train, epochs=10)

PyTorch

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        return self.fc2(torch.relu(self.fc1(x)))

💡 Ressources : Pandas Docs • Sklearn Docs • Numpy Docs

Python Data Science

Pourquoi Python pour la Data ?

Sommaire

L'Écosystème Data

Jupyter Lab

Anaconda

Google Colab

Numpy : Le Socle

Acquisition de Données

Pandas : L'Analyse

Visualisation de Données

Machine Learning

Deep Learning

Cheat Sheet Architecture DL

Mise en Production

NLP & Traitement du Texte

Generative AI & LLMs

Référence Rapide

📊 Pandas - Manipulation de Données

🔢 Numpy - Calcul Numérique

🤖 Scikit-Learn - Machine Learning

💾 Persistance & APIs

🧠 Deep Learning (Keras / PyTorch)

Testez vos connaissances