Tutoriel : Python pour l’IA — premiers pas

Pourquoi Python pour l’IA ?

Python est le langage de programmation numéro un pour l’intelligence artificielle. Plus de 80% des projets IA dans le monde utilisent Python. Les raisons : une syntaxe simple et lisible (idéale pour les débutants), un écosystème de bibliothèques IA inégalé (TensorFlow, PyTorch, scikit-learn, Hugging Face), et une communauté massive qui partage des tutoriels et des modèles gratuits. Ce tutoriel vous guide de l’installation de Python à votre premier programme d’IA fonctionnel.

Installation de l’environnement

# Option 1 : Installer Python sur votre ordinateur

# Windows :
1. Téléchargez Python sur python.org/downloads
2. Lancez l'installateur
3. IMPORTANT : Cochez "Add Python to PATH" ☑
4. Cliquez "Install Now"
5. Vérifiez dans le terminal (cmd) :
   python --version
   # Python 3.12.x

# macOS :
brew install python

# Linux (Ubuntu/Debian) :
sudo apt update
sudo apt install python3 python3-pip python3-venv

# Option 2 : Google Colab (rien à installer)
# Ouvrez colab.research.google.com dans votre navigateur
# Python est déjà installé avec toutes les bibliothèques IA
# → Recommandé pour les débutants !

Les bases de Python en 15 minutes

# Variables et types de données
nom = "Aminata"          # Texte (string)
age = 25                 # Nombre entier (int)
salaire = 450000.0       # Nombre décimal (float)
est_developpeur = True   # Booléen (True/False)

print(f"Bonjour {nom}, tu as {age} ans et tu gagnes {salaire:,.0f} FCFA")
# Sortie : Bonjour Aminata, tu as 25 ans et tu gagnes 450,000 FCFA

# Listes (collections d'éléments)
langages = ["Python", "JavaScript", "HTML", "CSS"]
print(langages[0])       # Python (premier élément)
print(len(langages))     # 4 (nombre d'éléments)
langages.append("SQL")   # Ajouter un élément

# Dictionnaires (clé → valeur)
etudiant = {
    "nom": "Ousmane Diop",
    "age": 22,
    "ville": "Dakar",
    "compétences": ["Python", "Excel"]
}
print(etudiant["ville"])  # Dakar

# Conditions
if age >= 18:
    print("Majeur")
elif age >= 15:
    print("Adolescent")
else:
    print("Enfant")

# Boucles
for langage in langages:
    print(f"J'apprends {langage}")

# Fonctions
def calculer_salaire_net(brut, taux_impot=0.2):
    """Calcule le salaire net après impôt"""
    net = brut * (1 - taux_impot)
    return net

résultat = calculer_salaire_net(450000)
print(f"Salaire net : {résultat:,.0f} FCFA")  # 360,000 FCFA

Les bibliothèques essentielles pour l’IA

# Installer les bibliothèques
pip install numpy pandas matplotlib scikit-learn

# NumPy — Calcul numérique (la base de tout en IA)
import numpy as np

# Créer des tableaux de nombres
données = np.array([150000, 250000, 350000, 450000, 550000])
print(f"Salaire moyen : {np.mean(données):,.0f} FCFA")  # 350,000 FCFA
print(f"Salaire médian : {np.median(données):,.0f} FCFA") # 350,000 FCFA
print(f"Écart-type : {np.std(données):,.0f} FCFA")        # 141,421 FCFA

# Pandas — Manipulation de données (comme Excel mais en code)
import pandas as pd

# Créer un tableau de données
ventes = pd.DataFrame({
    "produit": ["iPhone 15", "Galaxy S24", "MacBook Air", "HP Pavilion", "AirPods"],
    "prix": [650000, 550000, 850000, 385000, 165000],
    "quantité": [12, 18, 5, 22, 35],
})

# Ajouter une colonne calculée
ventes["chiffre_affaires"] = ventes["prix"] * ventes["quantité"]

# Trier par chiffré d'affaires
ventes_triees = ventes.sort_values("chiffre_affaires", ascending=False)
print(ventes_triees)

# Statistiques rapides
print(f"
CA total : {ventes['chiffre_affaires'].sum():,.0f} FCFA")
print(f"Produit le plus vendu : {ventes.loc[ventes['quantité'].idxmax(), 'produit']}")

# Matplotlib — Visualisation de données
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
plt.bar(ventes["produit"], ventes["chiffre_affaires"] / 1000000)
plt.title("Chiffre d'affaires par produit (en millions FCFA)")
plt.ylabel("CA (millions FCFA)")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Premier projet IA : Prédire les ventes

# Prédire les ventes du mois prochain avec scikit-learn
from sklearn.linear_model import LinearRegression
import numpy as np

# Données historiques de ventes mensuelles (12 mois)
mois = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]).reshape(-1, 1)
ventes = np.array([
    2500000,   # Janvier
    2200000,   # Février (mois creux)
    2800000,   # Mars
    3100000,   # Avril
    3000000,   # Mai
    2700000,   # Juin
    3200000,   # Juillet
    3500000,   # Août (rentrée)
    3800000,   # Septembre
    3400000,   # Octobre
    3600000,   # Novembre
    4200000,   # Décembre (fêtes)
])

# Créer et entraîner le modèle
model = LinearRegression()
model.fit(mois, ventes)

# Prédire le mois 13 (janvier prochain)
prediction = model.predict([[13]])
print(f"Ventes prédites pour le mois 13 : {prediction[0]:,.0f} FCFA")

# Visualiser
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
plt.scatter(mois, ventes / 1000000, color='blue', s=100, label='Données réelles')
plt.plot(range(1, 15), model.predict(np.array(range(1, 15)).reshape(-1, 1)) / 1000000, 
         color='red', linestyle='--', label='Tendance')
plt.scatter([13], prediction / 1000000, color='green', s=200, marker='*', label='Prédiction')
plt.xlabel('Mois')
plt.ylabel('Ventes (millions FCFA)')
plt.title('Prédiction des ventes avec régression linéaire')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# Score de qualité du modèle
score = model.score(mois, ventes)
print(f"Score R² : {score:.2f}")  # Plus c'est proche de 1, mieux c'est
print(f"Pente : {model.coef_[0]:,.0f} FCFA/mois")  # Croissance mensuelle

Deuxième projet : Classifier des données

# Classifier des clients : vont-ils acheter ou non ?
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import pandas as pd
import numpy as np

# Données clients fictives (en réalité, vos données CRM)
np.random.seed(42)
n = 200

data = pd.DataFrame({
    "age": np.random.randint(18, 65, n),
    "nb_visites": np.random.randint(1, 20, n),
    "temps_site_min": np.random.uniform(0.5, 30, n).round(1),
    "panier_moyen_fcfa": np.random.randint(5000, 500000, n),
    "a_achete": np.random.choice([0, 1], n, p=[0.6, 0.4])  # 0=non, 1=oui
})

print("Aperçu des données :")
print(data.head())
print(f"
Taux d'achat : {data['a_achete'].mean():.1%}")

# Séparer features et target
X = data[["age", "nb_visites", "temps_site_min", "panier_moyen_fcfa"]]
y = data["a_achete"]

# Diviser en entraînement (80%) et test (20%)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entraîner un Random Forest
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# Évaluer
predictions = clf.predict(X_test)
print(f"
Précision : {accuracy_score(y_test, predictions):.1%}")
print(classification_report(y_test, predictions, target_names=["N'achète pas", "Achète"]))

# Prédire pour un nouveau client
nouveau_client = [[28, 5, 12.3, 150000]]  # age, visites, temps, panier
proba = clf.predict_proba(nouveau_client)[0]
print(f"
Nouveau client (28 ans, 5 visites, 12 min, panier 150K) :")
print(f"Probabilité d'achat : {proba[1]:.1%}")

Troisième projet : Appeler l’API OpenAI

# Intégrer ChatGPT dans votre programme Python
pip install openai

import openai
import os

# Configurer la clé API (utilisez une variable d'environnement)
client = openai.OpenAI(api_key="sk-votre-clé-api")

def poser_question(question):
    """Pose une question à ChatGPT et retourne la réponse"""
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # Modèle économique et rapide
        messages=[
            {"rôle": "system", "content": "Tu es un assistant utile qui répond en français."},
            {"rôle": "user", "content": question}
        ],
        temperature=0.7,
        max_tokens=500
    )
    return response.choices[0].message.content

# Tester
réponse = poser_question("Quelles sont les 3 meilleures bibliothèques Python pour l'IA ?")
print(réponse)

# Application pratique : analyser des avis clients
avis_clients = [
    "Excellent service, livraison rapide !",
    "Produit de mauvaise qualité, je suis déçu",
    "Correct, rien d'exceptionnel",
]

for avis in avis_clients:
    sentiment = poser_question(
        f"Analyse le sentiment de cet avis client et réponds par "
        f"POSITIF, NÉGATIF ou NEUTRE suivi d'un score de 1 à 10 : '{avis}'"
    )
    print(f"Avis : {avis}")
    print(f"Analyse : {sentiment}
")

Ressources pour continuer l’apprentissage

Cours gratuits en ligne. Le cours « Python for Everybody » de l’Université du Michigan sur Coursera est la meilleure introduction à Python (gratuit en mode audit). Pour l’IA spécifiquement, le cours « Machine Learning » d’Andrew Ng sur Coursera reste la référence mondiale (gratuit en mode audit également).

Pratique quotidienne. Kaggle.com propose des compétitions de data science avec des datasets réels et des notebooks partagés par la communauté. Commencez par les compétitions « Getting Started » qui incluent des tutoriels pas à pas. LeetCode et HackerRank proposent des exercices Python quotidiens pour progresser.

Communauté au Sénégal. Rejoignez les communautés tech sénégalaises : Dakar AI (meetup mensuel sur l’IA), GalsenDev (communauté des développeurs sénégalais), et les groupes Facebook/WhatsApp « Python Sénégal » et « Data Science Dakar » pour échanger avec d’autres apprenants et professionnels.

Pratique sur des projets personnels. La meilleure façon d’apprendre est de construire. Quelques idées de projets pour débutants : un bot WhatsApp qui répond aux FAQ de votre entreprise, un programme qui analyse vos dépenses mensuelles depuis un fichier CSV Wave, un outil qui génère automatiquement les légendes Instagram pour votre commerce.

Étape 1 : installer Python proprement sur votre poste

Avant tout exercice IA, installez Python 3.12 ou 3.13 depuis le site officiel python.org. Sous Windows, cochez impérativement la case « Add Python to PATH » pendant l’installation, sinon les commandes ne fonctionneront pas dans le terminal. Sous macOS, préférez Homebrew avec brew install python@3.13. Sous Ubuntu ou Debian, la commande sudo apt install python3.12 python3.12-venv suffit. Pour un développeur travaillant à Dakar avec une connexion intermittente, téléchargez aussi le package offline pour réinstaller en cas de besoin sans dépendre du réseau.

Vérifiez l’installation avec python --version dans un nouveau terminal. Vous devez voir s’afficher un numéro 3.12.x ou 3.13.x. Si la commande n’est pas reconnue, redémarrez le terminal ou ajoutez manuellement le dossier d’installation à votre variable PATH. Cette étape paraît triviale mais elle bloque encore beaucoup de débutants en pratique.

Étape 2 : créer un environnement virtuel isolé

Ne jamais installer de bibliothèques IA dans le Python global. Créez un environnement virtuel dédié à votre projet pour éviter les conflits de versions entre numpy, torch et tensorflow. Placez-vous dans votre dossier projet, puis lancez la commande adaptée à votre système.

python -m venv .venv
# Activation Windows
.venv\Scripts\activate
# Activation macOS / Linux
source .venv/bin/activate

Une fois activé, le prompt du terminal affiche le préfixe (.venv). Toutes les commandes pip suivantes installeront les paquets uniquement dans cet environnement, sans polluer votre système. Pour quitter, tapez deactivate. Cette discipline vous évitera des heures de debug plus tard.

Étape 3 : installer les bibliothèques fondamentales

Pour démarrer en IA, quatre bibliothèques couvrent 80 % des besoins : numpy pour le calcul vectoriel, pandas pour la manipulation de données tabulaires, scikit-learn pour les algorithmes classiques, et matplotlib pour la visualisation. Installez-les en une seule commande dans votre environnement virtuel actif.

pip install numpy pandas scikit-learn matplotlib jupyter

L’installation télécharge environ 200 Mo de paquets. Sur une connexion Orange Sénégal en heures de pointe, prévoyez cinq à dix minutes. Une fois terminée, vérifiez avec pip list que les versions sont récentes : numpy 2.x, pandas 2.x, scikit-learn 1.5+. Si vous obtenez des versions plus anciennes, mettez à jour pip avec python -m pip install --upgrade pip.

Étape 4 : lancer un notebook Jupyter pour expérimenter

Jupyter Notebook offre l’environnement idéal pour apprendre l’IA : code, résultats et explications dans un seul document. Lancez-le depuis votre dossier projet avec environnement actif.

jupyter notebook

Le navigateur s’ouvre automatiquement sur l’interface Jupyter à l’adresse localhost:8888. Cliquez sur « New » puis « Python 3 » pour créer votre premier notebook. Cette interface est devenue le standard mondial pour la data science et l’apprentissage IA. Sauvegardez régulièrement avec Ctrl+S, les notebooks sont stockés au format .ipynb directement dans votre dossier.

Étape 5 : manipuler votre premier dataset avec pandas

Pour pratiquer concrètement, partez d’un dataset réel. Téléchargez le fichier titanic.csv depuis Kaggle ou utilisez n’importe quel fichier CSV de votre activité (ventes mensuelles d’une boutique à Lomé, par exemple). Chargez-le et explorez sa structure.

import pandas as pd
df = pd.read_csv('titanic.csv')
print(df.shape)
print(df.head())
print(df.describe())

La sortie affiche le nombre de lignes et colonnes, les cinq premières lignes, et les statistiques descriptives (moyenne, médiane, écart-type) pour chaque colonne numérique. Cette exploration prend trente secondes et vous donne une vision claire des données avant tout entraînement de modèle.

Étape 6 : entraîner un premier modèle de classification

Construisons un modèle simple qui prédit une variable cible à partir d’autres colonnes. Avec scikit-learn, le pattern est toujours le même : préparer X (features) et y (cible), séparer en jeu d’entraînement et de test, instancier le modèle, fitter, prédire, évaluer.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

X = df[['Pclass', 'Age', 'Fare']].fillna(0)
y = df['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
preds = model.predict(X_test)
print(f"Précision : {accuracy_score(y_test, preds):.2%}")

Vous obtenez une précision typique entre 75 et 82 % sur ce dataset. C’est votre premier modèle IA fonctionnel. Le pattern est exactement le même pour des problèmes métier réels : prédire le churn client d’un opérateur télécom, classifier des tickets support, estimer le risque de défaut sur un crédit.

Étape 7 : visualiser les résultats avec matplotlib

La visualisation transforme des nombres en compréhension. Tracez l’importance des variables pour comprendre quelles colonnes pèsent dans la décision du modèle.

import matplotlib.pyplot as plt
importances = pd.Series(model.feature_importances_, index=X.columns)
importances.sort_values().plot(kind='barh')
plt.title("Importance des variables")
plt.tight_layout()
plt.show()

Le graphique affiche une barre horizontale par variable, triée par importance croissante. Vous identifiez immédiatement quelles colonnes sont décisives. Cette interprétabilité est cruciale pour défendre vos résultats devant un client à Abidjan ou un comité de direction qui exige des explications, pas seulement des chiffres.

Étape 8 : aller vers l’apprentissage profond avec PyTorch

Quand scikit-learn atteint ses limites (texte non structuré, images, séries temporelles complexes), passez à PyTorch. L’installation se fait également via pip, en choisissant la version adaptée à votre matériel sur le configurateur officiel pytorch.org.

pip install torch torchvision

Pour un poste sans carte graphique dédiée (cas typique d’un ordinateur portable de bureau), la version CPU suffit pour apprendre. Les modèles s’entraînent plus lentement mais tous les concepts s’appliquent. Pour passer en production sur des volumes réels, louez un GPU à l’heure chez un fournisseur cloud, c’est rentable dès qu’on dépasse quelques heures d’entraînement par mois.

Étape 9 : structurer un vrai projet et le partager

Un script unique dans un notebook ne suffit plus dès que le projet grandit. Créez une arborescence claire : dossier data/ pour les fichiers bruts, notebooks/ pour l’exploration, src/ pour les modules réutilisables, models/ pour les modèles entraînés sauvegardés en pickle ou joblib. Ajoutez un fichier requirements.txt généré par pip freeze > requirements.txt pour que vos collègues installent exactement les mêmes versions.

Sur un angle proche et industrialiser vos prompts d’IA, lisez notre guide pratique sur le prompt engineering avancé. Mettez votre code sous Git, poussez sur GitHub ou GitLab, et vous avez les fondations d’un projet IA professionnel reproductible partout dans le monde.