Scikit-learn Pipeline: Galvenais ceļvedis ML darbplūsmas automatizācijā

Mašīnmācīšanās pasaulē modeļa izveide bieži tiek attēlota kā krāšņs pēdējais solis. Tomēr pieredzējuši datu zinātnieki un ML inženieri zina, ka ceļš uz robustu modeli ir bruģēts ar virkni būtisku, bieži vien atkārtotu un kļūdām pakļautu soļu: datu tīrīšana, pazīmju mērogošana, kategorisko mainīgo kodēšana un daudz kas cits. Šo soļu individuāla pārvaldīšana apmācības, validācijas un testēšanas datu kopām var ātri kļūt par loģistikas murgu, kas noved pie nemanāmām kļūdām un, kas ir visbīstamāk, pie datu noplūdes.

Šeit nāk palīgā Scikit-learn Pipeline. Tā nav tikai ērtība; tas ir fundamentāls rīks profesionālu, reproducējamu un ražošanai gatavu mašīnmācīšanās sistēmu veidošanai. Šis visaptverošais ceļvedis jūs iepazīstinās ar visu, kas jums jāzina, lai apgūtu Scikit-learn Pipelines, sākot no pamatjēdzieniem līdz pat progresīvām tehnikām.

Problēma: manuāla mašīnmācīšanās darbplūsma

Apskatīsim tipisku uzraudzītās mācīšanās uzdevumu. Pirms jūs pat varat izsaukt model.fit(), jums ir jāsagatavo dati. Standarta darbplūsma varētu izskatīties šādi:

1. Datu sadalīšana: Sadaliet savu datu kopu apmācības un testēšanas kopās. Šis ir pirmais un vissvarīgākais solis, lai nodrošinātu, ka varat novērtēt sava modeļa veiktspēju ar neredzētiem datiem.
2. Trūkstošo vērtību apstrāde: Identificējiet un aizpildiet trūkstošos datus savā apmācības kopā (piemēram, izmantojot vidējo, mediānu vai konstanti).
3. Kategorisko pazīmju kodēšana: Pārveidojiet nenumeriskas kolonnas, piemēram, 'Valsts' vai 'Produkta kategorija', skaitliskā formātā, izmantojot tādas metodes kā One-Hot kodēšana vai Ordinālā kodēšana.
4. Skaitlisko pazīmju mērogošana: Pielāgojiet visas skaitliskās pazīmes līdzīgam mērogam, izmantojot tādas metodes kā standartizācija (StandardScaler) vai normalizācija (MinMaxScaler). Tas ir būtiski daudziem algoritmiem, piemēram, SVM, loģistiskajai regresijai un neironu tīkliem.
5. Modeļa apmācība: Visbeidzot, apmāciet savu izvēlēto mašīnmācīšanās modeli ar iepriekš apstrādātajiem apmācības datiem.

Tagad, kad vēlaties veikt prognozes ar savu testa kopu (vai jauniem, neredzētiem datiem), jums ir jāatkārto tieši tie paši priekšapstrādes soļi. Jums ir jāpiemēro tā pati aizpildīšanas stratēģija (izmantojot vērtību, kas aprēķināta no apmācības kopas), tā pati kodēšanas shēma un tie paši mērogošanas parametri. Manuāla visu šo apmācīto transformatoru uzskaite ir nogurdinoša un galvenais kļūdu avots.

Lielākais risks šeit ir datu noplūde. Tā notiek, kad informācija no testa kopas nejauši nonāk apmācības procesā. Piemēram, ja jūs aprēķināt vidējo vērtību aizpildīšanai vai mērogošanas parametrus no visas datu kopas pirms sadalīšanas, jūsu modelis netieši mācās no testa datiem. Tas noved pie pārāk optimistiska veiktspējas novērtējuma un modeļa, kas reālajā pasaulē cieš neveiksmi.

Iepazīstinām ar Scikit-learn Pipelines: automatizēts risinājums

Scikit-learn Pipeline ir objekts, kas savieno vairākus datu transformācijas soļus un galīgo novērtētāju (piemēram, klasifikatoru vai regresoru) vienā, vienotā objektā. Jūs varat to iedomāties kā montāžas līniju saviem datiem.

Kad jūs izsaucat .fit() uz Pipeline, tas secīgi piemēro fit_transform() katram starpposma solim uz apmācības datiem, nododot viena soļa izvadi kā nākama soļa ievadi. Visbeidzot, tas izsauc .fit() uz pēdējā soļa, kas ir novērtētājs. Kad jūs izsaucat .predict() vai .transform() uz Pipeline, tas piemēro tikai .transform() metodi katram starpposma solim uz jaunajiem datiem, pirms veic prognozi ar galīgo novērtētāju.

Galvenās Pipelines izmantošanas priekšrocības

• Datu noplūdes novēršana: Šī ir vissvarīgākā priekšrocība. Iekapsulējot visu priekšapstrādi konveijerā, jūs nodrošināt, ka transformācijas tiek apgūtas tikai no apmācības datiem krusteniskās validācijas laikā un tiek pareizi piemērotas validācijas/testa datiem.
• Vienkāršība un organizētība: Visa jūsu darbplūsma, no neapstrādātiem datiem līdz apmācītam modelim, ir apvienota vienā objektā. Tas padara jūsu kodu tīrāku, lasāmāku un vieglāk pārvaldāmu.
• Reproducējamība: Pipeline objekts iekapsulē visu jūsu modelēšanas procesu. Jūs varat viegli saglabāt šo vienu objektu (piemēram, izmantojot `joblib` vai `pickle`) un vēlāk to ielādēt, lai veiktu prognozes, nodrošinot, ka katru reizi tiek ievēroti tieši tie paši soļi.
• Efektivitāte režģa meklēšanā (Grid Search): Jūs varat veikt hiperparametru pielāgošanu visā konveijerā vienlaicīgi, atrodot labākos parametrus gan priekšapstrādes soļiem, gan galīgajam modelim. Mēs izpētīsim šo spēcīgo funkciju vēlāk.

Jūsu pirmā vienkāršā Pipeline izveide

Sāksim ar pamata piemēru. Iedomājieties, ka mums ir skaitliska datu kopa un mēs vēlamies mērogot datus pirms loģistiskās regresijas modeļa apmācības. Lūk, kā tam izveidot konveijeru.

Vispirms iestatīsim mūsu vidi un izveidosim dažus parauga datus.

            
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# Generate some sample data
X, y = np.random.rand(100, 5) * 10, (np.random.rand(100) > 0.5).astype(int)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

            

              
                Copy
              
            
          

Tagad definēsim mūsu konveijeru. Konveijers tiek izveidots, norādot soļu sarakstu. Katrs solis ir kortežs (tuple), kas satur nosaukumu (jūsu izvēlētu virkni) un pašu transformatora vai novērtētāja objektu.

            
# Create the pipeline steps
steps = [
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression())
]

# Create the Pipeline object
pipe = Pipeline(steps)

# Now, you can treat the 'pipe' object as if it were a regular model.
# Let's train it on our training data.
pipe.fit(X_train, y_train)

# Make predictions on the test data
y_pred = pipe.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
print(f"Pipeline Accuracy: {accuracy:.4f}")

            

              
                Copy
              
            
          

Tas arī viss! Tikai dažās rindiņās mēs esam apvienojuši mērogošanu un klasifikāciju. Scikit-learn apstrādā visu starpposma loģiku. Kad tiek izsaukts pipe.fit(X_train, y_train), tas vispirms izsauc StandardScaler().fit_transform(X_train) un pēc tam nodod rezultātu LogisticRegression().fit(). Kad tiek izsaukts pipe.predict(X_test), tas piemēro jau apmācīto mērogotāju, izmantojot StandardScaler().transform(X_test), pirms veic prognozes ar loģistiskās regresijas modeli.

Nehomogēnu datu apstrāde: ColumnTransformer

Reālās pasaules datu kopas reti ir vienkāršas. Tās bieži satur dažādu datu tipu sajaukumu: skaitliskas kolonnas, kurām nepieciešama mērogošana, kategoriskas kolonnas, kurām nepieciešama kodēšana, un varbūt teksta kolonnas, kurām nepieciešama vektorizācija. Vienkāršs secīgs konveijers tam nav pietiekams, jo jums ir jāpiemēro dažādas transformācijas dažādām kolonnām.

Šeit izceļas ColumnTransformer. Tas ļauj jums piemērot dažādus transformatorus dažādām datu kolonnu apakškopām un pēc tam gudri apvieno rezultātus. Tas ir ideāls rīks, ko izmantot kā priekšapstrādes soli lielākā konveijerā.

Piemērs: skaitlisko un kategorisko pazīmju apvienošana

Izveidosim reālistiskāku datu kopu ar gan skaitliskām, gan kategoriskām pazīmēm, izmantojot pandas.

            
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.impute import SimpleImputer

# Create a sample DataFrame
data = {
    'age': [25, 30, 45, 35, 50, np.nan, 22],
    'salary': [50000, 60000, 120000, 80000, 150000, 75000, 45000],
    'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA', 'UK'],
    'purchased': [0, 1, 1, 0, 1, 1, 0]
}
df = pd.DataFrame(data)

X = df.drop('purchased', axis=1)
y = df['purchased']

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

# Identify numerical and categorical columns
numerical_features = ['age', 'salary']
categorical_features = ['country']

            

              
                Copy
              
            
          

Mūsu priekšapstrādes stratēģija būs:

1. Skaitliskajām kolonnām (age, salary): Aizpildīt trūkstošās vērtības ar mediānu, pēc tam tās mērogot.
2. Kategoriskajām kolonnām (country): Aizpildīt trūkstošās vērtības ar visbiežāk sastopamo kategoriju, pēc tam tās kodēt ar one-hot metodi.

Mēs varam definēt šos soļus, izmantojot divus atsevišķus mini-konveijerus.

            
# Create a pipeline for numerical features
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# Create a pipeline for categorical features
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

            

              
                Copy
              
            
          

Tagad mēs izmantojam `ColumnTransformer`, lai piemērotu šos konveijerus pareizajām kolonnām.

            
# Create the preprocessor with ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numerical_features),
        ('cat', categorical_transformer, categorical_features)
    ])

            

              
                Copy
              
            
          

`ColumnTransformer` pieņem `transformers` sarakstu. Katrs transformators ir kortežs, kas satur nosaukumu, transformatora objektu (kas pats var būt konveijers) un kolonnu nosaukumu sarakstu, kuriem to piemērot.

Visbeidzot, mēs varam ievietot šo `preprocessor` kā pirmo soli mūsu galvenajā konveijerā, kam seko mūsu galīgais novērtētājs.

            
from sklearn.ensemble import RandomForestClassifier

# Create the full pipeline
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42))
])

# Train and evaluate the full pipeline
full_pipeline.fit(X_train, y_train)

print("Model score on test data:", full_pipeline.score(X_test, y_test))

# You can now make predictions on new raw data
new_data = pd.DataFrame({
    'age': [40, 28],
    'salary': [90000, 55000],
    'country': ['USA', 'Germany'] # 'Germany' is an unknown category
})

predictions = full_pipeline.predict(new_data)
print("Predictions for new data:", predictions)

            

              
                Copy
              
            
          

Ievērojiet, cik eleganti tas pārvalda sarežģītu darbplūsmu. Parametrs `handle_unknown='ignore'` `OneHotEncoder` ir īpaši noderīgs ražošanas sistēmām, jo tas novērš kļūdas, kad datos parādās jaunas, neredzētas kategorijas.

Progresīvas Pipeline tehnikas

Pipelines piedāvā vēl vairāk jaudas un elastības. Apskatīsim dažas progresīvas funkcijas, kas ir būtiskas profesionāliem mašīnmācīšanās projektiem.

Pielāgotu transformatoru izveide

Dažreiz ar iebūvētajiem Scikit-learn transformatoriem nepietiek. Jums varētu būt nepieciešams veikt domēnam specifisku transformāciju, piemēram, iegūt pazīmes logaritmu vai apvienot divas pazīmes jaunā. Jūs varat viegli izveidot savus pielāgotos transformatorus, kas nevainojami integrējas konveijerā.

Lai to izdarītu, jūs izveidojat klasi, kas manto no `BaseEstimator` un `TransformerMixin`. Jums ir jāimplementē tikai `fit()` un `transform()` metodes (un `__init__()`, ja nepieciešams).

Izveidosim transformatoru, kas pievieno jaunu pazīmi: `salary` un `age` attiecību.

            
from sklearn.base import BaseEstimator, TransformerMixin

# Define column indices (can also pass names)
age_ix, salary_ix = 0, 1

class FeatureRatioAdder(BaseEstimator, TransformerMixin):
    def __init__(self):
        pass # No parameters to set
    def fit(self, X, y=None):
        return self # Nothing to learn during fit, so just return self
    def transform(self, X):
        salary_age_ratio = X[:, salary_ix] / X[:, age_ix]
        return np.c_[X, salary_age_ratio] # Concatenate original X with new feature

            

              
                Copy
              
            
          

Jūs varētu ievietot šo pielāgoto transformatoru savā skaitlisko datu apstrādes konveijerā:

            
numeric_transformer_with_custom = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('ratio_adder', FeatureRatioAdder()), # Our custom transformer
    ('scaler', StandardScaler())
])

            

              
                Copy
              
            
          

Šis pielāgošanas līmenis ļauj jums iekapsulēt visu savu pazīmju inženierijas loģiku konveijerā, padarot jūsu darbplūsmu ārkārtīgi pārnēsājamu un reproducējamu.

Hiperparametru pielāgošana ar Pipelines, izmantojot `GridSearchCV`

Šis, iespējams, ir viens no jaudīgākajiem Pipelines pielietojumiem. Jūs varat meklēt labākos hiperparametrus visai savai darbplūsmai, ieskaitot priekšapstrādes soļus un galīgo modeli, visu uzreiz.

Lai norādītu, kurus parametrus pielāgot, jūs izmantojat īpašu sintaksi: `soļa_nosaukums__parametra_nosaukums`.

Paplašināsim mūsu iepriekšējo piemēru un pielāgosim hiperparametrus gan mūsu priekšapstrādātāja imputerim, gan `RandomForestClassifier`.

            
from sklearn.model_selection import GridSearchCV

# We use the 'full_pipeline' from the ColumnTransformer example

# Define the parameter grid
param_grid = {
    'preprocessor__num__imputer__strategy': ['mean', 'median'],
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [None, 10, 20],
    'classifier__min_samples_leaf': [1, 2, 4]
}

# Create the GridSearchCV object
grid_search = GridSearchCV(full_pipeline, param_grid, cv=5, verbose=1, n_jobs=-1)

# Fit it to the data
grid_search.fit(X_train, y_train)

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

# The best estimator is already refitted on the whole training data
best_model = grid_search.best_estimator_
print("Test set score with best model: ", best_model.score(X_test, y_test))

            

              
                Copy
              
            
          

Aplūkojiet uzmanīgi atslēgas `param_grid`:

• 'preprocessor__num__imputer__strategy': Tas mērķē uz `strategy` parametru `SimpleImputer` solim ar nosaukumu `imputer` iekš skaitliskā konveijera ar nosaukumu `num`, kas pats atrodas iekš `ColumnTransformer` ar nosaukumu `preprocessor`.
• 'classifier__n_estimators': Tas mērķē uz `n_estimators` parametru galīgajam novērtētājam ar nosaukumu `classifier`.

To darot, `GridSearchCV` pareizi izmēģina visas kombinācijas un atrod optimālo parametru kopu visai darbplūsmai, pilnībā novēršot datu noplūdi pielāgošanas procesa laikā, jo visa priekšapstrāde tiek veikta katrā krusteniskās validācijas solī.

Jūsu Pipeline vizualizēšana un pārbaude

Sarežģīti konveijeri var kļūt grūti saprotami. Scikit-learn nodrošina lielisku veidu, kā tos vizualizēt. Sākot ar versiju 0.23, jūs varat iegūt interaktīvu HTML attēlojumu.

            
from sklearn import set_config

# Set display to 'diagram' to get the visual representation
set_config(display='diagram')

# Now, simply displaying the pipeline object in a Jupyter Notebook or similar environment will render it
full_pipeline

            

              
                Copy
              
            
          

Tas ģenerēs diagrammu, kas parāda datu plūsmu caur katru transformatoru un novērtētāju, kopā ar to nosaukumiem. Tas ir neticami noderīgi atkļūdošanai, darba kopīgošanai un modeļa struktūras izpratnei.

Jūs varat arī piekļūt atsevišķiem apmācīta konveijera soļiem, izmantojot to nosaukumus:

            
# Access the final classifier of the fitted pipeline
final_classifier = full_pipeline.named_steps['classifier']
print("Feature importances:", final_classifier.feature_importances_)

# Access the OneHotEncoder to see the learned categories
onehot_encoder = full_pipeline.named_steps['preprocessor'].named_transformers_['cat'].named_steps['onehot']
print("Categorical features learned:", onehot_encoder.categories_)

            

              
                Copy
              
            
          

Biežākās kļūdas un labākās prakses

1. Apmācība ar nepareiziem datiem: Vienmēr, vienmēr apmāciet savu konveijeru TIKAI ar apmācības datiem. Nekad neapmāciet to ar pilnu datu kopu vai testa kopu. Tas ir galvenais noteikums, lai novērstu datu noplūdi.
2. Datu formāti: Pievērsiet uzmanību datu formātam, ko sagaida katrs solis. Daži transformatori (kā mūsu pielāgotajā piemērā) var strādāt ar NumPy masīviem, kamēr citi ir ērtāki ar Pandas DataFrames. Scikit-learn parasti labi tiek galā ar šo, bet tas ir kaut kas, par ko jābūt informētam, īpaši ar pielāgotiem transformatoriem.
3. Konveijeru saglabāšana un ielādēšana: Lai ieviestu savu modeli, jums būs jāsaglabā apmācītais konveijers. Standarta veids, kā to darīt Python ekosistēmā, ir ar `joblib` vai `pickle`. `joblib` bieži ir efektīvāks objektiem, kas satur lielus NumPy masīvus.

               
   import joblib
   
   # Save the pipeline
   joblib.dump(full_pipeline, 'my_model_pipeline.joblib')
   
   # Load the pipeline later
   loaded_pipeline = joblib.load('my_model_pipeline.joblib')
   
   # Make predictions with the loaded model
   loaded_pipeline.predict(new_data)
   
               
   
                 
                   Copy
                 
               
             

4. Izmantojiet aprakstošus nosaukumus: Piešķiriet saviem konveijera soļiem un `ColumnTransformer` komponentiem skaidrus, aprakstošus nosaukumus (piemēram, 'numeric_imputer', 'categorical_encoder', 'svm_classifier'). Tas padara jūsu kodu lasāmāku un vienkāršo hiperparametru pielāgošanu un atkļūdošanu.

Secinājums: Kāpēc Pipelines ir neaizstājamas profesionālā ML

Scikit-learn Pipelines nav tikai rīks tīrāka koda rakstīšanai; tās pārstāv paradigmas maiņu no manuālas, kļūdām pakļautas skriptēšanas uz sistemātisku, robustu un reproducējamu pieeju mašīnmācībai. Tās ir pamatīgas ML inženierijas prakses mugurkauls.

Pieņemot konveijerus, jūs iegūstat:

• Robustumu: Jūs novēršat visbiežāko kļūdu avotu mašīnmācīšanās projektos — datu noplūdi.
• Efektivitāti: Jūs optimizējat visu savu darbplūsmu, no pazīmju inženierijas līdz hiperparametru pielāgošanai, vienā, saskaņotā vienībā.
• Reproducējamību: Jūs izveidojat vienu, serializējamu objektu, kas satur visu jūsu modeļa loģiku, padarot to viegli izvietojamu un kopīgojamu.

Ja jūs nopietni domājat par mašīnmācīšanās modeļu veidošanu, kas uzticami darbojas reālajā pasaulē, Scikit-learn Pipelines apguve nav izvēles iespēja — tā ir būtiska. Sāciet tos iekļaut savos projektos jau šodien, un jūs veidosiet labākus, uzticamākus modeļus ātrāk nekā jebkad agrāk.