import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer, make_column_selector
data = pd.read_csv("sample_dataset.csv", sep =";") # Importer le jeu de données
numerical = data.select_dtypes(exclude = "object").columns # Identifier les noms des variables quantitatives
categorical = data.select_dtypes(include = "object").columns # Identifier les noms des variables qualitatives
'''
La fonction ci-dessous permet de traiter des variables qualitatives et quantitatives en même temps.
Il suffit de spécifier des 3-uplets définis par :
- un nom,
- une méthode d'imputation,
- et les noms des variables concernées par cette imputation.
'''
cleaner = ColumnTransformer([
('numerical_transformer', SimpleImputer(strategy='mean'), numerical),
('categorical_transformer', SimpleImputer(strategy='most_frequent'), categorical)])
new_data = cleaner.fit_transform(data)
# Une autre manière de faire :
cleaner = ColumnTransformer([
('numerical_transformer', SimpleImputer(strategy='mean'), make_column_selector(dtype_exclude="object")),
('categorical_transformer', SimpleImputer(strategy='most_frequent'), make_column_selector(dtype_include="object"))
] , remainder='passthrough')
new_data = cleaner.fit_transform(data)
import numpy as np
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, OrdinalEncoder
# One-hot encoding : codage de variables nominales
X = np.array([["A"],["A"],["B"],["C"]]) # exemple d'un vecteur X = (A,A,B,C)
enc = OneHotEncoder(sparse=False) # définition de l'encodeur que nous souhaitons utiliser
X_enc = enc.fit_transform(X) # encodage du vecteur X
# Ordinal encoding : codage de variables ordinale
X1 = [["High"],["Low"],["Low"],["Medium"]] # un deuxieme exemple d'une variable ordinale
enc1 = OrdinalEncoder(categories=[["Low","Medium","High"]]) # il faut préciser l'ordre d'importance à la fonction
X1_enc = enc1.fit_transform(X1)
# Label encoding : codage de la variable cible
y = ["A","B","B","C","D"] # et un troisième exemple ou nous avons 4 classes.
enc2 = LabelEncoder()
y_enc = enc2.fit_transform(y)
import pandas as pd
from sklearn.preprocessing import PowerTransformer, KBinsDiscretizer, Binarizer
import matplotlib.pyplot as plt
''' ------Power transform-------'''
data = pd.read_csv("sample_dataset.csv", sep = ";") # importer le jeu de données csv
data['mean texture'].hist() # représenter le paramètre "mean texture" sous forme d'histogrammes
plt.show()
power = PowerTransformer('yeo-johnson',standardize=False) # définir le transformateur que vous voulez utiliser
trans_data = power.fit_transform(data) # transformer les données
plt.hist(trans_data[:,1]) # afficher le 1er paramètre des données transformées sous forme d'histogrammes
plt.show()
''' ------Binning-------'''
binner = KBinsDiscretizer(strategy = 'uniform', n_bins = 5, encode = 'onehot-dense') # binning en 5 catégories de largeur fixe.
bins_data = binner.fit_transform(data)
''' ------Binning-------'''
converter = Binarizer(threshold = 12) # dans ce cas, le seuil est égal à 12
binary_param = converter.fit_transform(data.iloc[:,-2:-1]) # convertir la dérnière colonne
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
data = pd.read_excel("sample_dataset.xlsx") # Importer le jeu de données sous format excel
'''Normalisation z-score'''
scaler = StandardScaler() # préciser quelle normalisation vous souhaitez utiliser
data_scaled = scaler.fit_transform(data) # données normalisées
'''Normalisation Min-Max'''
scaler1 = MinMaxScaler()
data_scaled = scaler1.fit_transform(data)
'''Normalisation robuste'''
scaler2 = RobustScaler()
data_scaled = scaler2.fit_transform(data)
import pandas as pd
from sklearn.feature_selection import SelectKBest, f_regression, mutual_info_regression, f_classif, mutual_info_classif, chi2
from scipy.stats import pearsonr
import numpy as np
from sklearn.preprocessing import OrdinalEncoder
df = pd.read_csv("sample_dataset.csv")
df = df.iloc[:,:11].dropna() # dropna() permet de supprimer toutes les lignes avec des valeurs manquantes
X = df.iloc[:,:-1] # paramètres d'entrée
y = df.iloc[:,-1] # paramètre de sortie
''' Variables quantitatives et cible quantitative '''
# Matrice de corrélation
r = np.zeros((df.shape[1],df.shape[1]))
for i in range(df.shape[1]):
for j in range(df.shape[1]):
r[i,j] = np.corrcoef(df.iloc[:,i], df.iloc[:,j])[0,1]
# Sélectionner les 5 paramètres les plus corrélés avec la sortie.
selector = SelectKBest(f_regression, k = 5)
selector.fit(X,y)
X_tr = selector.transform(X) # les variables les plus corrélés
noms_var = X.columns[selector.get_support()] # les noms des variables les plus corrélés
# Information mutuelle
selector = SelectKBest(mutual_info_regression, k = 5)
selector.fit(X,y)
X_s = selector.transform(X)
noms_var = X.columns[selector.get_support()]
I = selector.scores_
''' Variables qualitatives et cible quantitative '''
X = df.iloc[:,:3]
X = OrdinalEncoder().fit_transform(X).toarray()
selector = SelectKBest(lambda X,y : mutual_info_regression(X,y, discrete_features=True),k = 5)
X_tr = selector.fit_transform(X,y)
noms_var = X.columns[selector.get_support()]
''' Variables quantitatives et cible qualitative '''
# ANOVA
selector = SelectKBest(f_classif, k = 5)
selector.fit(X,y)
X_tr = selector.transform(X)
noms_var = X.columns[selector.get_support()]
p_values = selector.pvalues_ # p_values
#Information mutuelle
selector = SelectKBest(mutual_info_classif, k = 5)
selector.fit(X,y)
X_tr = selector.transform(X)
noms_var = X.columns[selector.get_support()]
''' Variables qualitatives et cible qualitative '''
X_tr = OrdinalEncoder().fit_transform(X)
y_tr = LabelEncoder().fit_transform(y)
selector = SelectKBest(chi2, k = 5)
X_tr = selector.fit_transform(X_tr,y_tr)
p_values = selector.pvalues_ # p_values