Dans le royaume de apprentissage automatique en utilisant PythonScikit-Learn est un outil indispensable. En tant que première bibliothèque pour l'apprentissage automatique en Python, Scikit-Learn fournit une suite complète de algorithmes et des outils pour résoudre un large éventail de problèmes. De la classification et de la régression au clustering et à la réduction de la dimensionnalité, Scikit-Learn permet aux scientifiques des données de créer des outils robustes et efficaces modèles d'apprentissage automatiqueQue vous soyez un débutant faisant ses premiers pas dans le monde de l’apprentissage automatique ou un praticien chevronné cherchant à élargir votre boîte à outils, cet article constitue une introduction concise et informative à Scikit-Learn.

Qu'est-ce que Scikit-Learn ?

Présentation de Scikit-Learn

Scikit-Learn est une bibliothèque d'apprentissage automatique puissante et populaire en Python. Elle fournit une large gamme d'algorithmes et d'outils pour l'analyse des données et la formation des modèles. Avec son interface conviviale et efficace, Scikit-Learn est largement utilisé par les débutants et les data scientists expérimentés pour résoudre des problèmes d'apprentissage automatique complexes.

Caractéristiques principales

Scikit-Learn offre plusieurs fonctionnalités clés qui en font un outil essentiel pour l'apprentissage automatique en Python :

• Efficace et évolutif:Scikit-Learn est conçu pour être efficace en termes de calcul et peut gérer facilement de grands ensembles de données. Il exploite la puissance des bibliothèques numériques telles que NumPy et SciPy pour garantir une exécution efficace.
• Large gamme d'algorithmes:Scikit-Learn fournit une suite complète de algorithmes d'apprentissage automatique, incluant des méthodes d'apprentissage supervisées et non supervisées. Ces algorithmes vont des méthodes classiques telles que la régression linéaire et la régression logistique à des techniques plus avancées comme les forêts aléatoires et les machines à vecteurs de support.
• Prétraitement des données et ingénierie des fonctionnalités:Scikit-Learn propose une variété d'outils pour le prétraitement des données et l'ingénierie des fonctionnalités. Il fournit des fonctions pour gérer les données manquantes, mettre à l'échelle les fonctionnalités, encoder les variables catégorielles et diviser les données en ensembles d'apprentissage et de test.
• Sélection et évaluation des modèles:Scikit-Learn fournit des outils robustes pour la sélection et l'évaluation de modèles, notamment la validation croisée et la recherche de grille. Ces techniques permettent de trouver les meilleurs hyperparamètres pour un modèle donné et d'évaluer ses performances à l'aide de diverses mesures d'évaluation.
• Intégration avec d'autres bibliothèques:Scikit-Learn s'intègre parfaitement à d'autres bibliothèques Python populaires, telles que NumPy, Pandas et Matplotlib. Cela permet aux utilisateurs d'exploiter les riches fonctionnalités de ces bibliothèques en conjonction avec Scikit-Learn pour la manipulation des données, la visualisation et l'évaluation des modèles.

Algorithmes pris en charge

Scikit-Learn prend en charge une large gamme d'algorithmes d'apprentissage automatique pour les tâches d'apprentissage supervisées et non supervisées. Certains des algorithmes populaires pris en charge par Scikit-Learn incluent :

• Régression linéaire:Un algorithme simple mais puissant pour l'analyse de régression, qui modélise la relation entre la variable dépendante et une ou plusieurs variables indépendantes.
• Régression logistique:Un algorithme de classification qui modélise la probabilité d'un résultat binaire ou multi-classes en fonction d'une combinaison linéaire de caractéristiques d'entrée.
• Arbres de décision:Un algorithme polyvalent qui construit un modèle arborescent pour prendre des décisions basées sur un ensemble de conditions ou de règles.
• Machines à vecteurs de support (SVM):Un algorithme puissant qui effectue la classification en trouvant le meilleur hyperplan pour séparer différentes classes dans l'espace des fonctionnalités.
• Bayes naïf:Un algorithme probabiliste basé sur le théorème de Bayes, couramment utilisé pour la classification de texte et le filtrage du spam.

En plus de ces algorithmes, Scikit-Learn prend également en charge divers algorithmes de clustering, techniques de réduction de dimensionnalité et méthodes d'ensemble, telles que les forêts aléatoires et le gradient boosting.

Installation et configuration

Configuration requise

Avant d'installer Scikit-Learn, assurez-vous que votre système répond aux exigences suivantes :

• Python 3.x (Scikit-Learn n'est pas compatible avec Python 2.x)
• NumPy et SciPy (Scikit-Learn dépend de ces bibliothèques pour des calculs numériques efficaces)
• Matplotlib (facultatif, pour la visualisation des données)

Installation de Scikit-Learn

Pour installer Scikit-Learn, vous pouvez utiliser le gestionnaire de paquets Python, pip. Ouvrez votre terminal ou votre invite de commande et exécutez la commande suivante :

pip installe scikit-learn

Si vous préférez utiliser Anaconda, vous pouvez installer Scikit-Learn en utilisant le gestionnaire de paquets conda :

conda installer scikit-learn

Scikit-Learn est maintenant prêt à être utilisé dans votre environnement Python.

Importer Scikit-Learn

Pour commencer à utiliser Scikit-Learn, vous devez importer les modules nécessaires. En Python, vous pouvez importer Scikit-Learn à l'aide de l'instruction suivante :

importer sklearn

Une fois importé, vous pouvez accéder aux différentes classes et fonctions fournies par Scikit-Learn pour effectuer des tâches d'apprentissage automatique.

Représentation des données dans Scikit-Learn

Caractéristiques et variables cibles

Dans Scikit-Learn, les données sont généralement représentées sous forme de tableau ou de matrice bidimensionnelle, où chaque ligne représente un échantillon ou une observation individuelle, et chaque colonne représente une caractéristique ou un attribut de cet échantillon. La variable cible, que nous cherchons à prédire, est généralement représentée sous forme de tableau ou de vecteur unidimensionnel distinct.

Tableaux Numpy et DataFrames Pandas

Scikit-Learn peut fonctionner avec des tableaux NumPy et des DataFrames Pandas en entrée. Les tableaux NumPy sont efficaces et largement utilisés pour les calculs numériques, tandis que les DataFrames Pandas offrent des fonctionnalités supplémentaires pour la manipulation et l'analyse des données.

Pour convertir un DataFrame Pandas en un tableau NumPy, vous pouvez utiliser le valeurs attribut:

importer pandas comme pd importer numpy comme np

Créer un DataFrame

df = pd.DataFrame({'fonctionnalité1': [1, 2, 3], 'fonctionnalité2': [4, 5, 6], 'cible': [0, 1, 0]})

Convertir un DataFrame en tableau NumPy

données = df.valeurs

Fonctionnalités distinctes et variables cibles

X = données[:, :-1] Caractéristiques # y = données[:, -1] Cible #

Gestion des données manquantes

Les ensembles de données du monde réel contiennent souvent des valeurs manquantes, ce qui peut nuire aux performances des modèles d'apprentissage automatique. Scikit-Learn propose diverses stratégies pour gérer les données manquantes, notamment l'imputation et la suppression.

Une méthode populaire est l'imputation moyenne, où les valeurs manquantes sont remplacées par la moyenne des valeurs disponibles pour cette fonctionnalité. Scikit-Learn fournit la SimpleImputer classe pour l'imputation des valeurs manquantes :

à partir de sklearn.impute importer SimpleImputer

Créer un objet imputer

imputer = SimpleImputer(stratégie='moyenne')

Ajuster l'imputer aux données

imputer.fit(X)

Imputer les valeurs manquantes

X_imputé = imputer.transform(X)

Gestion des variables catégorielles

Les variables catégorielles, qui peuvent prendre un nombre limité de valeurs, doivent être codées dans un format numérique avant de pouvoir être utilisées dans des algorithmes d'apprentissage automatique. Scikit-Learn propose diverses techniques de codage des variables catégorielles, telles que le codage one-hot et le codage des étiquettes.

Le codage à chaud crée des caractéristiques binaires pour chaque catégorie, représentant l'absence ou la présence de cette catégorie. Scikit-Learn fournit les Encodeur OneHot classe pour l'encodage one-hot :

à partir de sklearn.preprocessing importer OneHotEncoder

Créer un objet encodeur

encodeur = OneHotEncoder()

Adaptez l'encodeur aux données

encodeur.fit(X)

Coder les variables catégorielles

X_encoded = encodeur.transform(X)

Le codage des étiquettes attribue une étiquette numérique unique à chaque catégorie. Scikit-Learn fournit les Encodeur d'étiquettes classe pour l'encodage des étiquettes :

à partir de sklearn.preprocessing importer LabelEncoder

Créer un objet encodeur

encodeur = LabelEncoder()

Adaptez l'encodeur aux données

encodeur.fit(y)

Coder une variable catégorielle

y_encoded = encodeur.transform(y)

Prétraitement des données

Nettoyage des données

Le nettoyage des données consiste à supprimer ou à corriger les erreurs, les incohérences ou les valeurs aberrantes dans l'ensemble de données. Cela peut améliorer la qualité et la fiabilité des prévisions du modèle.

Scikit-Learn propose diverses techniques de nettoyage des données, telles que la gestion des données manquantes (comme indiqué précédemment), la détection des valeurs aberrantes et la réduction du bruit. Ces techniques peuvent être appliquées avant ou après la mise à l'échelle des fonctionnalités, en fonction des exigences spécifiques du problème.

Mise à l'échelle des données

La mise à l'échelle des fonctionnalités est une étape cruciale dans de nombreux algorithmes d'apprentissage automatique, car elle garantit que toutes les fonctionnalités sont à une échelle similaire. Cela peut empêcher certaines fonctionnalités de dominer les autres et améliorer les performances et la convergence du modèle.

Scikit-Learn propose plusieurs méthodes de mise à l'échelle des fonctionnalités, notamment la standardisation et la normalisation. La standardisation met à l'échelle chaque fonctionnalité de sorte qu'elle ait une moyenne de 0 et un écart type de 1, tandis que la normalisation met à l'échelle chaque fonctionnalité sur une plage spécifique, généralement comprise entre 0 et 1.

à partir de sklearn.preprocessing importer StandardScaler, MinMaxScaler

Créer un objet scaler

scaler = StandardScaler()

Ajuster l'échelle aux données

scaler.fit(X)

Mettre à l'échelle les fonctionnalités

X_scaled = scaler.transform(X)

Codage des fonctionnalités

Outre la gestion des variables catégorielles, le codage des caractéristiques peut également impliquer la transformation et la combinaison de caractéristiques existantes pour créer de nouvelles caractéristiques informatives. Ce processus est souvent appelé ingénierie des caractéristiques et est essentiel pour améliorer les performances et l'interprétabilité des modèles d'apprentissage automatique.

Scikit-Learn propose plusieurs techniques de codage de caractéristiques, telles que les caractéristiques polynomiales, les termes d'interaction et les transformations de Fourier. Ces techniques peuvent être utilisées pour créer des relations non linéaires et capturer des interactions d'ordre supérieur entre les caractéristiques.

Fractionnement des données pour la formation et les tests

Pour évaluer les performances d'un modèle d'apprentissage automatique, il est essentiel de disposer d'ensembles de données distincts pour la formation et les tests. Scikit-Learn fournit les train_test_split fonction permettant de diviser les données en un ensemble d'apprentissage et un ensemble de test.

à partir de sklearn.model_selection importer train_test_split

Diviser les données en ensembles d’entraînement et de test

X_train, X_test, y_train, y_test = train_test_split(X, y, taille_test=0.2, état_aléatoire=42)

Le taille_test Le paramètre spécifie la proportion des données à utiliser pour les tests et la état_aléatoire le paramètre assure la reproductibilité en fixant la graine aléatoire.

Apprentissage supervisé

Aperçu de l'apprentissage supervisé

L'apprentissage supervisé est un type d'apprentissage automatique dans lequel le modèle apprend à partir de données d'entraînement étiquetées pour faire des prédictions ou prendre des décisions. Il consiste à fournir des fonctionnalités d'entrée et leurs valeurs cibles correspondantes au modèle, ce qui lui permet d'apprendre la relation entre les fonctionnalités et la cible.

Scikit-Learn propose une large gamme d'algorithmes d'apprentissage supervisé pour les tâches de régression et de classification. Ces algorithmes utilisent différentes techniques mathématiques et statistiques pour apprendre les modèles et les relations sous-jacents dans les données.

Régression linéaire

La régression linéaire est un algorithme simple mais puissant pour l'analyse de régression, dont l'objectif est de prédire une variable cible continue en fonction d'une ou plusieurs caractéristiques d'entrée. Il suppose une relation linéaire entre les caractéristiques et la variable cible.

Scikit-Learn fournit le Régression linéaire classe pour la régression linéaire :

à partir de sklearn.linear_model importer LinearRegression

Créer un objet de régression linéaire

modèle = LinearRegression()

Ajuster le modèle aux données d'entraînement

modèle.fit(X_train, y_train)

Faire des prédictions sur de nouvelles données

y_pred = modèle.predict(X_test)

Régression logistique

La régression logistique est un algorithme de classification qui modélise la probabilité d'un résultat binaire ou multi-classe en fonction d'une combinaison linéaire de caractéristiques d'entrée. Il est largement utilisé pour les problèmes de classification binaire, tels que la détection de spam ou le diagnostic de maladie.

Scikit-Learn fournit le Régression logistique classe pour la régression logistique :

à partir de sklearn.linear_model importer LogisticRegression

Créer un objet de régression logistique

modèle = Régression Logistique()

Ajuster le modèle aux données d'entraînement

modèle.fit(X_train, y_train)

Faire des prédictions sur de nouvelles données

y_pred = modèle.predict(X_test)

Arbres de décision

Les arbres de décision sont des algorithmes polyvalents qui construisent un modèle arborescent pour prendre des décisions basées sur un ensemble de conditions ou de règles. Ils sont couramment utilisés pour les tâches de régression et de classification et peuvent gérer à la fois des variables numériques et catégorielles.

Scikit-Learn fournit le Arbre de décision régresseur classe pour la régression de l'arbre de décision et la Classificateur d'arbre de décision classe pour la classification des arbres de décision :

à partir de sklearn.tree importer DecisionTreeRegressor, DecisionTreeClassifier

Créer un objet d'arbre de décision

modèle = DecisionTreeRegressor() # Pour la régression

ou

modèle = DecisionTreeClassifier() # Pour la classification

Ajuster le modèle aux données d'entraînement

modèle.fit(X_train, y_train)

Faire des prédictions sur de nouvelles données

y_pred = modèle.predict(X_test)

Machines à vecteurs de support

Les machines à vecteurs de support (SVM) sont des algorithmes puissants qui effectuent la classification en trouvant le meilleur hyperplan pour séparer différentes classes dans l'espace des caractéristiques. Ils peuvent gérer les problèmes de classification linéaires et non linéaires et sont particulièrement efficaces dans les espaces à haute dimension.

Scikit-Learn fournit le SVC classe pour la classification des vecteurs de support :

depuis sklearn.svm importer SVC

Créer un objet classificateur de vecteur de support

modèle = SVC()

Ajuster le modèle aux données d'entraînement

modèle.fit(X_train, y_train)

Faire des prédictions sur de nouvelles données

y_pred = modèle.predict(X_test)

Bayes naïf

Naive Bayes est un algorithme probabiliste basé sur le théorème de Bayes et est couramment utilisé pour la classification de texte et le filtrage du spam. Il suppose que toutes les caractéristiques sont conditionnellement indépendantes compte tenu de l'étiquette de classe et estime la probabilité de chaque classe en fonction des caractéristiques observées.

Scikit-Learn fournit plusieurs classificateurs bayésiens naïfs, notamment GaussienNB pour les fonctionnalités continues et MultinomialNB pour les fonctions discrètes :

à partir de sklearn.naive_bayes importer GaussianNB, MultinomialNB

Créer un objet classificateur bayésien naïf

modèle = GaussianNB() # Pour les fonctionnalités continues

ou

modèle = MultinomialNB() # Pour les fonctionnalités discrètes

Ajuster le modèle aux données d'entraînement

modèle.fit(X_train, y_train)

Faire des prédictions sur de nouvelles données

y_pred = modèle.predict(X_test)

Apprentissage non supervisé

Aperçu de l'apprentissage non supervisé

L'apprentissage non supervisé est un type d'apprentissage automatique dans lequel le modèle apprend à partir de données non étiquetées pour découvrir des modèles ou des structures cachés. Il consiste à fournir des caractéristiques d'entrée sans aucune valeur cible correspondante, ce qui permet au modèle d'apprendre la distribution sous-jacente des données.

Scikit-Learn propose une large gamme d'algorithmes d'apprentissage non supervisés pour des tâches telles que le clustering, la réduction de dimensionnalité et la détection d'anomalies. Ces algorithmes utilisent différentes techniques, telles que les mesures de distance et la modélisation probabiliste, pour extraire des informations significatives des données.

Analyse en composantes principales (ACP)

L'analyse en composantes principales (ACP) est une technique de réduction de dimensionnalité qui vise à projeter les données dans un espace de dimension inférieure tout en préservant autant que possible les informations d'origine. Elle y parvient en trouvant les directions (composantes principales) le long desquelles les données varient le plus.

Scikit-Learn fournit le PCA cours pour PCA :

à partir de sklearn.decomposition importer PCA

Créer un objet PCA

pca = PCA(n_composants=2)

Ajuster le modèle PCA aux données

pca.fit(X)

Transformer les données dans l'espace de dimension inférieure

X_transformé = pca.transform(X)

Regroupement k-Means

Le clustering k-Means est un algorithme populaire pour partitionner les données en k clusters, où chaque échantillon appartient au centre du cluster le plus proche. Il vise à minimiser la somme des carrés au sein du cluster, en regroupant efficacement les échantillons similaires.

Scikit-Learn fournit le K-Moyenne classe pour le clustering k-Means :

depuis sklearn.cluster importer KMeans

Créer un objet de clustering k-Means

kmeans = KMeans(n_clusters=3)

Ajuster le modèle k-Means aux données

kmeans.fit(X)

Prédire les étiquettes de cluster pour les données

étiquettes = kmeans.predict(X)

Regroupement hiérarchique

Le clustering hiérarchique est un algorithme agglomératif qui commence avec chaque échantillon comme cluster individuel et fusionne successivement les clusters les plus similaires jusqu'à ce qu'une condition de terminaison soit remplie. Il en résulte une hiérarchie de clusters, qui peut être visualisée sous la forme d'une structure arborescente appelée dendrogramme.

Scikit-Learn fournit le AgglomérationClustering classe pour le clustering hiérarchique :

à partir de sklearn.cluster importer AgglomerativeClustering

Créer un objet de clustering agglomératif

hiérarchique = AgglomerativeClustering(n_clusters=3)

Ajuster le modèle de clustering agglomératif aux données

ajustement.hiérarchique(X)

Prédire les étiquettes de cluster pour les données

étiquettes = étiquettes.hiérarchiques_

Sélection et évaluation des modèles

Validation croisée

La validation croisée est une technique largement utilisée pour estimer les performances d'un modèle d'apprentissage automatique sur des données non vues. Elle consiste à diviser les données disponibles en plusieurs sous-ensembles ou plis, à entraîner le modèle sur un sous-ensemble des plis et à évaluer ses performances sur le pli restant.

Scikit-Learn fournit le score_cross_val fonction permettant d'effectuer une validation croisée :

à partir de sklearn.model_selection importer cross_val_score

Effectuer une validation croisée sur un modèle

scores = cross_val_score(modèle, X, y, cv=5)

Le CV Le paramètre spécifie le nombre de plis à utiliser pour la validation croisée. La fonction renvoie un tableau de scores, un pour chaque pli.

Recherche par grille

La recherche de grille est une technique de réglage des hyperparamètres, dans laquelle une grille de valeurs d'hyperparamètres est définie, et le modèle est formé et évalué pour chaque combinaison d'hyperparamètres. Elle permet de trouver l'ensemble optimal d'hyperparamètres qui maximise les performances du modèle.

Scikit-Learn fournit le Recherche de grille CV classe pour effectuer une recherche dans la grille :

à partir de sklearn.model_selection importer GridSearchCV

Définir une grille d'hyperparamètres à rechercher

param_grid = {'C': [1, 10, 100], 'gamma': [0.1, 0.01, 0.001]}

Effectuer une recherche de grille sur un modèle

grid_search = GridSearchCV (modèle, param_grid, cv=5)

Ajuster le modèle de recherche de grille aux données

recherche_grille.fit(train_X, train_y)

Obtenez les meilleurs hyperparamètres et les performances correspondantes

meilleurs_params = grid_search.best_params_ meilleur_score = grid_search.best_score_

Mesures d'évaluation

Les mesures d'évaluation sont utilisées pour mesurer les performances d'un modèle d'apprentissage automatique. Scikit-Learn fournit une large gamme de mesures d'évaluation pour les tâches de régression, de classification et de clustering. Ces mesures aident à évaluer l'exactitude, la précision, le rappel et d'autres aspects de performance du modèle.

Certaines mesures d’évaluation couramment utilisées dans Scikit-Learn incluent l’erreur quadratique moyenne (MSE), l’exactitude, la précision, le rappel, le score F1 et le score de silhouette.

Méthodes d'ensemble

Ensachage

Le bagging, abréviation de bootstrap aggregation, est une méthode d'ensemble qui combine plusieurs modèles en entraînant chaque modèle sur un sous-ensemble échantillonné de manière aléatoire des données d'entraînement. Elle permet de réduire le surapprentissage et d'améliorer la stabilité et la robustesse des prédictions.

Scikit-Learn fournit le Régresseur de bagging et EnsachageClassificateur classes pour l'ensachage :

à partir de sklearn.ensemble importer BaggingRegressor, BaggingClassifier

Créer un objet régresseur de bagging

ensachage = BaggingRegressor(base_estimator=model, n_estimators=10)

Créer un objet classificateur de bagging

ensachage = BaggingClassifier(base_estimator=model, n_estimators=10)

Stimuler

Le boosting est une autre méthode d'ensemble qui combine plusieurs modèles faibles en un modèle fort en ajustant de manière itérative les poids des échantillons d'entraînement en fonction des performances des modèles précédents. Elle se concentre sur les échantillons difficiles à classer, améliorant progressivement les performances du modèle.

Scikit-Learn fournit le Régresseur AdaBoost et Classificateur AdaBoost cours pour booster :

depuis sklearn.ensemble importer AdaBoostRegressor, AdaBoostClassifier

Créer un objet régresseur AdaBoost

boosting = AdaBoostRegressor(base_estimator=model, n_estimators=10)

Créer un objet classificateur AdaBoost

boosting = AdaBoostClassifier(base_estimator=model, n_estimators=10)

Forêts aléatoires

Random Forests est une méthode d'ensemble qui combine plusieurs arbres de décision, où chaque arbre est formé sur un sous-ensemble de fonctionnalités sélectionnées de manière aléatoire. Elle réduit le surapprentissage et améliore la précision et la robustesse des prédictions.

Scikit-Learn fournit le Régresseur de forêt aléatoire et Classificateur de forêt aléatoire classes pour les forêts aléatoires :

à partir de sklearn.ensemble importer RandomForestRegressor, RandomForestClassifier

Créer un objet régresseur de forêt aléatoire

forêt = RandomForestRegressor(n_estimators=10)

Créer un objet classificateur de forêt aléatoire

forêt = RandomForestClassifier(n_estimators=10)

Amplification du gradient

Le Gradient Boosting est une méthode d'ensemble qui combine plusieurs modèles faibles, tels que des arbres de décision, en un modèle fort en minimisant de manière itérative une fonction de perte. Elle construit le modèle par étapes, où chaque nouveau modèle corrige les erreurs des modèles précédents.

Scikit-Learn fournit le Régresseur de renforcement de gradient et Classificateur de renforcement de gradient classes pour l'amplification du gradient :

à partir de sklearn.ensemble importer GradientBoostingRegressor, GradientBoostingClassifier

Créer un objet régresseur d'amplification de gradient

boosting = GradientBoostingRegressor(n_estimators=10)

Créer un objet classificateur d'amplification de gradient

boosting = GradientBoostingClassifier(n_estimators=10)

Réduction de la dimensionnalité

Analyse discriminante linéaire (LDA)

L'analyse discriminante linéaire (LDA) est une technique de réduction de dimensionnalité qui vise à trouver un espace de dimension inférieure qui maximise la séparation entre les différentes classes. Elle y parvient en projetant les données sur un ensemble de vecteurs discriminants linéaires.

Scikit-Learn fournit le Analyse discriminante linéaire classe pour LDA:

à partir de sklearn.discriminant_analysis importer LinearDiscriminantAnalysis

Créer un objet LDA

lda = AnalyseDiscriminanteLinéaire(n_composants=2)

Ajuster le modèle LDA aux données

lda.fit(X, y)

Transformer les données dans l'espace de dimension inférieure

X_transformé = lda.transform(X)

Incorporation de voisins stochastiques distribués en t (t-SNE)

L'intégration stochastique distribuée en t (t-SNE) est une technique de réduction de dimensionnalité qui vise à préserver la structure locale et globale des données dans un espace de dimension inférieure. Elle y parvient en modélisant la distribution de probabilité des similitudes par paires entre les points de données.

Scikit-Learn fournit le TSNE classe pour t-SNE :

à partir de sklearn.manifold importer TSNE

Créer un objet t-SNE

tsne = TSNE(n_composants=2)

Ajuster le modèle t-SNE aux données

tsne.fit(X)

Transformer les données dans l'espace de dimension inférieure

X_transformé = tsne.transform(X)

Sauvegarde et chargement des modèles

Sérialisation et désérialisation

La sérialisation est le processus de conversion d'un modèle en un format sérialisé qui peut être stocké dans un fichier ou transféré sur un réseau. La désérialisation est le processus inverse de reconstruction du modèle à partir du format sérialisé.

Scikit-Learn fournit le saumure module de sérialisation et de désérialisation :

importer des cornichons

Sérialiser le modèle dans un fichier

avec open('model.pkl', 'wb') comme fichier : pickle.dump(model, file)

Désérialiser le modèle à partir d'un fichier

avec open('model.pkl', 'rb') comme fichier : model = pickle.load(file)

Pickle et Joblib

Pickle est un module intégré à Python qui permet de sérialiser et de désérialiser des objets, y compris des modèles Scikit-Learn. Cependant, ce n'est peut-être pas l'option la plus efficace pour les modèles ou les ensembles de données volumineux.

Scikit-Learn fournit également le travaillib module, qui est une alternative plus efficace à pickle pour la sérialisation et la désérialisation :

depuis sklearn.externals importer joblib

Sérialiser le modèle dans un fichier

joblib.dump(modèle, 'model.pkl')

Désérialiser le modèle à partir d'un fichier

modèle = joblib.load('model.pkl')

Le travaillib le module prend en charge le parallélisme et offre de meilleures performances pour les tâches de calcul scientifique de grande envergure.

Sauvegarde et chargement des modèles

Une fois qu'un modèle est formé et évalué, il est souvent nécessaire de le sauvegarder pour une utilisation ou un déploiement ultérieur. Scikit-Learn propose diverses options pour sauvegarder et charger des modèles, notamment la sérialisation et la désérialisation à l'aide de pickle ou joblib.

En sauvegardant le modèle, vous pouvez éviter de devoir le réentraîner à chaque fois que vous souhaitez l'utiliser. Cela est particulièrement utile lorsque vous travaillez avec de grands ensembles de données ou des modèles coûteux en termes de calcul.

Pour enregistrer un modèle entraîné, vous pouvez utiliser le sauvegarder méthode fournie par l'objet modèle :

modèle.save(“modèle.h5”)

Pour charger un modèle enregistré, vous pouvez utiliser le charger_modele fonction de la bibliothèque correspondante :

depuis tensorflow.keras.models importer load_model

modèle = load_model(“model.h5”)

Assurez-vous d'importer la bibliothèque appropriée et de spécifier le chemin de fichier correct lors de l'enregistrement et du chargement des modèles.

En conclusion, Scikit-Learn est une bibliothèque d'apprentissage automatique complète et puissante en Python qui offre une large gamme d'algorithmes et d'outils pour l'analyse des données et la formation des modèles. Avec son interface conviviale, sa mise en œuvre efficace et sa documentation complète, Scikit-Learn est le choix incontournable pour les data scientists débutants et expérimentés. En suivant les instructions d'installation et de configuration, en comprenant la représentation des données, les techniques de prétraitement, les algorithmes d'apprentissage supervisés et non supervisés, les méthodes de sélection et d'évaluation des modèles, les méthodes d'ensemble, les techniques de réduction de la dimensionnalité et les processus de sérialisation et de désérialisation, vous serez bien équipé pour vous attaquer à diverses tâches d'apprentissage automatique à l'aide de Scikit-Learn.