Aller au contenu

TP2: Mini Projet - Programmation Avancée sous Python

Projet programmation avancée sous Python Ce projet de programmation avancée sous Python aborde deux concepts clés : l'arbre de décision et la régression linéaire. Les étudiants apprendront à mettre en œuvre ces techniques à l'aide de bibliothèques Python telles que NumPy, Matplotlib et Scikit-learn.

D'après le document TP2: Mini Projet - Programmation Avancée sous Python

Cet article a été rédigé automatiquement à partir du document source, puis vérifié avant publication.

Document source

Projet programmation avancée sous Python

Ce projet de programmation avancée sous Python aborde deux concepts clés : l'arbre de décision et la régression linéaire. Les étudiants apprendront à mettre en œuvre ces techniques à l'aide de bibliothèques Python telles que NumPy, Matplotlib et Scikit-learn. Ce document fournit des exemples de code, des explications sur chaque étape, ainsi que des questions pour approfondir la compréhension des concepts.

Activité 1 : Arbre de décision

Dans cette première activité, nous allons créer un arbre de décision en utilisant la bibliothèque Scikit-learn. Un arbre de décision est un modèle prédictif qui utilise une structure arborescente pour prendre des décisions basées sur des données d'entrée.

Code de l'arbre de décision

import numpy
import matplotlib.pyplot as plot
from sklearn import tree
from sklearn.tree import DecisionTreeRegressor

# Construire un ensemble de données simple avec y = x + bruit aléatoire
nPoints = 100
xPlot = [(float(i)/float(nPoints) - 0.5) for i in range(nPoints + 1)]
x = [[s] for s in xPlot]
numpy.random.seed(1)
y = [s + numpy.random.normal(scale=0.1) for s in xPlot]

plot.plot(xPlot,y)
plot.xlabel('x')
plot.ylabel('y')
plot.show()

simpleTree = DecisionTreeRegressor(max_depth=1)
simpleTree.fit(x, y)

# Dessiner l'arbre
with open("simpleTree.dot", 'w') as f:
    f = tree.export_graphviz(simpleTree, out_file=f)

# Comparer la prédiction de l'arbre avec les vraies valeurs
yHat = simpleTree.predict(x)
plot.figure()
plot.plot(xPlot, y, label='True y')
plot.plot(xPlot, yHat, label='Tree Prediction ', linestyle='--')
plot.legend(bbox_to_anchor=(1,0.2))
plot.xlabel('x')
plot.ylabel('y')
plot.show()

Questions sur l'arbre de décision

  • Définir le rôle de : numpy, matplotlib, pyplot, sklearn.
  • À quoi servent les lignes de code : with open("simpleTree.dot", 'w') as f: et f = tree.export_graphviz(simpleTree, out_file=f) ?
  • Combien de fichiers output retourne cet exemple ?
  • Pouvez-vous proposer un autre fichier en output et lequel ?

Activité 2 : Régression linéaire

La régression linéaire est une méthode statistique utilisée pour modéliser la relation entre une variable dépendante et une ou plusieurs variables indépendantes. Dans cette activité, nous allons créer un modèle de régression linéaire en utilisant également Scikit-learn.

Code de la régression linéaire

from sklearn import linear_model
import matplotlib.pyplot as plt
import numpy as np
import random

# Étape 1 : données d'entraînement
X = [i for i in range(10)]
Y = [random.gauss(x,0.75) for x in X]
X = np.asarray(X)
Y = np.asarray(Y)
X = X[:,np.newaxis]
Y = Y[:,np.newaxis]

# Étape 2 : définir et entraîner un modèle
model = linear_model.LinearRegression()
model.fit(X, Y)

print(model.coef_)
print(model.intercept_)

# Étape 3 : prédiction
x_new_min = 0.0
x_new_max = 10.0
X_NEW = np.linspace(x_new_min, x_new_max, 100)
X_NEW = X_NEW[:,np.newaxis]
Y_NEW = model.predict(X_NEW)

plt.plot(X_NEW, Y_NEW, color='coral', linewidth=3)
plt.xlim(x_new_min,x_new_max)
plt.ylim(0,20)
plt.title("Régression linéaire simple utilisant scikit-learn et python 3",fontsize=10)
plt.xlabel('Abscisse')
plt.ylabel('Ordonnée')
plt.show()

Questions sur la régression linéaire

  • Quelles sont les différences entre le code avant et après avoir supprimé les commentaires ?

Points clés à retenir

Voici les points essentiels à retenir de ce projet :

  • Un arbre de décision est utilisé pour prédire des valeurs basées sur des données d'entrée.
  • La régression linéaire modélise la relation entre deux variables.
  • Les bibliothèques Python comme NumPy, Matplotlib et Scikit-learn sont essentielles pour l'analyse de données.

Questions fréquentes

Qu'est-ce qu'un arbre de décision ?

Un arbre de décision est un modèle prédictif qui utilise une structure arborescente pour prendre des décisions basées sur des données d'entrée. Il divise les données en sous-ensembles en fonction de critères spécifiques.

Comment fonctionne la régression linéaire ?

La régression linéaire modélise la relation entre une variable dépendante et une ou plusieurs variables indépendantes en ajustant une ligne droite qui minimise l'erreur entre les valeurs prédites et les valeurs réelles.

Quelle est la différence entre un arbre de décision et une régression linéaire ?

Un arbre de décision utilise une approche basée sur des règles pour faire des prédictions, tandis que la régression linéaire ajuste une ligne pour modéliser la relation entre les variables. Les arbres de décision peuvent gérer des données non linéaires, alors que la régression linéaire est limitée aux relations linéaires.

Partager

Commentaires

Aucun commentaire pour le moment. Posez la première question.

Les commentaires sont relus avant publication. Votre e-mail n'est jamais affiché.

← Toutes les révisions