Eploration des données
import pandas
Traitement commande
Lire le contenu du fichier "[Link]" dataframe = pandas.read_csv('COVID19_Dataset.csv')
Attribuer à chaque colonne le nom de l’attribut correspondant Columns = ['c1', 'c2', … 'cn']
[Link]=Columns
Lire un fichier text qui contient des titres de colonnes dataframe = pandas.read_table("[Link]",sep="\t",header=0,index_col=0)
Afficher la structure de la base print([Link])
Afficher les 10 premières lignes de la base print([Link](10))
Afficher seulement les valeurs d'un attribut print(dataframe['nom_attribut'])
Obtenir des statistiques sur les individus dans la base print([Link]() )
Créer une matrice qui ne contient que les données des attributs array = [Link]
X = array[:,0:8]
print(X)
Préparation des données
1 – Nettoyage (après lecture de la base )
Traitement commande
Filtrer les valeurs de l’attribut 'att' pour déterminer les valeurs non nulles. tmp=dataframe['att']!=0
Calculer la médiane de ces valeurs en utilisant la fonction" median ()" median_bmi = dataframe[tmp].median()
Remplacer les valeurs nulles de l’attribut " par la médiane. dataframe['att'] = dataframe['att'].replace(0,median_bmi['att'])
2 – Normalisation = Mise à l'échelle (Rescaling) (après lecture de la base )
from sklearn import preprocessing
from [Link] import MinMaxScaler
Traitement commande
créer un normalisateur approprié "scaler". scaler = MinMaxScaler(feature_range=(0, 1))
pour ramener les valeurs des attributs dans un intervalle [0-1]. rescaledX = scaler.fit_transform(dataframe)
1
2 – Standardisation = transformer les attributs avec 0,1 avec des lois gaussiennes
from sklearn import preprocessing
from [Link] import StandardScaler
Traitement Commande
pour créer un normalisateur approprié "scaler". scaler = StandardScaler().fit(dataframe)
pour standardiser les données. rescaledX = [Link](dataframe)
catégorisation des individus par l’algorithme k-moyenne.
import pandas
import imageio
from [Link] import StandardScaler
from matplotlib import pyplot as plt
from [Link] import MinMaxScaler
from [Link] import KMeans
Traitement Commande
Construire le nouvel ensemble de données (100 individus et 2 attributs). array = [Link]
data = array[:100,1:3]
Effectuer la normalisation des donnés afin que valeurs des deux attributs scaler = MinMaxScaler(feature_range=(0, 1))
soient dans un intervalle [0-1]. data = scaler.fit_transform(data)
[Link](data)
Afficher dans un graphe les individus tel que le premier attribut représente [Link](data[:,0], data[:,1], c='r')
les abscisses et le deuxième attribut représente les ordonnés. [Link]()
Effectuer la catégorisation par la méthode des k-moyennes puis kmeans = KMeans(n_clusters=2)
afficher le résultat de la catégorisation pour des valeurs de k =2, 3 et 4. [Link](data)
y_km = kmeans.fit_predict(data)
#Afficher les poitns aprés la la catégorisation pour 2 classes
[Link](data[y_km ==0,0], data[y_km == 0,1], s=20, c='r')
[Link](data[y_km ==1,0], data[y_km == 1,1], s=20, c='m')
2
catégorisation des individus par CAH
import pandas
from matplotlib import pyplot as plt
from [Link] import dendrogram, linkage
from [Link] import AgglomerativeClustering
from [Link] import MinMaxScaler
Traitement Commande
#lecture du fichier fromage = pandas.read_table("[Link]",sep="\t",header=0,index_col=0)
# affichage des dimension des données print(fromage
#affichage des nom des variables print([Link]).shape)
# l'intervalle de variation de chacune des variables, d'afficher les statistiques print([Link]())
#Réccupérer les valeurs des variables pour toutes les observations X = [Link]
#Changement de l'échelle ==> les varaibles n'ont pas le même intervalle varia scaler = MinMaxScaler(feature_range=(0, 1))
X_normalise = scaler.fit_transform(X)
#----------- creation et affichage du dendrogramme Z = linkage(X_normalise,method='single',metric='euclidean')
#tester différent types d'indices d'aggrégation ==> [Link]("CAH222")
#changer 'ward' par 'single' , 'complete' , 'average' dendrogram(Z,labels=[Link],orientation='left')
[Link]()
Z = linkage(X_normalise,method='ward',metric='euclidean')
[Link]("CAH")
dendrogram(Z,labels=[Link],orientation='left')
[Link]()
#------- creation des classes par la CH en utilisant les deux premiers attributs new_data = X_normalise[:,1:3]
#appliquer la CHA
k=3 # faire varier le k entre 2 et 5 y_hc = AgglomerativeClustering(n_clusters=3, affinity = 'euclidean', linkage =
##tester différent types d'indices d'aggrégation 'ward').fit_predict(new_data)
# affichage du résultat [Link](new_data[y_hc ==0,0], new_data[y_hc == 0,1], s=20, c='r')
[Link](new_data[y_hc ==1,0], new_data[y_hc == 1,1], s=20, c='m')
[Link](new_data[y_hc ==2,0], new_data[y_hc == 2,1], s=20, c='y')
[Link](new_data[y_hc ==3,0], new_data[y_hc == 3,1], s=20, c='b')
#[Link](new_data[y_hc ==4,0], new_data[y_hc == 4,1], s=20, c='g')
[Link]()
3
ACP
import [Link] as plt
from sklearn import decomposition
from sklearn import datasets
from [Link] import StandardScaler
from mpl_toolkits.mplot3d import axes3d
import [Link] as plt
Traitement Commande
Effectuer l’analyse en composantes principales (ACP). pca = [Link]()
Projeter les données sur les nouveaux axes. [Link](X_CR) #déterminer les nouveaux axes
ComposantesPrincipales = [Link](X_CR)
Afficher les inerties expliquées. En déduire le nombre approprié de print('1')
composantes principales qu’on doit considérer print(pca.explained_variance_ratio_)
fig = [Link]()
[Link](pca.explained_variance_ratio_,'+')
[Link]()
Afficher les données en considérant 3 composantes principales, puis y = [Link] # réccupérer les classes des observations==> utiles seulement pour l'affichage
2 composantes principales. fig = [Link]()
ax = fig.add_subplot(111, projection='3d')
[Link](ComposantesPrincipales[:, 0], ComposantesPrincipales[:, 1],
ComposantesPrincipales[:, 2], c=y)
ax.set_xlabel('1ère CP') #1ère composante principale
ax.set_ylabel('2ème CP') #2ème composante principale
ax.set_zlabel('3ème CP') #3ème composante principale
[Link]()
affichage des données aprés projection sur les DEUX premiers axes fig = [Link]()
principaux ax = fig.add_subplot(111)
[Link](ComposantesPrincipales[:, 0], ComposantesPrincipales[:, 1], c=y)
ax.set_xlabel('1ère CP') #1ère composante principale
ax.set_ylabel('2ème CP') #2ème composante principale
[Link]()
4
Fonctions catégorisation et affichage
Fonctoin Appel
Générer des données nbre_points = 1000 #Nombre d'observations
X1, y1 = datasets.make_blobs(n_samples=nbre_points, random_state=6)
X2, y2 = datasets.make_circles(n_samples=nbre_points, factor=.5, noise=.05)
#fonction pour l'affichage d'un graphique representant les classes affichage_Classes(X1,'b',"1er jeu de données")
def affichage_Classes(Data,LesLabels,Titre):
fig = [Link]() affichage_Classes(X1,Res_DBSCAN,"DBSCAN")
ax = fig.add_subplot(111)
[Link](Data[:,0], Data[:,1], c=LesLabels) affichage_Classes(X1,Res_km,"kmeans")
[Link](Titre)
[Link]()
#fonction pour la catégorisation avec le DBSCAN Res_DBSCAN=Clustering_DBSCAN(X1)
def Clustering_DBSCAN(Data):
dbscan = [Link](eps=.15,min_samples=4) Eps=0.15 minpoints = 4
Res_DBSCAN=[Link](Data);
return Res_DBSCAN.labels_
#fonction pour la catégorisation avec le k-means Res_km=Clustering_kmeans(X1)
def Clustering_kmeans(Data):
kmeans = KMeans(n_clusters=2)
[Link](Data)
y_km = kmeans.fit_predict(Data)
return y_km
5
Regression
import pandas as pd
import [Link] as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
Traitement Commandes
afficher les observations sur un plan 2D avec x=MinTemp et y=MaxTemp dataset = pd.read_csv('./[Link]')
[Link](x='MinTemp', y='MaxTemp', style='o')
[Link]('MinTemp vs MaxTemp')
[Link]('MinTemp')
[Link]('MaxTemp')
[Link]()
Construction du nouvel ensemble de données,composé seulement des deux X = dataset['MinTemp'].[Link](-1,1)
variables "MinTemp" et "MaxTemp". y = dataset['MaxTemp'].[Link](-1,1)
la fonction reshape(-1,1) permet de créer une matrice 2D avec plusieurs lignes
et une seule colonne
Division des données en un ensemble d'apprentissage (80%) et un ensemble X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
de test(20%)
Effectuer la régression linéaire en utilisant l'ensemble d'apprentissage regressor = LinearRegression()
[Link](X_train, y_train)
Affichage des paramètres du modèle print('Pente a: ', regressor.intercept_) # la pente a
print('Ordonnée à l''origine b :',regressor.coef_) # l'ordonnée à l'origine b
Affichage du coefficient de détermination R_2 r_sq = [Link](X_train, y_train)
print('coefficient of determination:', r_sq)
Prédire les températures maximales en utilisant les températures minimales y_pred = [Link](X_test)
de l'ensemble de test
Affichage du résultat [Link](X_test, y_test, color='gray') #Valeurs réelles observées
[Link](X_test, y_pred, color='blue') #Valeurs réelles observées
[Link](X_test, y_pred, color='red', linewidth=2) #Valeurs prédites
[Link]()
6
K-plus proches voisins
from [Link] import load_iris
from sklearn.model_selection import train_test_split
from [Link] import KNeighborsClassifier
from sklearn.model_selection import learning_curve, GridSearchCV
from [Link] import StandardScaler
Charger les données.
Créer une matrice qui ne contient que les valeurs des variables (séparer X= load_iris().data
les valeurs des attributs de leurs classes d’appartenances).
Créer un vecteur qui ne contient que les étiquettes des classes. y= load_iris().target
Afficher les noms des variables et en déduire leur nombre. print("[Link] variables : ", load_iris().feature_names)
Afficher les classes. En déduire le type de classification print("[Link] classes : ",load_iris().target_names)
4- Normaliser les valeurs des variables pour qu’elles suivent une loi scaler = StandardScaler().fit(X)
normale de moyenne 0 et de variance 1. rescaledX = [Link](X)
5- Ecrire une fonction qui permet de faire la classification avec def K_NN(X_train, X_test, y_train, y_test ,k):
l’algorithme des k-plus proches voisins et afficher le taux d’erreur knn = KNeighborsClassifier(n_neighbors=k)
obtenu sur l’ensemble de test. Res_KNN=[Link](X_train, y_train)
#Pas d'apprentissage d'un modèle pour le KNN ==> #Prédiction sur les données de test
#la fonction fit ne fait pas de l'apprentissage mais elle sert [Link](X_test)
seulement à la structuration des données) taux_erreur_test=(1-Res_KNN.score(X_test,y_test))
print('[Link] d\'erreur sur l\'ensemble de test',taux_erreur_test)
6- Diviser l’ensemble de données en un ensemble d'apprentissage qui X_train, X_test, y_train, y_test = train_test_split(rescaledX, y,
contient 60% des observations et un ensemble de test (40%). test_size=0.4)
7- Effectuer la classification des données en considérant k=2 K_NN(X_train, X_test, y_train, y_test ,2)
8- Utiliser la validation croisée pour déterminer la valeur optimale de k param=[{"n_neighbors":list(range(1,15))}]
puis refaire la classification en utilisant cette valeur. knn= GridSearchCV(KNeighborsClassifier(),param,cv=5)
Res_KNN=[Link](X_train, y_train)
best_k=Res_KNN.best_params_["n_neighbors"]
print("[Link] valeur de k : ",best_k)
#---Classification par KNN en utilisant la meilleure valeur de k K_NN(X_train, X_test, y_train, y_test ,best_k)