10 python one-liners pour optimiser vos pipelines d’apprentissage automatique

Image de l’auteur | Chatte

# Introduction

En ce qui concerne l’apprentissage automatique, l’efficacité est essentielle. L’écriture de code propre, lisible et concise accélère non seulement le développement, mais rend également vos pipelines d’apprentissage automatique plus faciles à comprendre, à partager, à maintenir et à déboguer. Python, avec sa syntaxe naturelle et expressive, est un excellent ajustement pour fabriquer des doublures puissantes qui peuvent gérer les tâches courantes dans une seule ligne de code.

Ce tutoriel se concentrera sur dix one-liners pratiques qui tiennent à tirer parti de la puissance des bibliothèques comme Scikit-apprend et Pandas Pour vous aider à rationaliser vos flux de travail d’apprentissage automatique. Nous couvrirons tout, de la préparation des données et de la formation du modèle à l’évaluation et à l’analyse des fonctionnalités.

Commençons.

# Configuration de l’environnement

Avant de créer notre code, importons les bibliothèques nécessaires que nous utiliserons tout au long des exemples.

import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

Avec cela à l’écart, codons … une ligne à la fois.

# 1. Chargement d’un ensemble de données

Commençons par l’une des bases. Commencer avec un projet signifie souvent charger des données. Scikit-Learn est livré avec plusieurs ensembles de données de jouets qui sont parfaits pour tester les modèles et les workflows. Vous pouvez charger à la fois les fonctionnalités et la variable cible en une seule ligne propre.

X, y = load_iris(return_X_y=True)

Ce seul liner utilise le load_iris fonction et ensembles return_X_y=True Pour retourner directement la matrice de fonctionnalité X et le vecteur cible yévitant la nécessité d’analyser un objet de type dictionnaire.

# 2. Diviser les données en ensembles de formation et de test

Une autre étape fondamentale de tout projet d’apprentissage automatique consiste à diviser vos données en plusieurs ensembles pour différentes utilisations. Le train_test_split La fonction est un pilier; Il peut être exécuté en une seule ligne pour produire quatre fractures de données distinctes pour vos ensembles de formation et de test.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

Ici, nous utilisons test_size=0.3 pour allouer 30% des données pour les tests et utiliser stratify=y Pour garantir la proportion de classes dans le train et les ensembles de tests reflète l’ensemble de données d’origine.

# 3. Création et formation d’un modèle

Pourquoi utiliser deux lignes pour instancier un modèle, puis la former? Vous pouvez enchaîner le fit Méthode directement au constructeur du modèle pour une ligne de code compacte et lisible, comme ceci:

model = LogisticRegression(max_iter=1000, random_state=42).fit(X_train, y_train)

Cette ligne unique crée un LogisticRegression Modèle et le forme immédiatement sur vos données d’entraînement, renvoyant l’objet modèle ajusté.

# 4. Effectuer une validation croisée K-Fold

La validation croisée donne une estimation plus robuste des performances de votre modèle qu’une seule division de test de train. Scikit-Learn cross_val_score Rend-il facile d’effectuer cette évaluation en une seule étape.

scores = cross_val_score(LogisticRegression(max_iter=1000, random_state=42), X, y, cv=5)

Cette ligne unique initialise un nouveau modèle de régression logistique, divise les données en 5 plis, entraîne et évalue le modèle 5 fois (cv=5), et renvoie une liste des scores de chaque pli.

# 5. Faire des prédictions et calcul de la précision

Après avoir formé votre modèle, vous voudrez évaluer ses performances sur l’ensemble de tests. Vous pouvez le faire et obtenir le score de précision avec un seul appel de méthode.

accuracy = model.score(X_test, y_test)

Le .score() La méthode combine commodément les étapes de calcul de prédiction et de précision, renvoyant la précision du modèle sur les données de test fournies.

# 6. Échelle des caractéristiques numériques

La mise à l’échelle des fonctionnalités est une étape de prétraitement courante, en particulier pour les algorithmes sensibles à l’échelle des caractéristiques d’entrée – y compris les SVM et la régression logistique. Vous pouvez ajuster le scaleur et transformer vos données simultanément en utilisant cette seule ligne de Python:

X_scaled = StandardScaler().fit_transform(X)

Le fit_transform La méthode est un raccourci pratique qui apprend les paramètres de mise à l’échelle des données et applique la transformation en un seul coup.

# 7. Appliquer un codage à un hot aux données catégorielles

Le codage à un hot est une technique standard pour gérer les caractéristiques catégorielles. Tandis que Scikit-Learn a un puissant OneHotEncoder Méthode puissante, le get_dummies La fonction de Pandas permet une vraie liner pour cette tâche.

df_encoded = pd.get_dummies(pd.DataFrame(X, columns=('f1', 'f2', 'f3', 'f4')), columns=('f1'))

Cette ligne convertit une colonne spécifique (f1) Dans un Pandas DataFrame dans de nouvelles colonnes avec des valeurs binaires (f1, f2, f3, f4), parfait pour les modèles d’apprentissage automatique.

# 8. Définition d’un pipeline Scikit-Learn

Les pipelines Scikit-Learn réalisent les chaînes de plusieurs étapes de traitement et un estimateur final simple. Ils empêchent les fuites de données et simplifient votre flux de travail. La définition d’un pipeline est une seule ligne propre, comme la suivante:

pipeline = Pipeline((('scaler', StandardScaler()), ('svc', SVC())))

Cela crée un pipeline qui fait d’abord à l’échelle les données en utilisant StandardScaler puis alimente le résultat dans un classificateur de vecteur de support.

# 9. réglage des hyperparamètres avec gridsearchcv

Trouver les meilleurs hyperparamètres pour votre modèle peut être fastidieux. GridSearchCV peut aider à automatiser ce processus. Par chaînage .fit()vous pouvez initialiser, définir la recherche et tout exécuter en une seule ligne.

grid_search = GridSearchCV(SVC(), {'C': (0.1, 1, 10), 'kernel': ('linear', 'rbf')}, cv=3).fit(X_train, y_train)

Cela met en place une recherche de grille pour un SVC modèle, teste différentes valeurs pour C et kerneleffectue une validation croisée 3 fois (cv=3), et l’ajuste aux données de formation pour trouver la meilleure combinaison.

# 10. Extraction des importations de fonctionnalités

Pour les modèles à base d’arbres comme les forêts aléatoires, la compréhension des caractéristiques les plus influentes est vitale pour construire un modèle utile et efficace. Une compréhension de la liste est une ligne pythonique classique pour extraire et tri les importations de fonctionnalités. Remarque Cet extrait construit d’abord le modèle, puis utilise une seule ligne pour déterminer les importations de fonctionnalités.

# First, train a model
feature_names = ('sepal_length', 'sepal_width', 'petal_length', 'petal_width')
rf_model = RandomForestClassifier(random_state=42).fit(X_train, y_train)

# The one-liner
importances = sorted(zip(feature_names, rf_model.feature_importances_), key=lambda x: x(1), reverse=True)

Cette ligne associe le nom de chaque fonctionnalité avec son score d’importance, puis trie la liste dans l’ordre descendant pour afficher d’abord les fonctionnalités les plus importantes.

# Emballage

Ces dix doublures montrent comment la syntaxe concise de Python peut vous aider à écrire un code d’apprentissage automatique plus efficace et lisible. Intégrez ces raccourcis dans votre flux de travail quotidien pour aider à réduire le passe-partout, à minimiser les erreurs et à passer plus de temps à se concentrer sur ce qui compte vraiment: créer des modèles efficaces et extraire des informations précieuses de vos données.

Matthew Mayo (@ Mattmayo13) est titulaire d’une maîtrise en informatique et d’un diplôme d’études supérieures en exploration de données. En tant que rédacteur en chef de Kdnuggets & Statologieet rédacteur en chef à Maîtrise de l’apprentissage automatiqueMatthew vise à rendre les concepts de science des données complexes accessibles. Ses intérêts professionnels incluent le traitement du langage naturel, les modèles de langue, les algorithmes d’apprentissage automatique et l’exploration de l’IA émergente. Il est motivé par une mission pour démocratiser les connaissances dans la communauté des sciences des données. Matthew est codant depuis l’âge de 6 ans.