In [ ]:
#version de Python
import sys
print(sys.version)

3.9.16 | packaged by conda-forge | (main, Feb  1 2023, 21:28:38) [MSC v.1929 64 bit (AMD64)]
In [ ]:
#version de scikit-learn
import sklearn
sklearn.__version__
Out[ ]:
'1.0.2'
In [ ]:
#changement de dossier
import os
os.chdir("C:/Users/ricco/Desktop/demo")

#chargement des données
import pandas
D = pandas.read_csv("wave500k_clustering.txt",sep="\t")
D.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 500000 entries, 0 to 499999
Data columns (total 21 columns):
 #   Column  Non-Null Count   Dtype  
---  ------  --------------   -----  
 0   V1      500000 non-null  float64
 1   V2      500000 non-null  float64
 2   V3      500000 non-null  float64
 3   V4      500000 non-null  float64
 4   V5      500000 non-null  float64
 5   V6      500000 non-null  float64
 6   V7      500000 non-null  float64
 7   V8      500000 non-null  float64
 8   V9      500000 non-null  float64
 9   V10     500000 non-null  float64
 10  V11     500000 non-null  float64
 11  V12     500000 non-null  float64
 12  V13     500000 non-null  float64
 13  V14     500000 non-null  float64
 14  V15     500000 non-null  float64
 15  V16     500000 non-null  float64
 16  V17     500000 non-null  float64
 17  V18     500000 non-null  float64
 18  V19     500000 non-null  float64
 19  V20     500000 non-null  float64
 20  V21     500000 non-null  float64
dtypes: float64(21)
memory usage: 80.1 MB
In [ ]:
#k-means
from sklearn.cluster import KMeans
km = KMeans(n_clusters=3,random_state=123,n_init=1)
km.fit(D)

#valeur de l'inertie
print(km.inertia_)

13280417.217539601
In [ ]:
#temps de calcul
%timeit km.fit(D)

363 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [ ]:
#en déploiement - affectation aux groupes
grp = km.predict(D)

#head
import numpy
numpy.unique(grp,return_counts=True)
Out[ ]:
(array([0, 1, 2]), array([180792, 180086, 139122], dtype=int64))
In [ ]:
#temps de traitement en déploiement
%timeit km.predict(D)

67.5 ms ± 2.82 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
In [ ]:
#scikit-learn "Intel Extension"
#liste des algorithmes gérés
import sklearnex
sklearnex.get_patch_names()
Out[ ]:
['pca',
 'kmeans',
 'dbscan',
 'distances',
 'linear',
 'ridge',
 'elasticnet',
 'lasso',
 'logistic',
 'log_reg',
 'random_forest_classifier',
 'random_forest_regressor',
 'train_test_split',
 'fin_check',
 'roc_auc_score',
 'tsne',
 'logisticregression',
 'randomrorestclassifier',
 'randomforestregressor',
 'svr',
 'svc',
 'nusvr',
 'nusvc',
 'knn_classifier',
 'knn_regressor',
 'nearest_neighbors',
 'kneighborsclassifier',
 'kneighborsregressor',
 'nearestneighbors',
 'set_config',
 'get_config',
 'config_context']
In [ ]:
#patcher les kmeans
from sklearnex import patch_sklearn
patch_sklearn("KMeans")

#mais on peut aussi patcher toutes les méthodes en vrac
#on fait appel à la commande en tout début de programme dans ce cas
#puis on travaille normalement avec scikit-learn !
#et en réalité, ce sont les méthodes de sklearnex qui sont appelées
#vous n'avez pas besoin de modifier le reste de votre code

Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
In [ ]:
#il faut réimporter la classe patchée !!!
from sklearn.cluster import KMeans

#puis relancer les KMeans
km_fast = KMeans(n_clusters=3,random_state=123,n_init=1)
km_fast.fit(D)

#intertie
print(km_fast.inertia_)

13280418.81748699
In [ ]:
#temps de calcul
%timeit km_fast.fit(D)

234 ms ± 9.57 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [ ]:
#en déploiement - affectation aux groupes
grp_fast = km_fast.predict(D)

#head
numpy.unique(grp_fast,return_counts=True)
Out[ ]:
(array([0, 1, 2]), array([180072, 180801, 139127], dtype=int64))
In [ ]:
#temps de traitement en déploiement
%timeit km_fast.predict(D)

22.6 ms ± 777 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
In [ ]:
#comparaison
pandas.crosstab(grp,grp_fast)
Out[ ]:
col_0 0 1 2
row_0
0 0 180792 0
1 180072 0 14
2 0 9 139113