Gépi tanulási adatfolyam: Egyéni Scikit-learn transzformerek fejlesztése

A gépi tanulási adatfolyamok (pipeline-ok) elengedhetetlenek a robusztus és karbantartható gépi tanulási modellek építéséhez. A Scikit-learn (sklearn) egy hatékony keretrendszert biztosít ezen adatfolyamok létrehozásához. Minden jó adatfolyam kulcsfontosságú eleme az egyéni adatátalakítások elvégzésének képessége. Ez a cikk a scikit-learn-ben történő egyéni transzformerek fejlesztését vizsgálja, átfogó útmutatót nyújtva adattudósok és gépi tanulási mérnökök számára világszerte.

Mi az a gépi tanulási adatfolyam?

A gépi tanulási adatfolyam az adatfeldolgozási komponensek egy láncolata. Ezek a komponensek általában a következőket tartalmazzák:

• Adattisztítás: A hiányzó értékek, kiugró adatok és következetlenségek kezelése.
• Jellemzőkinyerés: Új jellemzők létrehozása a meglévőkből a modell teljesítményének javítása érdekében.
• Jellemzőkiválasztás: A modell szempontjából legrelevánsabb jellemzők kiválasztása.
• Modell tanítása: Egy gépi tanulási modell tanítása az előkészített adatokon.
• Modell kiértékelése: A tanított modell teljesítményének felmérése.

Az adatfolyam használata számos előnnyel jár, többek között:

• Reprodukálhatóság: Biztosítja, hogy ugyanazokat az adatfeldolgozási lépéseket következetesen alkalmazzák.
• Modularitás: Az adatfeldolgozási munkafolyamatot újrafelhasználható komponensekre bontja.
• Karbantarthatóság: Megkönnyíti az adatfeldolgozási munkafolyamat frissítését és karbantartását.
• Egyszerűsített telepítés: Leegyszerűsíti a gépi tanulási modellek telepítési folyamatát.

Miért van szükség egyéni transzformerekre?

A Scikit-learn beépített transzformerek széles skáláját kínálja a gyakori adatfeldolgozási feladatokhoz. Azonban sok valós helyzetben olyan egyéni adatátalakításokat kell végrehajtania, amelyek specifikusak az Ön adataihoz és problémájához. Itt jönnek képbe az egyéni transzformerek. Az egyéni transzformerek lehetővé teszik, hogy az egyéni adatfeldolgozási logikáját olyan újrafelhasználható komponensekbe zárja, amelyek zökkenőmentesen integrálhatók egy scikit-learn adatfolyamba.

Képzelje el például, hogy egy globális e-kereskedelmi platform ügyféladataival dolgozik. Lehet, hogy létre kell hoznia egy egyéni transzformert, amely a tranzakciók pénznemeit egy közös pénznemre (pl. USD) váltja át a historikus árfolyamok alapján. Vagy vegyünk egy olyan esetet, amely különböző országokban található IoT-eszközök szenzoradatait érinti; itt építhet egy egyéni transzformert az adatok normalizálására a helyi időzónák és mértékegységek alapján.

Egyéni transzformer készítése

Egy egyéni transzformer létrehozásához a scikit-learn-ben létre kell hoznia egy osztályt, amely az sklearn.base.BaseEstimator és az sklearn.base.TransformerMixin osztályokból öröklődik. Az osztályának két metódust kell implementálnia:

• fit(self, X, y=None): Ez a metódus megtanul minden olyan paramétert, amely a transzformációhoz szükséges. Sok esetben ez a metódus egyszerűen a self-et adja vissza.
• transform(self, X): Ez a metódus alkalmazza a transzformációt az adatokra.

Itt egy alapvető példa egy egyéni transzformerre, amely egy állandó értéket ad hozzá minden jellemzőhöz:

            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
              
            
          

Bontsuk le ezt a példát:

• Szükséges könyvtárak importálása: BaseEstimator, TransformerMixin az sklearn.base-ből és numpy a numerikus műveletekhez.
• Az osztály definiálása: Az AddConstantTransformer a BaseEstimator és a TransformerMixin osztályokból öröklődik.
• Konstruktor (__init__): Ez a metódus inicializálja a transzformert egy constant értékkel (alapértelmezés szerint 1).
• fit metódus: Ez a metódus egyszerűen a self-et adja vissza, mivel ennek a transzformernek nem kell semmilyen paramétert tanulnia az adatokból.
• transform metódus: Ez a metódus hozzáadja a constant értéket a bemeneti X adatok minden eleméhez.

Példa a használatra

            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
              
            
          

Ez a példa bemutatja, hogyan használható az AddConstantTransformer egy adatfolyamban. Először az adatokat a StandardScaler segítségével skálázzuk, majd az állandót hozzáadjuk az egyéni transzformerünkkel.

Haladó egyéni transzformer fejlesztés

Most pedig nézzünk meg néhány haladóbb esetet és technikát az egyéni transzformerek építéséhez.

Kategorikus jellemzők kezelése

A kategorikus jellemzők gyakori adattípusok a gépi tanulásban. Létrehozhat egyéni transzformereket a kategorikus jellemzőkön végzett különféle műveletekhez, mint például a one-hot kódolás, a címkekódolás vagy a jellemzőkivonatolás (feature hashing).

Itt egy példa egy egyéni transzformerre, amely one-hot kódolást végez a megadott oszlopokon:

            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
              
            
          

Ebben a példában:

• A transzformer automatikusan azonosítja a kategorikus oszlopokat (ha nincsenek megadva).
• A kódoláshoz a scikit-learn OneHotEncoder-jét használja.
• A handle_unknown='ignore' segítségével kezeli az ismeretlen kategóriákat.
• A kódolt jellemzőket visszacsatolja az eredeti adatkerethez.

Hiányzó értékek kezelése

A hiányzó értékek egy másik gyakori probléma a gépi tanulási adathalmazokban. Létrehozhat egyéni transzformereket a hiányzó értékek pótlására különféle stratégiákkal, mint például az átlaggal, mediánnal vagy a leggyakoribb értékkel (módusszal) történő behelyettesítés.

Itt egy példa egy egyéni transzformerre, amely a mediánnal pótolja a hiányzó értékeket:

            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
              
            
          

Ez a transzformer a scikit-learn SimpleImputer-jét használja a behelyettesítéshez. Lehetővé teszi a behelyettesítési stratégia és a hiányzó értékeket reprezentáló érték megadását.

Jellemzők skálázása és normalizálása

A jellemzők skálázása és normalizálása fontos előfeldolgozási lépés sok gépi tanulási algoritmus számára. Létrehozhat egyéni transzformereket különböző skálázási és normalizálási technikák megvalósítására.

Bár a scikit-learn olyan transzformereket biztosít, mint a StandardScaler és a MinMaxScaler, előfordulhat, hogy specifikus adat eloszlásokhoz egyéni skálázóra van szüksége. Például, ha nagyon ferde eloszlású adatokkal rendelkezik, egy PowerTransformer (amely szintén elérhető a scikit-learn-ben) megfelelőbb lehet. Azonban ezt is beágyazhatja egy egyéni transzformerbe, hogy kezelje a paramétereit és zökkenőmentesen integrálja az adatfolyamába.

            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
              
            
          

Több transzformáció kombinálása

Néha szükség lehet több transzformáció alkalmazására ugyanazon adatokon. Létrehozhat egy egyéni transzformert, amely több transzformációt egyetlen lépésben egyesít. Ez segíthet leegyszerűsíteni az adatfolyamot és olvashatóbbá tenni azt.

Itt egy példa egy egyéni transzformerre, amely kombinálja a one-hot kódolást és a hiányzó értékek pótlását:

            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
              
            
          

Ez a transzformer az előző példákból származó CategoricalEncoder-t és MissingValueImputer-t használja a one-hot kódolás és a hiányzó értékek pótlásának egyetlen lépésben történő elvégzésére.

Bevált gyakorlatok az egyéni transzformerek fejlesztéséhez

Íme néhány bevált gyakorlat, amelyet érdemes követni az egyéni transzformerek fejlesztésekor:

• Maradjon egyszerű: Minden transzformernek egyetlen, jól definiált feladatot kell elvégeznie.
• Legyen újrafelhasználható: Tervezze a transzformereit a lehető legáltalánosabbra, hogy különböző adatfolyamokban is újra felhasználhatók legyenek.
• Kezelje a szélsőséges eseteket: Vegye figyelembe, hogy a transzformere hogyan fogja kezelni a szélsőséges eseteket, mint például a hiányzó értékeket, kiugró adatokat és váratlan adattípusokat.
• Írjon egységteszteket: Írjon egységteszteket annak biztosítására, hogy a transzformere helyesen működik.
• Dokumentálja a kódját: Dokumentálja a kódját egyértelműen, hogy mások is megértsék, hogyan kell használni a transzformerét.

Valós példák

Nézzünk meg néhány további valós példát az egyéni transzformerekre.

Dátum alapú jellemzőkinyerés

Idősoros adatokkal való munka során gyakran hasznos jellemzőket kinyerni a dátumokból, például a hét napját, az év hónapját vagy az év negyedévét. Létrehozhat egy egyéni transzformert e feladat elvégzésére.

            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
              
            
          

Ez a transzformer kinyeri a hét napját, a hónapot és a negyedévet a megadott dátum oszlopokból.

Szöveges jellemzőkinyerés

Szöveges adatokkal való munka során gyakran hasznos a jellemzőkinyerés olyan technikákkal, mint a TF-IDF vagy a szóbeágyazások (word embeddings). Létrehozhat egyéni transzformereket e feladatok elvégzésére. Például vegyük a többnyelvű vásárlói véleményeket. Szüksége lehet egy egyéni transzformerre, amely lefordítja a véleményeket angolra, mielőtt alkalmazná a TF-IDF vektorizálást.

Megjegyzés: A fordítási szolgáltatások gyakran API-kulcsokat igényelnek és költségekkel járhatnak. Ez a példa az egyéni transzformer struktúrájára összpontosít.

            # Megjegyzés: Ez a példa egy fordítási szolgáltatást (pl. Google Translate API) és API-kulcsot igényel
# from googletrans import Translator # Példa könyvtár (telepítés: 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() # A fordító példányosítása (beállítást igényel)

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

    def transform(self, X):
        # Példa: Fordítás angolra (cserélje le a tényleges fordítási logikára)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Dummy fordítás a bemutatás kedvéért
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Lefordítva: " + text)

        # Itt alkalmazza a TF-IDF-et vagy más szövegvektorizálási technikákat
        return X

            

              
                Copy
              
            
          

Térinformatikai jellemzőkinyerés

Térinformatikai adatokkal való munka során létrehozhat egyéni transzformereket olyan jellemzők kinyerésére, mint a legközelebbi várostól való távolság, a népsűrűség vagy a földhasználat típusa. Például vegyük az ingatlanárak globális elemzését. Létrehozhatna egy egyéni transzformert, amely külső API-k segítségével lekéri az adott helyszín átlagos jövedelmi szintjét a szélességi és hosszúsági adatok alapján.

Integráció meglévő könyvtárakkal

Az egyéni transzformerek használhatók más Python könyvtárak funkcióinak becsomagolására egy scikit-learn adatfolyamba. Ez lehetővé teszi, hogy kihasználja más könyvtárak erejét, miközben továbbra is élvezheti egy adatfolyam szerkezetének és szervezettségének előnyeit.

Például használhatna egy egyéni transzformert egy anomália-észlelési, idősor-előrejelzési vagy képfeldolgozási könyvtár integrálására a gépi tanulási adatfolyamába.

Összegzés

Az egyéni transzformerek hatékony eszközt jelentenek a robusztus és karbantartható gépi tanulási adatfolyamok építéséhez a scikit-learn-ben. Azáltal, hogy az egyéni adatfeldolgozási logikáját újrafelhasználható komponensekbe zárja, olyan adatfolyamokat hozhat létre, amelyek könnyebben érthetők, frissíthetők és telepíthetők. Ne felejtse el követni a bevált gyakorlatokat, írjon egységteszteket és dokumentálja a kódját, hogy biztosítsa az egyéni transzformerek megbízhatóságát és karbantarthatóságát. Ahogy fejleszti gépi tanulási készségeit, az egyéni transzformerek fejlesztésének elsajátítása felbecsülhetetlen értékűvé válik a komplex és változatos valós problémák megoldásában szerte a világon. A nemzetközi e-kereskedelem pénznem-átváltásainak kezelésétől az IoT-eszközök szenzoradatainak feldolgozásáig világszerte, az egyéni transzformerek képessé teszik Önt arra, hogy adatfolyamait az adatai és alkalmazásai specifikus igényeihez igazítsa.