Python Scikit-learn Vlastné Estimátory: Komplexný sprievodca implementáciou algoritmov

Scikit-learn je výkonná a široko používaná Python knižnica pre strojové učenie. Aj keď poskytuje rozsiahlu zbierku predpripravených algoritmov, existujú situácie, keď potrebujete implementovať svoje vlastné algoritmy. Našťastie, scikit-learn ponúka flexibilný rámec pre vytváranie vlastných estimátorov, ktorý vám umožňuje bezproblémovo integrovať vaše algoritmy do ekosystému scikit-learn. Tento komplexný sprievodca vás prevedie procesom vytvárania vlastných estimátorov, od pochopenia základov až po implementáciu pokročilých techník. Preskúmame aj príklady zo skutočného sveta, ktoré ilustrujú praktické aplikácie vlastných estimátorov.

Prečo vytvárať vlastné estimátory?

Predtým, ako sa ponoríme do podrobností implementácie, poďme pochopiť, prečo by ste mohli chcieť vytvárať vlastné estimátory:

• Implementácia nových algoritmov: Scikit-learn nepokrýva každý možný algoritmus strojového učenia. Ak ste vyvinuli nový algoritmus alebo chcete implementovať vedeckú štúdiu, vytvorenie vlastného estimátora je správny spôsob.
• Prispôsobenie existujúcich algoritmov: Možno budete chcieť upraviť existujúci algoritmus scikit-learn, aby lepšie vyhovoval vašim špecifickým potrebám. Vlastné estimátory vám umožňujú rozšíriť alebo prispôsobiť existujúce funkcie.
• Integrácia s externými knižnicami: Možno budete chcieť použiť algoritmy z iných Python knižníc, ktoré nie sú priamo kompatibilné so scikit-learn. Vlastné estimátory poskytujú most medzi týmito knižnicami a API scikit-learn.
• Zlepšenie opätovnej použiteľnosti kódu: Zapuzdrením vášho algoritmu do vlastného estimátora ho môžete ľahko opätovne použiť v rôznych projektoch a zdieľať ho s ostatnými.
• Vylepšenie integrácie potrubia: Vlastné estimátory sa bezproblémovo integrujú s potrubiami scikit-learn, čo vám umožňuje vytvárať komplexné pracovné postupy strojového učenia.

Pochopenie základov Scikit-learn Estimátorov

Vo svojej podstate je scikit-learn estimátor Python trieda, ktorá implementuje metódy fit a predict (a niekedy aj iné metódy ako transform alebo fit_transform). Tieto metódy definujú správanie estimátora počas trénovania a predikcie. Existujú dva hlavné typy estimátorov:

• Transformátory: Tieto estimátory transformujú dáta z jedného formátu do druhého. Príklady zahŕňajú StandardScaler, PCA a OneHotEncoder. Zvyčajne implementujú metódy fit a transform.
• Modely (Prediktory): Tieto estimátory sa učia model z dát a používajú ho na vytváranie predikcií. Príklady zahŕňajú LinearRegression, DecisionTreeClassifier a KMeans. Zvyčajne implementujú metódy fit a predict.

Oba typy estimátorov zdieľajú spoločné API, čo vám umožňuje používať ich zameniteľne v potrubiach a iných nástrojoch scikit-learn.

Vytvorenie jednoduchého vlastného transformátora

Začnime s jednoduchým príkladom vlastného transformátora. Tento transformátor bude škálovať každú funkciu o konštantný faktor. Tento transformátor je podobný ako `StandardScaler`, ale je jednoduchší a umožňuje špecifikovať vlastný škálovací faktor.

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

class FeatureScaler(BaseEstimator, TransformerMixin):
    def __init__(self, factor=1.0):
        self.factor = factor

    def fit(self, X, y=None):
        # No fitting needed for this transformer
        return self

    def transform(self, X):
        return X * self.factor

            

              
                Copy
              
            
          

Tu je rozpis kódu:

• Dedenie: Dedíme z BaseEstimator a TransformerMixin. BaseEstimator poskytuje základné funkcie ako get_params a set_params, zatiaľ čo TransformerMixin poskytuje predvolenú implementáciu fit_transform (ktorá volá fit a potom transform).
• __init__: Toto je konštruktor. Ako argument berie škálovací faktor a ukladá ho do atribútu self.factor. Je dôležité definovať parametre vášho estimátora v konštruktore.
• fit: Táto metóda sa volá na prispôsobenie transformátora k dátam. V tomto prípade sa nemusíme nič učiť z dát, takže jednoducho vrátime self. Argument y sa často nepoužíva pre transformátory, ale je potrebný pre kompatibilitu s API scikit-learn.
• transform: Táto metóda sa volá na transformáciu dát. Jednoducho vynásobíme každú funkciu škálovacím faktorom.

Teraz sa pozrime, ako používať tento vlastný transformátor:

            
# Example Usage
from sklearn.pipeline import Pipeline

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

# Create a FeatureScaler with a factor of 2
scaler = FeatureScaler(factor=2.0)

# Transform the data
X_transformed = scaler.transform(X)

print(X_transformed)
# Output:
# [[ 2.  4.]
#  [ 6.  8.]
#  [10. 12.]]

# Using in a pipeline
pipe = Pipeline([('scaler', FeatureScaler(factor=3.0))])
X_transformed_pipeline = pipe.fit_transform(X)
print(X_transformed_pipeline)
# Output:
# [[ 3.  6.]
#  [ 9. 12.]
#  [15. 18.]]

            

              
                Copy
              
            
          

Vytvorenie jednoduchého vlastného modelu (Prediktora)

Ďalej vytvorme jednoduchý vlastný model. Tento model bude predikovať priemer trénovacích dát pre všetky budúce predikcie. Aj keď to nie je obzvlášť užitočné, demonštruje to základnú štruktúru vlastného prediktora.

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

class MeanPredictor(BaseEstimator, RegressorMixin):
    def __init__(self):
        self.mean_ = None

    def fit(self, X, y):
        self.mean_ = np.mean(y)
        return self

    def predict(self, X):
        return np.full(X.shape[0], self.mean_)

            

              
                Copy
              
            
          

Tu je rozpis kódu:

• Dedenie: Dedíme z BaseEstimator a RegressorMixin. RegressorMixin poskytuje predvolené implementácie pre metódy súvisiace s regresiou (hoci ich v tomto príklade nepoužívame).
• __init__: Inicializujeme self.mean_ na None. Tento atribút bude ukladať priemer cieľovej premennej po prispôsobení.
• fit: Táto metóda vypočíta priemer cieľovej premennej y a uloží ho do self.mean_.
• predict: Táto metóda vráti pole rovnakej dĺžky ako vstup X, pričom každý prvok sa rovná uloženému priemeru.

Teraz sa pozrime, ako používať tento vlastný model:

            
# Example Usage
X = np.array([[1], [2], [3]])
y = np.array([10, 20, 30])

# Create a MeanPredictor
predictor = MeanPredictor()

# Fit the model
predictor.fit(X, y)

# Predict on new data
X_new = np.array([[4], [5], [6]])
y_pred = predictor.predict(X_new)

print(y_pred)
# Output:
# [20. 20. 20.]

            

              
                Copy
              
            
          

Implementácia overenia parametrov

Je dôležité overiť parametre odovzdané vašim vlastným estimátorom. Pomáha to predchádzať neočakávanému správaniu a poskytuje používateľom informatívne chybové správy. Môžete použiť funkciu check_estimator z sklearn.utils.estimator_checks na automatické testovanie vášho estimátora proti množine bežných kontrol.

Najprv upravme FeatureScaler tak, aby obsahoval overenie parametrov:

            
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.utils import validation

class FeatureScaler(BaseEstimator, TransformerMixin):
    def __init__(self, factor=1.0):
        self.factor = factor

    def fit(self, X, y=None):
        # Validate the input
        self.factor = validation.check_scalar(
            self.factor,
            'factor',
            target_type=float,
            min_val=0.0,
            include_boundaries=True
        )
        return self

    def transform(self, X):
        validation.check_is_fitted(self)
        X = validation.check_array(X)
        return X * self.factor

            

              
                Copy
              
            
          

Čo sme pridali:

• validation.check_scalar: Túto funkciu používame v metóde fit na overenie, či je parameter factor float väčší alebo rovný 0.
• validation.check_is_fitted: Túto funkciu používame v metóde `transform` na zabezpečenie, že estimátor bol prispôsobený pred transformáciou dát.
• validation.check_array: Túto funkciu používame na overenie, či je vstup `X` platné pole.

Teraz použime check_estimator na testovanie nášho estimátora:

            
from sklearn.utils.estimator_checks import check_estimator

# Perform checks
check_estimator(FeatureScaler)

            

              
                Copy
              
            
          

Ak sa vyskytnú nejaké problémy s vašim estimátorom (napr. nesprávne typy parametrov alebo chýbajúce metódy), check_estimator vyvolá chybu. Toto je výkonný nástroj na zabezpečenie, že vaše vlastné estimátory dodržiavajú API scikit-learn.

Spracovanie hyperparametrov pomocou GridSearchCV

Jednou z kľúčových výhod vytvárania vlastných estimátorov je, že ich môžete používať s nástrojmi na ladenie hyperparametrov scikit-learn, ako sú GridSearchCV a RandomizedSearchCV. Ak chcete, aby bol váš estimátor kompatibilný s týmito nástrojmi, musíte zabezpečiť, aby boli jeho parametre prístupné a modifikovateľné. Zvyčajne sa to rieši automaticky vďaka triede `BaseEstimator`.

Demonštrujme to pomocou FeatureScaler. Použijeme GridSearchCV na nájdenie optimálneho škálovacieho faktora:

            
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
import numpy as np

# Create a pipeline with the FeatureScaler
pipe = Pipeline([('scaler', FeatureScaler())])

# Define the parameter grid
param_grid = {'scaler__factor': [0.5, 1.0, 1.5, 2.0]}

# Create a GridSearchCV object
grid_search = GridSearchCV(pipe, param_grid, cv=3, scoring='r2') # Using R^2 as an example scoring metric.

# Generate some sample data
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]])
y = np.array([2, 4, 6, 8, 10])

# Fit the grid search
grid_search.fit(X, y)

# Print the best parameters and score
print("Best parameters:", grid_search.best_params_)
print("Best score:", grid_search.best_score_)

            

              
                Copy
              
            
          

V tomto príklade definujeme mriežku parametrov, ktorá určuje hodnoty parametra factor, ktoré sa majú prehľadať. GridSearchCV potom vyhodnotí potrubie s každou kombináciou parametrov a vráti najlepší výkon. Všimnite si konvenciu pomenúvania `scaler__factor` pre prístup k parametrom v rámci fázy potrubia.

Pokročilé techniky: Spracovanie komplexných typov dát a chýbajúcich hodnôt

Pozrime sa na príklad vlastného transformátora, ktorý imputuje chýbajúce hodnoty pomocou mediánu:

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

class MedianImputer(BaseEstimator, TransformerMixin):
    def __init__(self):
        self.median_ = None

    def fit(self, X, y=None):
        # Calculate the median for each column
        self.median_ = np.nanmedian(X, axis=0)
        return self

    def transform(self, X):
        # Impute missing values with the median
        X_imputed = np.where(np.isnan(X), self.median_, X)
        return X_imputed

            

              
                Copy
              
            
          

V tomto príklade metóda fit vypočíta medián pre každý stĺpec vo vstupných dátach, pričom ignoruje chýbajúce hodnoty (np.nan). Metóda transform potom nahradí všetky chýbajúce hodnoty vo vstupných dátach zodpovedajúcim mediánom.

Tu je návod, ako ho používať:

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

# Create a MedianImputer
imputer = MedianImputer()

# Fit the imputer
imputer.fit(X)

# Transform the data
X_imputed = imputer.transform(X)

print(X_imputed)
# Output:
# [[1.  2.  5.5]
#  [3.  4.  5. ]
#  [2.  4.  6. ]]

            

              
                Copy
              
            
          

Príklady a prípady použitia zo skutočného sveta

Preskúmajme niektoré príklady zo skutočného sveta, kde môžu byť vlastné estimátory obzvlášť užitočné:

• Inžinierstvo funkcií časových radov: Možno budete chcieť vytvoriť vlastný transformátor, ktorý extrahuje funkcie z dát časových radov, ako sú rollingové štatistiky alebo oneskorené hodnoty. Napríklad na finančných trhoch môžete vytvoriť estimátor, ktorý vypočíta pohyblivý priemer a štandardnú odchýlku cien akcií v špecifickom okne. Tento estimátor sa potom môže použiť v potrubí na predikciu budúcich cien akcií. Veľkosť okna by mohla byť hyperparameter naladený pomocou `GridSearchCV`.
• Spracovanie prirodzeného jazyka (NLP): Mohli by ste vytvoriť vlastný transformátor, ktorý vykonáva čistenie textu alebo extrakciu funkcií pomocou techník, ktoré nie sú priamo dostupné v scikit-learn. Napríklad môžete chcieť implementovať vlastný stemmer alebo lemmatizer prispôsobený špecifickému jazyku alebo doméne. Môžete tiež integrovať externé knižnice ako NLTK alebo spaCy do vášho vlastného estimátora.
• Spracovanie obrazu: Možno budete chcieť vytvoriť vlastný transformátor, ktorý aplikuje špecifické operácie spracovania obrazu, ako je filtrovanie alebo detekcia hrán, predtým, ako sa obrazy vložia do modelu strojového učenia. Mohlo by to zahŕňať integráciu s knižnicami ako OpenCV alebo scikit-image. Napríklad estimátor by mohol normalizovať jas a kontrast lekárskych obrazov pred trénovaním modelu na detekciu nádorov.
• Odporúčacie systémy: Môžete vytvoriť vlastný estimátor, ktorý implementuje algoritmy kolaboratívneho filtrovania, ako je maticová faktorizácia, na generovanie personalizovaných odporúčaní. Mohlo by to zahŕňať integráciu s knižnicami ako Surprise alebo implicit. Napríklad systém odporúčania filmov by mohol použiť vlastný estimátor na predikciu hodnotení používateľov na základe ich minulých preferencií a hodnotení iných používateľov.
• Analýza geopriestorových dát: Vytvorte vlastné transformátory na prácu s dátami o polohe. To môže zahŕňať výpočet vzdialeností medzi bodmi, vykonávanie priestorových spojení alebo extrahovanie funkcií z geografických tvarov. Napríklad by ste mohli vypočítať vzdialenosť každého zákazníka od najbližšej predajne, aby ste informovali o marketingových stratégiách.

Osvedčené postupy pre vytváranie vlastných estimátorov

Ak chcete zabezpečiť, aby boli vaše vlastné estimátory robustné, udržiavateľné a kompatibilné so scikit-learn, postupujte podľa týchto osvedčených postupov:

• Dediť z BaseEstimator a príslušného Mixinu: To poskytuje základnú funkčnosť a zabezpečuje kompatibilitu s API scikit-learn.
• Implementovať __init__, fit a transform (alebo predict): Tieto metódy sú jadrom vášho estimátora.
• Overiť vstupné parametre: Použite sklearn.utils.validation na overenie parametrov odovzdaných vášmu estimátoru.
• Správne spracovať chýbajúce hodnoty: Rozhodnite sa, ako by mal váš estimátor spracovávať chýbajúce hodnoty, a implementujte príslušnú logiku.
• Dokumentujte svoj kód: Poskytnite jasnú a stručnú dokumentáciu pre váš estimátor, vrátane jeho účelu, parametrov a použitia. Používajte docstringy dodržiavajúce konvenciu NumPy/SciPy pre konzistentnosť.
• Testujte svoj kód: Použite sklearn.utils.estimator_checks na testovanie vášho estimátora proti množine bežných kontrol. Napíšte tiež jednotkové testy na overenie, či váš estimátor funguje správne.
• Dodržiavajte konvencie Scikit-learn: Dodržiavajte štýl kódovania a API konvencie scikit-learn, aby ste zabezpečili konzistentnosť a udržiavateľnosť.
• Zvážte použitie dekorátorov: Keď je to vhodné, použite dekorátory ako @validate_arguments z knižníc ako `typing-extensions` na zjednodušenie overenia parametrov.

Záver

Nezabudnite dôkladne testovať a dokumentovať svoje vlastné estimátory, aby ste zabezpečili ich kvalitu a použiteľnosť. S pevným pochopením API scikit-learn a trochou kreativity môžete využiť vlastné estimátory na vytváranie sofistikovaných riešení strojového učenia prispôsobených vašim špecifickým potrebám. Veľa šťastia!