உங்கள் இயந்திர கற்றல் பணிப்பாய்வுகளை ஒழுங்குபடுத்த ஸ்கிட்-லேர்ன் பைப்லைன்களைப் பயன்படுத்தவும். வலுவான, மறுஉருவாக்கக்கூடிய மற்றும் உற்பத்திக்குத் தயாரான மாதிரிகளுக்கான தரவு முன்தயாரிப்பு, மாதிரி பயிற்சி மற்றும் அதிபரப்பளவு சரிப்படுத்தும் முறைகளை தானியக்கமாக்க கற்றுக்கொள்ளுங்கள்.
ஸ்கிட்-லேர்ன் பைப்லைன்: ML பணிப்பாய்வு தன்னியக்கத்திற்கான இறுதி வழிகாட்டி
இயந்திர கற்றல் உலகில், ஒரு மாதிரியை உருவாக்குவது பெரும்பாலும் கவர்ச்சிகரமான இறுதிப் படியாகச் சித்தரிக்கப்படுகிறது. இருப்பினும், அனுபவம் வாய்ந்த தரவு விஞ்ஞானிகள் மற்றும் ML பொறியாளர்கள் உறுதியான மாதிரிக்குச் செல்லும் பயணம் முக்கியமான, அடிக்கடி மீண்டும் மீண்டும் செய்யக்கூடிய மற்றும் பிழைகள் ஏற்பட வாய்ப்புள்ள படிகளால் ஆனது என்பதை அறிவார்கள்: தரவு சுத்தம் செய்தல், அம்சம் அளவிடுதல், வகை மாறி குறியாக்கம் மற்றும் பல. பயிற்சி, சரிபார்த்தல் மற்றும் சோதனை ஆகியவற்றுக்கான ஒவ்வொரு அடியையும் தனித்தனியாக நிர்வகிப்பது விரைவாக ஒரு தளவாட பேரழிவாக மாறி, நுட்பமான பிழைகளுக்கு வழிவகுக்கும், மேலும் மிகவும் ஆபத்தானது, தரவு கசிவு.
இங்குதான் ஸ்கிட்-லேர்னின் பைப்லைன் மீட்புக்கு வருகிறது. இது ஒரு வசதி மட்டுமல்ல; தொழில்முறை, மறுஉருவாக்கக்கூடிய மற்றும் உற்பத்திக்குத் தயாரான இயந்திர கற்றல் அமைப்புகளை உருவாக்குவதற்கான ஒரு அடிப்படை கருவியாகும். இந்த விரிவான வழிகாட்டி, ஸ்கிட்-லேர்ன் பைப்லைன்களைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தையும், அடிப்படை கருத்துகள் முதல் மேம்பட்ட நுட்பங்கள் வரை உங்களுக்கு வழிகாட்டும்.
சிக்கல்: கையேடு இயந்திர கற்றல் பணிப்பாய்வு
ஒரு பொதுவான மேற்பார்வையிடப்பட்ட கற்றல் பணியைக் கருத்தில் கொள்வோம். நீங்கள் model.fit() ஐ அழைப்பதற்கு முன்பே, உங்கள் தரவை நீங்கள் தயார் செய்ய வேண்டும். ஒரு நிலையான பணிப்பாய்வு இப்படி இருக்கலாம்:
- தரவைப் பிரிக்கவும்: பயிற்சி மற்றும் சோதனைத் தொகுப்புகளாக உங்கள் தரவுத்தொகுப்பைப் பிரிக்கவும். கண்ணுக்குத் தெரியாத தரவுகளில் உங்கள் மாதிரியின் செயல்திறனை மதிப்பிட முடியும் என்பதை உறுதி செய்வதற்கான முதல் மற்றும் மிக முக்கியமான படி இது.
- விடுபட்ட மதிப்புகளைக் கையாளவும்: உங்கள் பயிற்சித் தொகுப்பில் விடுபட்ட தரவை அடையாளம் கண்டு நிரப்பவும் (எ.கா., சராசரி, இடைநிலை அல்லது ஒரு மாறிலியைப் பயன்படுத்தி).
- வகை அம்சங்களைக் குறியாக்கம் செய்யுங்கள்: 'நாடு' அல்லது 'தயாரிப்பு வகை' போன்ற எண்ணியல் அல்லாத நெடுவரிசைகளை ஒன்-ஹாட் என்கோடிங் அல்லது ஆர்டினல் என்கோடிங் போன்ற நுட்பங்களைப் பயன்படுத்தி எண்ணியல் வடிவமாக மாற்றவும்.
- எண்ணியல் அம்சங்களை அளவிடவும்: தரப்படுத்தல் (
StandardScaler) அல்லது இயல்பாக்கம் (MinMaxScaler) போன்ற முறைகளைப் பயன்படுத்தி அனைத்து எண்ணியல் அம்சங்களையும் ஒரே மாதிரியான அளவிற்குக் கொண்டு வாருங்கள். SVMகள், லாஜிஸ்டிக் பின்னடைவு மற்றும் நரம்பியல் வலைப்பின்னல்கள் போன்ற பல வழிமுறைகளுக்கு இது மிகவும் முக்கியமானது. - மாதிரிக்கு பயிற்சி அளிக்கவும்: இறுதியாக, முன்தயாரிப்பு செய்யப்பட்ட பயிற்சித் தரவுகளில் நீங்கள் தேர்ந்தெடுத்த இயந்திர கற்றல் மாதிரிக்கு பொருத்தவும்.
இப்போது, உங்கள் சோதனைத் தொகுப்பில் (அல்லது புதிய, பார்க்கப்படாத தரவு) கணிப்புகளைச் செய்ய விரும்பினால், நீங்கள் அதே முன்தயாரிப்பு படிகளை மீண்டும் செய்ய வேண்டும். நீங்கள் அதே நிரப்புதல் உத்தியைப் பயன்படுத்த வேண்டும் (பயிற்சித் தொகுப்பிலிருந்து கணக்கிடப்பட்ட மதிப்பை பயன்படுத்தி), அதே குறியாக்கத் திட்டம் மற்றும் அதே அளவீட்டு அளவுருக்கள். இந்த பொருத்தப்பட்ட அனைத்து மாற்றிகளையும் கைமுறையாக கண்காணிக்க வேண்டியது கடினமானது மற்றும் பிழைகளின் முக்கிய ஆதாரமாக உள்ளது.
இங்கு மிகப்பெரிய ஆபத்து தரவு கசிவு. சோதனைத் தொகுப்பிலிருந்து வரும் தகவல்கள் பயிற்சி செயல்முறையில் கவனக்குறைவாக கசியும்போது இது நிகழ்கிறது. எடுத்துக்காட்டாக, நீங்கள் பிரிக்கப்படுவதற்கு முன் முழு தரவுத்தொகுப்பிலிருந்தும் நிரப்புதல் அல்லது அளவீட்டு அளவுருக்களுக்கான சராசரியைக் கணக்கிட்டால், உங்கள் மாதிரி மறைமுகமாக சோதனைத் தரவிலிருந்து கற்றுக்கொள்கிறது. இது அதிகப்படியான நம்பிக்கையான செயல்திறன் மதிப்பீட்டிற்கும், உண்மையான உலகில் மோசமாக தோல்வியடையும் ஒரு மாதிரிக்கும் வழிவகுக்கிறது.
ஸ்கிட்-லேர்ன் பைப்லைன்களை அறிமுகப்படுத்துகிறோம்: தானியங்கி தீர்வு
ஸ்கிட்-லேர்ன் பைப்லைன் என்பது பல தரவு மாற்றும் படிகளையும் இறுதி மதிப்பீட்டாளரையும் (வகைப்படுத்தி அல்லது பின்னடைவு போன்றவை) ஒரு ஒருங்கிணைந்த பொருளாக சங்கிலியால் பிணைக்கும் ஒரு பொருளாகும். உங்கள் தரவுக்கான அசெம்பிளி லைனாக நீங்கள் இதைப் பற்றி நினைக்கலாம்.
நீங்கள் ஒரு பைப்லைனில் .fit() என்று அழைக்கும்போது, அது பயிற்சித் தரவுகளில் ஒவ்வொரு இடைநிலை படிக்கும் fit_transform() ஐ தொடர்ச்சியாகப் பயன்படுத்துகிறது, ஒரு படியின் வெளியீட்டை அடுத்த உள்ளீடாக அனுப்புகிறது. இறுதியாக, இது கடைசி படி, மதிப்பீட்டாளர் மீது .fit() ஐ அழைக்கிறது. நீங்கள் பைப்லைனில் .predict() அல்லது .transform() என்று அழைக்கும்போது, இறுதி மதிப்பீட்டாளருடன் கணிப்பு செய்வதற்கு முன், புதிய தரவுக்கு ஒவ்வொரு இடைநிலை படியின் .transform() முறையை மட்டுமே இது பயன்படுத்துகிறது.
பைப்லைன்களைப் பயன்படுத்துவதன் முக்கிய நன்மைகள்
- தரவு கசிவு தடுப்பு: இது மிகவும் முக்கியமான நன்மை. பைப்லைனுக்குள் அனைத்து முன்தயாரிப்பையும் உள்ளடக்குவதன் மூலம், குறுக்கு-சரிபார்ப்பின்போது பயிற்சித் தரவிலிருந்து மட்டுமே மாற்றங்கள் கற்றுக்கொள்ளப்படுவதையும், சரிபார்த்தல்/சோதனைத் தரவில் சரியாகப் பயன்படுத்தப்படுவதையும் உறுதி செய்கிறீர்கள்.
- எளிமை மற்றும் அமைப்பு: மூல தரவிலிருந்து பயிற்சி பெற்ற மாதிரி வரை உங்கள் முழு பணிப்பாய்வும் ஒரு பொருளாக சுருக்கப்படுகிறது. இது உங்கள் குறியீட்டை சுத்தமாகவும், படிக்கக்கூடியதாகவும், நிர்வகிக்க எளிதாகவும் ஆக்குகிறது.
- மறுஉருவாக்கம்: பைப்லைன் ஆப்ஜெக்ட் உங்கள் முழு மாதிரி செயல்முறையையும் உள்ளடக்குகிறது. இந்த ஒரு பொருளை எளிதாகச் சேமிக்கலாம் (எ.கா., `joblib` அல்லது `pickle` ஐப் பயன்படுத்தி) மேலும் கணிப்புகளைச் செய்ய பின்னர் அதை ஏற்றலாம், ஒவ்வொரு முறையும் அதே படிகள் பின்பற்றப்படுவதை உறுதி செய்கிறது.
- கிரிட் தேடலில் திறன்: முன்தயாரிப்பு படிகள் மற்றும் இறுதி மாதிரி ஆகிய இரண்டிற்கும் சிறந்த அளவுருக்களை ஒரே நேரத்தில் கண்டறிந்து, முழு பைப்லைன் முழுவதும் ஒரே நேரத்தில் அதிபரப்பளவு சரிசெய்தலை நீங்கள் செய்யலாம். இந்த சக்திவாய்ந்த அம்சத்தை பின்னர் ஆராய்வோம்.
உங்களின் முதல் எளிய பைப்லைனை உருவாக்குதல்
ஒரு அடிப்படை எடுத்துக்காட்டுடன் ஆரம்பிக்கலாம். எங்களிடம் ஒரு எண்ணியல் தரவுத்தொகுப்பு உள்ளது என்றும், ஒரு லாஜிஸ்டிக் பின்னடைவு மாதிரிக்கு பயிற்சி அளிப்பதற்கு முன் தரவை அளவிட விரும்புகிறோம் என்றும் கற்பனை செய்து பாருங்கள். அதற்காக நீங்கள் ஒரு பைப்லைனை எவ்வாறு உருவாக்குவீர்கள் என்பது இங்கே.
முதலில், எங்கள் சூழலை அமைத்து சில மாதிரி தரவை உருவாக்கலாம்.
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)
இப்போது, எங்கள் பைப்லைனை வரையறுப்போம். படிகளின் பட்டியலை வழங்குவதன் மூலம் ஒரு பைப்லைன் உருவாக்கப்படுகிறது. ஒவ்வொரு அடியும் ஒரு பெயர் (நீங்கள் விரும்பும் சரம்) மற்றும் மாற்றும் அல்லது மதிப்பீட்டுப் பொருள் ஆகியவற்றை உள்ளடக்கிய ஒரு tuple ஆகும்.
# 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}")
அவ்வளவுதான்! சில வரிகளில், அளவிடுதல் மற்றும் வகைப்படுத்துதலை இணைத்துள்ளோம். ஸ்கிட்-லேர்ன் அனைத்து இடைநிலை தர்க்கத்தையும் கையாளுகிறது. pipe.fit(X_train, y_train) என்று அழைக்கப்படும்போது, அது முதலில் StandardScaler().fit_transform(X_train) என்று அழைத்து, அதன் விளைவை LogisticRegression().fit() க்கு அனுப்புகிறது. pipe.predict(X_test) என்று அழைக்கப்படும்போது, அது லாஜிஸ்டிக் பின்னடைவு மாதிரியுடன் கணிப்புகளைச் செய்வதற்கு முன்பு StandardScaler().transform(X_test) ஐப் பயன்படுத்தி ஏற்கனவே பொருத்தப்பட்ட அளவை பயன்படுத்துகிறது.
மாறுபட்ட தரவைக் கையாளுதல்: `ColumnTransformer`
உண்மையான தரவுத்தொகுப்புகள் அரிதாகவே எளிமையானவை. அவை பெரும்பாலும் தரவு வகைகளின் கலவையைக் கொண்டிருக்கும்: அளவிடுவதற்குத் தேவையான எண்ணியல் நெடுவரிசைகள், குறியாக்கத் தேவையான வகை நெடுவரிசைகள், மற்றும் வெக்டரைசேஷன் செய்ய வேண்டிய உரை நெடுவரிசைகள். இதற்காக ஒரு எளிய தொடர்ச்சியான பைப்லைன் போதுமானதாக இல்லை, ஏனெனில் நீங்கள் வெவ்வேறு நெடுவரிசைகளுக்கு வெவ்வேறு மாற்றங்களைப் பயன்படுத்த வேண்டும்.
இங்குதான் ColumnTransformer பிரகாசிக்கிறது. உங்கள் தரவின் வெவ்வேறு துணைக்குழுக்களில் வெவ்வேறு மாற்றிகளைப் பயன்படுத்தவும், பின்னர் முடிவுகளை அறிவார்ந்த முறையில் இணைக்கவும் இது உங்களை அனுமதிக்கிறது. பெரிய பைப்லைனில் முன்தயாரிப்பு அடியாகப் பயன்படுத்த இது சரியான கருவியாகும்.
எடுத்துக்காட்டு: எண்ணியல் மற்றும் வகை அம்சங்களை இணைத்தல்
பாண்டாஸைப் பயன்படுத்தி எண்ணியல் மற்றும் வகை அம்சங்களுடன் கூடிய யதார்த்தமான தரவுத்தொகுப்பை உருவாக்குவோம்.
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']
எங்கள் முன்தயாரிப்பு உத்தி பின்வருமாறு இருக்கும்:
- எண்ணியல் நெடுவரிசைகளுக்கு (
age,salary): விடுபட்ட மதிப்புகளை இடைநிலையுடன் நிரப்பவும், பின்னர் அவற்றை அளவிடவும். - வகை நெடுவரிசைகளுக்கு (
country): விடுபட்ட மதிப்புகளை அடிக்கடி வரும் வகையுடன் நிரப்பவும், பின்னர் ஒரு-ஹாட் குறியாக்கம் செய்யவும்.
இந்த படிகளை இரண்டு தனி மினி-பைப்லைன்களைப் பயன்படுத்தி வரையறுக்கலாம்.
# 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'))
])
இப்போது, இந்த பைப்லைன்களை சரியான நெடுவரிசைகளுக்குப் பயன்படுத்த `ColumnTransformer` ஐப் பயன்படுத்துகிறோம்.
# Create the preprocessor with ColumnTransformer
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numerical_features),
('cat', categorical_transformer, categorical_features)
])
`ColumnTransformer` `transformers` பட்டியலை எடுக்கும். ஒவ்வொரு மாற்றியும் ஒரு பெயர், மாற்றும் பொருள் (அது ஒரு பைப்லைனாக இருக்கலாம்), மற்றும் அதைப் பயன்படுத்த வேண்டிய நெடுவரிசை பெயர்களின் பட்டியலைக் கொண்ட ஒரு tuple ஆகும்.
இறுதியாக, இந்த `preprocessor` ஐ எங்கள் பிரதான பைப்லைனில் முதல் படியாக வைக்கலாம், அதைத் தொடர்ந்து எங்கள் இறுதி மதிப்பீட்டாளர்.
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)
இந்த சிக்கலான பணிப்பாய்வை இது எவ்வளவு நேர்த்தியாகக் கையாள்கிறது என்பதை கவனியுங்கள். `OneHotEncoder` இல் உள்ள `handle_unknown='ignore'` அளவுரு உற்பத்தி அமைப்புகளுக்கு மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் தரவில் புதிய, பார்க்கப்படாத வகைகள் தோன்றும்போது அது பிழைகளைத் தடுக்கிறது.
மேம்பட்ட பைப்லைன் நுட்பங்கள்
பைப்லைன்கள் இன்னும் அதிக சக்தி மற்றும் நெகிழ்வுத்தன்மையை வழங்குகின்றன. தொழில்முறை இயந்திர கற்றல் திட்டங்களுக்கு அவசியமான சில மேம்பட்ட அம்சங்களை ஆராய்வோம்.
தனிப்பயன் மாற்றிகளை உருவாக்குதல்
சில நேரங்களில், உள்ளமைக்கப்பட்ட ஸ்கிட்-லேர்ன் மாற்றிகள் போதுமானதாக இல்லை. நீங்கள் ஒரு அம்சத்தின் மடக்கையை பிரித்தெடுப்பது அல்லது இரண்டு அம்சங்களை ஒரு புதிய அம்சமாக இணைப்பது போன்ற டொமைன்-குறிப்பிட்ட மாற்றத்தை நீங்கள் செய்ய வேண்டியிருக்கலாம். பைப்லைனில் தடையின்றி ஒருங்கிணைக்கும் உங்கள் சொந்த தனிப்பயன் மாற்றிகளை நீங்கள் எளிதாக உருவாக்கலாம்.
இதைச் செய்ய, `BaseEstimator` மற்றும் `TransformerMixin` ஆகியவற்றிலிருந்து பெறப்பட்ட ஒரு வகுப்பை உருவாக்குகிறீர்கள். நீங்கள் `fit()` மற்றும் `transform()` முறைகளை மட்டுமே செயல்படுத்த வேண்டும் (மேலும் தேவைப்பட்டால் `__init__()`).
`சம்பளம்` மற்றும் `வயது` விகிதத்தை புதிய அம்சமாகச் சேர்க்கும் ஒரு மாற்றியை உருவாக்குவோம்.
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
இந்த தனிப்பயன் மாற்றியை உங்கள் எண்ணியல் செயலாக்க பைப்லைனில் நீங்கள் செருகலாம்:
numeric_transformer_with_custom = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')),
('ratio_adder', FeatureRatioAdder()), # Our custom transformer
('scaler', StandardScaler())
])
இந்த அளவிலான தனிப்பயனாக்கம் உங்கள் அம்சம் பொறியியல் தர்க்கத்தை பைப்லைனுக்குள் உள்ளடக்க அனுமதிக்கிறது, இது உங்கள் பணிப்பாய்வை மிகவும் சிறியதாகவும் மீண்டும் உருவாக்கக்கூடியதாகவும் ஆக்குகிறது.
`GridSearchCV` ஐப் பயன்படுத்தி பைப்லைன்களுடன் அதிபரப்பளவு சரிசெய்தல்
பைப்லைன்களின் மிகவும் சக்திவாய்ந்த பயன்பாடுகளில் இதுவும் ஒன்றாகும். முன்தயாரிப்பு படிகள் மற்றும் இறுதி மாதிரி உட்பட, உங்கள் முழு பணிப்பாய்விற்கான சிறந்த அதிபரப்புகளை நீங்கள் ஒரே நேரத்தில் தேடலாம்.
எந்த அளவுருக்களை சரிசெய்ய வேண்டும் என்பதைக் குறிப்பிட, நீங்கள் ஒரு சிறப்பு தொடரியலைப் பயன்படுத்துகிறீர்கள்: `step_name__parameter_name`.
எங்கள் முந்தைய எடுத்துக்காட்டை விரிவுபடுத்தி, எங்கள் முன்தயாரிப்பில் உள்ள நிரப்பியின் அதிபரப்புகளையும் `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))
`param_grid` இல் உள்ள விசைகளை உன்னிப்பாகப் பாருங்கள்:
'preprocessor__num__imputer__strategy': இது `preprocessor` என்ற பெயரிடப்பட்ட `ColumnTransformer` இன் உள்ளே உள்ள `num` என்ற எண்ணியல் பைப்லைனுக்குள் பெயரிடப்பட்ட `imputer` என்ற `SimpleImputer` படியின் `strategy` அளவுருவை இலக்காகக் கொண்டுள்ளது.'classifier__n_estimators': இது `classifier` என்ற பெயரிடப்பட்ட இறுதி மதிப்பீட்டாளரின் `n_estimators` அளவுருவை இலக்காகக் கொண்டுள்ளது.
இதைச் செய்வதன் மூலம், `GridSearchCV` அனைத்து சேர்க்கைகளையும் சரியாக முயற்சித்து, முழு பணிப்பாய்வுக்கும் உகந்த அளவுருக்களைக் கண்டறிந்து, சரிப்படுத்தும் செயல்பாட்டின் போது தரவு கசிவைத் தடுக்கிறது, ஏனெனில் அனைத்து முன்தயாரிப்புகளும் ஒவ்வொரு குறுக்கு-சரிபார்ப்பு மடிப்புகளுக்குள் செய்யப்படுகின்றன.
உங்கள் பைப்லைனை காட்சிப்படுத்துதல் மற்றும் ஆய்வு செய்தல்
சிக்கலான பைப்லைன்களை நியாயப்படுத்துவது கடினம். ஸ்கிட்-லேர்ன் அவற்றைக் காட்சிப்படுத்த ஒரு சிறந்த வழியை வழங்குகிறது. பதிப்பு 0.23 இலிருந்து தொடங்கி, நீங்கள் ஒரு ஊடாடும் HTML பிரதிநிதித்துவத்தைப் பெறலாம்.
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
இது ஒவ்வொரு மாற்றி மற்றும் மதிப்பீட்டாளர் வழியாக தரவு ஓட்டத்தை அவற்றின் பெயர்களுடன் காட்டும் ஒரு வரைபடத்தை உருவாக்கும். பிழைகளை சரிசெய்வதற்கும், உங்கள் வேலையைப் பகிர்வதற்கும், உங்கள் மாதிரியின் கட்டமைப்பைப் புரிந்துகொள்வதற்கும் இது நம்பமுடியாத அளவிற்கு பயனுள்ளதாக இருக்கும்.
பொருத்தப்பட்ட பைப்லைனின் தனிப்பட்ட படிகளையும் அவற்றின் பெயர்களைப் பயன்படுத்தி அணுகலாம்:
# 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_)
பொதுவான ஆபத்துகள் மற்றும் சிறந்த நடைமுறைகள்
- தவறான தரவில் பொருத்துதல்: எப்போதும், உங்கள் பைப்லைனை பயிற்சித் தரவில் மட்டுமே பொருத்தவும். முழு தரவுத்தொகுப்பு அல்லது சோதனைத் தொகுப்பில் ஒருபோதும் பொருத்த வேண்டாம். தரவு கசிவைத் தடுப்பதற்கான கார்டினல் விதி இது.
- தரவு வடிவங்கள்: ஒவ்வொரு படியும் எதிர்பார்க்கும் தரவு வடிவத்தை கவனத்தில் கொள்ளுங்கள். சில மாற்றிகள் (எங்கள் தனிப்பயன் எடுத்துக்காட்டில் உள்ளவை போன்றவை) NumPy வரிசைகளுடன் வேலை செய்யலாம், மற்றவை Pandas DataFrames உடன் மிகவும் வசதியானவை. ஸ்கிட்-லேர்ன் இதை பொதுவாகக் கையாள்வதில் நல்லது, ஆனால் இது குறிப்பாக தனிப்பயன் மாற்றிகளுடன் கவனிக்க வேண்டிய ஒன்று.
- பைப்லைன்களைச் சேமித்து ஏற்றுதல்: உங்கள் மாதிரியை வரிசைப்படுத்த, பொருத்தப்பட்ட பைப்லைனைச் சேமிக்க வேண்டும். பைதான் சுற்றுச்சூழல் அமைப்பில் இதைச் செய்வதற்கான நிலையான வழி `joblib` அல்லது `pickle` உடன் உள்ளது. பெரிய NumPy வரிசைகளைக் கொண்டிருக்கும் பொருட்களுக்கு `joblib` பெரும்பாலும் மிகவும் திறமையானது.
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) - விளக்கமான பெயர்களைப் பயன்படுத்தவும்: உங்கள் பைப்லைன் படிகளுக்கும் `ColumnTransformer` கூறுகளுக்கும் தெளிவான, விளக்கமான பெயர்களைக் கொடுங்கள் (எ.கா., 'numeric_imputer', 'categorical_encoder', 'svm_classifier'). இது உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாக ஆக்குகிறது மற்றும் அதிபரப்பளவு சரிசெய்தல் மற்றும் பிழைகளை சரிசெய்வதை எளிதாக்குகிறது.
முடிவு: தொழில்முறை ML க்கு ஏன் பைப்லைன்கள் பேச்சுவார்த்தைக்குட்பட்டவை அல்ல
ஸ்கிட்-லேர்ன் பைப்லைன்கள் சுத்தமான குறியீட்டை எழுதுவதற்கான ஒரு கருவி மட்டுமல்ல; அவை கையேடு, பிழை ஏற்பட வாய்ப்புள்ள ஸ்கிரிப்டிங்கிலிருந்து முறையான, வலுவான மற்றும் மீண்டும் உருவாக்கக்கூடிய இயந்திர கற்றல் அணுகுமுறைக்கு ஒரு முன்னுதாரண மாற்றத்தை பிரதிபலிக்கின்றன. அவை ஒலி ML பொறியியல் நடைமுறைகளின் முதுகெலும்பாக இருக்கின்றன.
பைப்லைன்களை ஏற்றுக்கொள்வதன் மூலம், நீங்கள் பெறுவது:
- உறுதியான தன்மை: இயந்திர கற்றல் திட்டங்களில் மிகவும் பொதுவான பிழை ஆதாரத்தை நீங்கள் நீக்குகிறீர்கள் - தரவு கசிவு.
- திறன்: அம்சம் பொறியியல் முதல் அதிபரப்பளவு சரிசெய்தல் வரை உங்கள் முழு பணிப்பாய்வையும் ஒரு ஒருங்கிணைந்த பிரிவாக ஒழுங்குபடுத்துகிறீர்கள்.
- மறுஉருவாக்கம்: உங்கள் முழு மாதிரி தர்க்கத்தையும் உள்ளடக்கிய ஒரு தொடர்ச்சியான பொருளை உருவாக்குகிறீர்கள், இது வரிசைப்படுத்தவும் பகிரவும் எளிதாக்குகிறது.
உண்மையான உலகில் நம்பகத்தன்மையுடன் செயல்படும் இயந்திர கற்றல் மாதிரிகளை உருவாக்குவதில் நீங்கள் தீவிரமாக இருந்தால், ஸ்கிட்-லேர்ன் பைப்லைன்களை தேர்ச்சி பெறுவது விருப்பமானது அல்ல - இது அவசியம். அவற்றை இன்றே உங்கள் திட்டங்களில் இணைக்கத் தொடங்குங்கள், மேலும் முன்னெப்போதையும் விட சிறந்த, நம்பகமான மாதிரிகளை வேகமாக உருவாக்குவீர்கள்.