Machine Learning Pipeline: Udvikling af Custom Transformers i Scikit-learn

Machine learning pipelines er afgørende for at bygge robuste og vedligeholdelsesvenlige machine learning-modeller. Scikit-learn (sklearn) tilbyder et stærkt framework til at skabe disse pipelines. En nøglekomponent i enhver god pipeline er evnen til at udføre brugerdefinerede datatransformationer. Denne artikel udforsker udviklingen af brugerdefinerede transformers i scikit-learn og giver en omfattende guide for data scientists og machine learning-ingeniører over hele verden.

Hvad er en Machine Learning Pipeline?

En machine learning pipeline er en sekvens af databehandlingskomponenter, der er kædet sammen. Disse komponenter omfatter typisk:

• Datarensning: Håndtering af manglende værdier, outliers og uoverensstemmelser.
• Feature Engineering: Oprettelse af nye features fra eksisterende for at forbedre modellens ydeevne.
• Feature-udvælgelse: Udvælgelse af de mest relevante features for modellen.
• Modeltræning: Træning af en machine learning-model på de forberedte data.
• Model-evaluering: Vurdering af den trænede models ydeevne.

Brug af en pipeline giver flere fordele, herunder:

• Reproducerbarhed: Sikrer, at de samme databehandlingstrin anvendes konsekvent.
• Modularitet: Opdeling af databehandlings-workflowet i genanvendelige komponenter.
• Vedligeholdelsesvenlighed: Gør det lettere at opdatere og vedligeholde databehandlings-workflowet.
• Forenklet implementering: Strømliner processen med at implementere machine learning-modeller.

Hvorfor Custom Transformers?

Scikit-learn tilbyder et bredt udvalg af indbyggede transformers til almindelige databehandlingsopgaver. Men i mange virkelige scenarier vil du have brug for at udføre brugerdefinerede datatransformationer, der er specifikke for dine data og dit problem. Det er her, brugerdefinerede transformers kommer ind i billedet. Brugerdefinerede transformers giver dig mulighed for at indkapsle din brugerdefinerede databehandlingslogik i genanvendelige komponenter, der problemfrit kan integreres i en scikit-learn pipeline.

Forestil dig for eksempel, at du arbejder med kundedata fra en global e-handelsplatform. Du kan have brug for at oprette en brugerdefineret transformer, der konverterer transaktionsvalutaer til en fælles valuta (f.eks. USD) baseret på historiske valutakurser. Eller overvej et scenarie, der involverer sensordata fra IoT-enheder på tværs af forskellige lande; du kunne bygge en brugerdefineret transformer til at normalisere data baseret på lokale tidszoner og måleenheder.

Opbygning af en Custom Transformer

For at oprette en brugerdefineret transformer i scikit-learn skal du oprette en klasse, der arver fra sklearn.base.BaseEstimator og sklearn.base.TransformerMixin. Din klasse skal implementere to metoder:

• fit(self, X, y=None): Denne metode lærer eventuelle parametre, der er nødvendige for transformationen. I mange tilfælde returnerer denne metode blot self.
• transform(self, X): Denne metode anvender transformationen på dataene.

Her er et grundlæggende eksempel på en brugerdefineret transformer, der tilføjer en konstant værdi til hver feature:

            from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class AddConstantTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, constant=1):
        self.constant = constant

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return X + self.constant

            

              
                Copy
              
            
          

Lad os gennemgå dette eksempel:

• Importer nødvendige biblioteker: BaseEstimator, TransformerMixin fra sklearn.base og numpy til numeriske operationer.
• Definer klassen: AddConstantTransformer arver fra BaseEstimator og TransformerMixin.
• Konstruktør (__init__): Denne metode initialiserer transformeren med en constant-værdi (standard er 1).
• fit-metoden: Denne metode returnerer blot self, da denne transformer ikke behøver at lære nogen parametre fra dataene.
• transform-metoden: Denne metode tilføjer constant-værdien til hvert element i inputdataene X.

Eksempel på Anvendelse

            from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = np.array([[1, 2], [3, 4], [5, 6]])

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('add_constant', AddConstantTransformer(constant=2))
])

X_transformed = pipeline.fit_transform(X)

print(X_transformed)

            

              
                Copy
              
            
          

Dette eksempel viser, hvordan man bruger AddConstantTransformer i en pipeline. Først skaleres dataene ved hjælp af StandardScaler, og derefter tilføjes konstanten ved hjælp af vores brugerdefinerede transformer.

Avanceret Udvikling af Custom Transformers

Lad os nu udforske nogle mere avancerede scenarier og teknikker til at bygge brugerdefinerede transformers.

Håndtering af Kategoriske Features

Kategoriske features er en almindelig datatype i machine learning. Du kan oprette brugerdefinerede transformers til at udføre forskellige operationer på kategoriske features, såsom one-hot encoding, label encoding eller feature hashing.

Her er et eksempel på en brugerdefineret transformer, der udfører one-hot encoding på specificerede kolonner:

            import pandas as pd
from sklearn.preprocessing import OneHotEncoder

class CategoricalEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None):
        self.categorical_features = categorical_features
        self.encoder = None

    def fit(self, X, y=None):
        if self.categorical_features is None:
            self.categorical_features = X.select_dtypes(include=['object']).columns

        self.encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
        self.encoder.fit(X[self.categorical_features])
        return self

    def transform(self, X):
        X_encoded = self.encoder.transform(X[self.categorical_features])
        X_encoded = pd.DataFrame(X_encoded, index=X.index, columns=self.encoder.get_feature_names_out(self.categorical_features))
        X = X.drop(columns=self.categorical_features)
        X = pd.concat([X, X_encoded], axis=1)
        return X

            

              
                Copy
              
            
          

I dette eksempel:

• Transformeren identificerer automatisk kategoriske kolonner (hvis ikke specificeret).
• Den bruger OneHotEncoder fra scikit-learn til at udføre kodningen.
• Den håndterer ukendte kategorier ved hjælp af handle_unknown='ignore'.
• De kodede features sammenkædes med den oprindelige dataframe.

Håndtering af Manglende Værdier

Manglende værdier er et andet almindeligt problem i machine learning-datasæt. Du kan oprette brugerdefinerede transformers til at imputere manglende værdier ved hjælp af forskellige strategier, såsom imputering med gennemsnit, median eller modus.

Her er et eksempel på en brugerdefineret transformer, der imputer manglende værdier ved hjælp af medianen:

            from sklearn.impute import SimpleImputer

class MissingValueImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='median', missing_values=np.nan):
        self.strategy = strategy
        self.missing_values = missing_values
        self.imputer = None

    def fit(self, X, y=None):
        self.imputer = SimpleImputer(strategy=self.strategy, missing_values=self.missing_values)
        self.imputer.fit(X)
        return self

    def transform(self, X):
        return self.imputer.transform(X)

            

              
                Copy
              
            
          

Denne transformer bruger SimpleImputer fra scikit-learn til at udføre imputeringen. Den giver dig mulighed for at specificere imputeringsstrategien og den værdi, der bruges til at repræsentere manglende værdier.

Feature-skalering og Normalisering

Feature-skalering og normalisering er vigtige forbehandlingstrin for mange machine learning-algoritmer. Du kan oprette brugerdefinerede transformers til at implementere forskellige skalerings- og normaliseringsteknikker.

Selvom scikit-learn tilbyder transformers som StandardScaler og MinMaxScaler, kan du have brug for en brugerdefineret scaler til specifikke datafordelinger. For eksempel, hvis du har data med en meget skæv fordeling, kan en PowerTransformer (også tilgængelig i scikit-learn) være mere passende. Du kan dog indkapsle den i en brugerdefineret transformer for at styre dens parametre og integrere den problemfrit i din pipeline.

            from sklearn.preprocessing import PowerTransformer

class SkewedDataTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, method='yeo-johnson'):
        self.method = method
        self.transformer = None

    def fit(self, X, y=None):
        self.transformer = PowerTransformer(method=self.method)
        self.transformer.fit(X)
        return self

    def transform(self, X):
        return self.transformer.transform(X)

            

              
                Copy
              
            
          

Kombinering af Flere Transformationer

Nogle gange kan det være nødvendigt at anvende flere transformationer på de samme data. Du kan oprette en brugerdefineret transformer, der kombinerer flere transformationer i et enkelt trin. Dette kan hjælpe med at forenkle din pipeline og gøre den mere læsbar.

Her er et eksempel på en brugerdefineret transformer, der kombinerer one-hot encoding og imputering af manglende værdier:

            class CombinedTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None, missing_value_strategy='median'):
        self.categorical_features = categorical_features
        self.missing_value_strategy = missing_value_strategy
        self.categorical_encoder = None
        self.missing_value_imputer = None

    def fit(self, X, y=None):
        self.categorical_encoder = CategoricalEncoder(categorical_features=self.categorical_features)
        self.missing_value_imputer = MissingValueImputer(strategy=self.missing_value_strategy)
        self.categorical_encoder.fit(X)
        self.missing_value_imputer.fit(X)
        return self

    def transform(self, X):
        X = self.categorical_encoder.transform(X)
        X = self.missing_value_imputer.transform(X)
        return X

            

              
                Copy
              
            
          

Denne transformer bruger CategoricalEncoder og MissingValueImputer fra de foregående eksempler til at udføre både one-hot encoding og imputering af manglende værdier i et enkelt trin.

Bedste Praksis for Udvikling af Custom Transformers

Her er nogle bedste praksis, du bør følge, når du udvikler brugerdefinerede transformers:

• Hold det enkelt: Hver transformer bør udføre en enkelt, veldefineret opgave.
• Gør den genanvendelig: Design dine transformers til at være så generiske som muligt, så de kan genbruges i forskellige pipelines.
• Håndter kanttilfælde: Overvej, hvordan din transformer vil håndtere kanttilfælde, såsom manglende værdier, outliers og uventede datatyper.
• Skriv enhedstests: Skriv enhedstests for at sikre, at din transformer fungerer korrekt.
• Dokumenter din kode: Dokumenter din kode tydeligt, så andre kan forstå, hvordan man bruger din transformer.

Eksempler fra den Virkelige Verden

Lad os udforske nogle flere eksempler på brugerdefinerede transformers fra den virkelige verden.

Feature Engineering på Datoer

Når man arbejder med tidsseriedata, er det ofte nyttigt at udtrække features fra datoer, såsom ugedag, måned på året eller kvartal. Du kan oprette en brugerdefineret transformer til at udføre denne opgave.

            class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, date_columns=None):
        self.date_columns = date_columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        for col in self.date_columns:
            X[col + '_dayofweek'] = X[col].dt.dayofweek
            X[col + '_month'] = X[col].dt.month
            X[col + '_quarter'] = X[col].dt.quarter
        return X

            

              
                Copy
              
            
          

Denne transformer udtrækker ugedag, måned og kvartal fra de specificerede datokolonner.

Feature Engineering på Tekst

Når man arbejder med tekstdata, er det ofte nyttigt at udføre feature engineering ved hjælp af teknikker som TF-IDF eller word embeddings. Du kan oprette brugerdefinerede transformers til at udføre disse opgaver. Overvej for eksempel kundeanmeldelser på flere sprog. Du kan have brug for en brugerdefineret transformer, der oversætter anmeldelserne til engelsk, før du anvender TF-IDF-vektorisering.

Bemærk: Oversættelsestjenester kræver ofte API-nøgler og kan medføre omkostninger. Dette eksempel fokuserer på strukturen af den brugerdefinerede transformer.

            # Bemærk: Dette eksempel kræver en oversættelsestjeneste (f.eks. Google Translate API) og API-nøgle
# from googletrans import Translator # Eksempelbibliotek (installer med pip install googletrans==4.0.0-rc1)

class TextFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, text_column, language='en'):
        self.text_column = text_column
        self.language = language
        # self.translator = Translator() # Instantiér oversætter (kræver opsætning)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        # Eksempel: Oversæt til engelsk (erstat med faktisk oversættelseslogik)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Dummy-oversættelse til demonstrationsformål
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Translated: " + text)

        # Anvend TF-IDF eller andre tekstvektoriseringsteknikker her
        return X

            

              
                Copy
              
            
          

Geospatial Feature Engineering

Når man arbejder med geospatiale data, kan man oprette brugerdefinerede transformers til at udtrække features såsom afstand til nærmeste by, befolkningstæthed eller arealanvendelsestype. Overvej for eksempel at analysere ejendomspriser globalt. Du kunne oprette en brugerdefineret transformer, der henter det gennemsnitlige indkomstniveau for en given placering ved hjælp af eksterne API'er baseret på bredde- og længdegrad.

Integration med Eksisterende Biblioteker

Brugerdefinerede transformers kan bruges til at indpakke funktionalitet fra andre Python-biblioteker i en scikit-learn pipeline. Dette giver dig mulighed for at udnytte kraften i andre biblioteker, mens du stadig drager fordel af strukturen og organisationen i en pipeline.

For eksempel kan du bruge en brugerdefineret transformer til at integrere et bibliotek for anomalidetektion, tidsserieprognoser eller billedbehandling i din machine learning pipeline.

Konklusion

Brugerdefinerede transformers er et stærkt værktøj til at bygge robuste og vedligeholdelsesvenlige machine learning pipelines i scikit-learn. Ved at indkapsle din brugerdefinerede databehandlingslogik i genanvendelige komponenter kan du skabe pipelines, der er lettere at forstå, opdatere og implementere. Husk at følge bedste praksis, skrive enhedstests og dokumentere din kode for at sikre, at dine brugerdefinerede transformers er pålidelige og vedligeholdelsesvenlige. Efterhånden som du udvikler dine machine learning-færdigheder, vil mestring af udvikling af brugerdefinerede transformers blive uvurderlig i håndteringen af komplekse og forskelligartede problemer fra den virkelige verden på tværs af kloden. Fra håndtering af valutaomregninger for international e-handel til behandling af sensordata fra IoT-enheder verden over, giver brugerdefinerede transformers dig mulighed for at skræddersy dine pipelines til de specifikke behov i dine data og applikationer.