##Visualisation de données # Séparation des données (feature & target)
import seaborn as sns X = df[['Salary']]
#Analyse de données y = df['YearsExperience']
import pandas as pd # Division en un ensemble d'entrainement et un
from [Link] import MinMaxScaler ensemble de test
#Manipulation des matrices X_train, X_test,y_train,y_test=train_test_split(X,y,test_size
import numpy as np =0.3,random_state=42)
# une classe pour encoder des variables catégorielles #Afficher tout les element (infinite)
from [Link] import OneHotEncoder np.set_printoptions(threshold=[Link])
#Visualisation statique print(one_hot_encoded,type(one_hot_encoded))
import [Link] as plt # Création d'un DataFrame des colonnes encodées
# une classe pour encoder des variables catégorielles encoded_df=[Link](one_hot_encoded,columns=e
from [Link] import LabelEncoder ncoder.get_feature_names_out(['month']))
# Une classe pour transformer des colonnes # Fusionner les colonnes encodées avec le DataFrame
from [Link] import ColumnTransformer original sans la variable 'month'
# pour mettre à l’échelle vos caractéristiques numériques df_encoded = [Link]([[Link]('month', axis=1),
from [Link] import StandardScaler encoded_df], axis=1)
# Importer les metriques #tracer des histogrammes pour les colonnes numériques
from [Link] import accuracy_score, precision_score, for column in [Link][:-1]: # Exclure la colonne
recall_score ,f1_score, confusion_matrix, classification_report 'species'
from sklearn.model_selection import train_test_split [Link](figsize=(8, 4))
from [Link] import KNeighborsClassifier [Link](df[column], kde=True)
from [Link] import DecisionTreeClassifier [Link](f'Histogramme de {column}')
# Charger le dataset Titanic depuis seaborn [Link](column)
titanic = sns.load_dataset('titanic') [Link]('Fréquence')
#Charger le dataset dapre un fichier excel ou csv [Link]()
df=pd.read_csv("[Link]") #Calcule du Moyenne
# Afficher les 5 premières lignes df[colonne].mean()
print([Link]()) #Calcul median
# Afficher les 10 dernières lignes du DataFrame df[colonne].
print([Link](10)) #Calcul des Quartiles
##Afficher les entete des colonnes de dataset Q1 = df[colonne].quantile(0.25)
print([Link]) Q2 = df[colonne].median()
#afficher le type de chaque colonne Q3 = df[colonne].quantile(0.75)
print([Link]) #Calcul du varience
#verifier si le dataset contient des valeur null et compter les df[colonne].var()
[Link]().sum() #Calcul d’ecart type
# le nombre total de valeurs manquantes. Interprétez les résultats. df[colonne].std()
[Link]().sum().sum( # Calcul de l'Étendue Interquartile (IQR)
#pour supprimer les ligne qui contient les valeurs null Q3-Q1
df1 = [Link]() #Définition des limites inférieure et supérieure pour les
#pour supprimer les colonnes qui contient les valeurs null valeurs aberrantes
df=[Link](axis=1) lower_bound = Q1 - 1.5 * IQR
#pour afficher le nombre de ligne et de colonnes(dimension) upper_bound = Q1 + 1.5 * IQR
[Link] ## Filtrage des données pour ne conserver que les
#Afficher les types de colonnes années d'experience qui se trouvent entre les limites
print([Link]) inférieure et supérieure
# Afficher des informations générales data = df[(df['YearsExperience'] >= lower_bound) &
[Link]() (df['YearsExperience'] <= upper_bound)]
# Afficher une description statistique #Détection des valeurs aberrantes
[Link]() for column in [Link][:-1]: # Exclure la colonne
#supprimer une ligne ou bien colonne 'species'
df2 = [Link]('nom du ligne /colonne', axis=1/colonne 0/ligne) [Link](figsize=(8, 4))
#créer un dataframe une partie du dataset contenant les variables [Link](x=df[column])
age et fare [Link](f'Boxplot de {column}')
df3=titanic[['age','fare']] #si characteristique double [[ee]] [Link](column)
#remplacer les valeurs manquantes de la variable age par médiane # statistique data object type object "qualitatif"
median = df3['age'].median() [Link](include=['object'])
df3['age'].fillna(median, inplace=True) # Analyse de la Variable Cible
#importer et instancier MinMaxScaler et appliquer MinMaxScaler df['weather'].value_counts()
scaler = MinMaxScaler() # Supprimez la colonne date
scaler_fit=scaler.fit_transform(df3) del df["date"]
df3_scaled = [Link](scaler_fit) #Encodez la variable weather en valeurs numériques
# Instanciation du One-Hot Encoder le=LabelEncoder()
encoder = OneHotEncoder(sparse_output=False) df["weather_encode"]=le.fit_transform(df["weather"])
# Application du One-Hot Encoding sur la colonne 'month' #matrice de correlation
one_hot_encoded = encoder.fit_transform(df[['month']]) cor=[Link](['weather'],axis=1).corr()
# Affichage de one_hot_encoded et de son type [Link](cor,annot=True)
print(one_hot_encoded,type(one_hot_encoded))
#check for duplicate rows et sum pour voire la somme
# KNeighborsClassifier avec n_neighbors = 5
des ligne dups
KNN = KNeighborsClassifier(n_neighbors=5)
[Link]().sum()
#Les variables de testes pour les arbre random=true
#visualisation des points
X_train,X_test,y_train,y_test=train_test_split(x,y,test_size=0.3,random_s
[Link](X_train['Area'], y_train, s=1)#nuage de points#
tate=42)
['Area']si on a plusieur feature dans le X_train
#entrainer ainsi pour les arbres et regression lineare
[Link]('Price vs Area')
[Link](X_train, y_train)
[Link]('Area')
#calculer prediction y_pred
[Link]('Price')
y_pred = [Link](X_test)
#entrener le modele
#score
lr = LinearRegression()
[Link](X_test, y_test)
[Link](X_train, y_train)
# y_test converti en [Link] pour l'affichage
# Afficher les paramètres du modèle donner l'expression
print([Link](y_test))
du polynome h(x)
# Create a confusion matrix
print(lr.intercept_)#valeur du theta zero
import [Link] as plt
print(lr.coef_)#coef de l'equation de regression theta 1,2..
from [Link] import confusion_matrix
#pour tracer la droite on ajoute ses 2 ligne a la partie du
import seaborn as sns
visualisation apres [Link]
# Calcul de la matrice de confusion
y_pred = [Link](X_test)#predire les valeur en utilisant
conf_matrix = confusion_matrix(y_test, y_pred)
le vecteur
# Visualiser la matrice de confusion avec un heatmap
[Link](X_test['Area'], y_pred, color='red')#tracer la
[Link](figsize=(7, 5), dpi=100)
droite
[Link](conf_matrix, annot=True, fmt="d",xticklabels=['Rain',
#pour clalculer l’erreur
'Sun', 'Fog', 'Drizzle', 'Snow'],yticklabels=['Rain', 'Sun', 'Fog', 'Drizzle',
MAE = mean_absolute_error(y_test, y_pred)
'Snow'])
MSE = mean_squared_error(y_test, y_pred)
[Link]('Véritables catégories')#titre pour l’axe des y
RMSE=root_mean_squared_error(y_test, y_pred)#import
[Link]('Prédictions')#titre pour l’axe des x
root_mean_squared_error
[Link]('Matrice de Confusion pour les Prédictions Météo')#titre matrice
r2 = r2_score(y_test, y_pred)
[Link]()#affichage matrice
#Diviser la base de données en deux tableaux Xm
#Affihcer Précision, rappel et F1-score pour KNN
(tableau d'observations) et ym (la variable cible)
print(classification_report(y_test, y_pred))
Xm = [Link][:,0:12]#:pour toute les ligne 0:12 pour
########################################################
les colonnes iloc pour extraire les colonnes sans les
from sklearn.model_selection import GridSearchCV
nommees
param_grid = {'n_neighbors': range(1, 20), 'metric':['euclidean',
ym = boston['MEDV']#derniere colonnes du target
'manhattan', 'minkowski']}
#standardisation
# Application de GridSearchCV avec validation croisée
# Initialize StandardScaler
grid_KNN = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)
scaler = StandardScaler()#import bilbo
grid_KNN.fit(X_train, y_train)
Xm_train_sc=scaler.fit_transform(Xm_train)
print(grid_KNN.best_params_)
Xm_test_sc = [Link](Xm_test)
# calcul de la nouvelle y_pred
Tracer les valeurs réelles et les prédictions sur
Final_model = KNeighborsClassifier(metric ='manhattan', n_neighbors =
l'ensemble de test
11, weights = 'distance')
# Visualisation
# Performance du modèle optimal
[Link](X_test , y_test, color='blue', label='Valeurs
Final_model = grid_KNN.best_estimator
réelles')
# Meilleur k trouvé
[Link](X_test, y_pred, color='red', label='Ligne de
best_k = grid_KNN.best_params_['n_neighbors']
régression')
#hyperparametre du decisiontree c'est max_depth et l'indice de genie
[Link]('Years of Experience')
plusier indice dont dispo
[Link]('Salary')
model=DecisionTreeClassifier(criterion="gini",max_depth=5)
[Link]('Régression linéaire simple')
#imports des biblo pour visualiser l’arbre
[Link]()
from [Link] import plot_tree
[Link]()
import [Link] as plt
#Tracer l'arbre de décision pour le model: final_model
# Visualisation de l'arbre de décision
[Link](figsize=(12, 8))
[Link](figsize=(50,15), dpi = 200) # Augmenter la taille de la figure
plot_tree(final_model, filled=True,
plot_tree(model,filled=True,feature_names=X_train.columns,#
feature_names=X_train.columns, class_names=['0
feature_names c’est le nom des caractéristiques
(Bénin)', '1 (Malin)'], rounded=True)
class_names=["Classe 0", "Classe 1", "Classe 2", "Classe 3", "Classe
[Link]('Arbre de Décision')
4"], rounded=True,fontsize=14)
[Link]()
# font_sizeAugmenter la taille de la police
# class_name c’est le noms des classes
plt.tight_layout()
[Link]("tree_model.png", dpi = 200)
[Link]() #affichage
#import des metriques pour la regression lineare
from [Link] import mean_absolute_error,
mean_squared_error, r2_score,root_mean_squared_error
#pour le modele du regression lineare
from sklearn.linear_model import LinearRegression
