మెషీన్ లెర్నింగ్లో ఒక సామెత ఉంది: గార్బేజ్ ఇన్, గార్బేజ్ అవుట్. మీరు ప్రపంచంలోనే అత్యంత అధునాతన అల్గారిథమ్ని కలిగి ఉండవచ్చు, కానీ మీరు పేలవంగా తయారు చేయబడిన డేటాను అందించినట్లయితే, ఫలితాలు పేలవంగా ఉంటాయి. దీనికి విరుద్ధంగా, అద్భుతమైన, ఆలోచనాత్మకంగా తయారు చేయబడిన డేటా అందించబడిన ఒక సాధారణ అల్గారిథమ్ ముడి, గజిబిజి డేటా ఇచ్చిన సంక్లిష్ట అల్గారిథమ్ను అధిగమించగలదు.
ఫీచర్ ఇంజనీరింగ్ అనేది మెషిన్ లెర్నింగ్ అల్గారిథమ్లు సమర్థవంతంగా నేర్చుకోగలిగే ప్రాతినిధ్యాలుగా ముడి డేటాను మార్చే క్రాఫ్ట్. అనువర్తిత యంత్ర అభ్యాసంలో ఇది నిస్సందేహంగా అత్యంత ప్రభావవంతమైన ఏకైక నైపుణ్యం - మరియు లోతైన డొమైన్ పరిజ్ఞానం డేటా సైన్స్తో కలిసేది.
మెషీన్ లెర్నింగ్లో, ఫీచర్ అనేది మీరు అంచనా వేయడానికి ప్రయత్నిస్తున్న ఏదైనా కొలవగల ఆస్తి లేదా లక్షణం. ఫీచర్లు మీ మోడల్కు ఇన్పుట్లు; లేబుల్ (లేదా లక్ష్యం) అనేది అవుట్పుట్.
ఇంటి ధర అంచనా మోడల్ కోసం:
ఇమెయిల్ స్పామ్ వర్గీకరణ కోసం:
మీరు ఎంచుకున్న అల్గోరిథం కంటే మీ ఫీచర్ల నాణ్యత, పరిమాణం మరియు ఔచిత్యం చాలా ముఖ్యమైనవి.
వాస్తవ ప్రపంచ డేటా గందరగోళంగా ఉంది. మెషిన్ లెర్నింగ్ అల్గారిథమ్లు నిర్దిష్ట అవసరాలను కలిగి ఉంటాయి, ఇవి ముడి డేటా దాదాపు ఎప్పుడూ సంతృప్తి చెందవు:
ఫీచర్ ఇంజనీరింగ్ అనేది ముడి డేటా మరియు మోడల్-రెడీ ఇన్పుట్ల మధ్య అంతరాన్ని తగ్గించే ప్రక్రియ.
లక్షణాలు చాలా భిన్నమైన ప్రమాణాలను కలిగి ఉన్నప్పుడు, నమూనాలు తప్పుదారి పట్టించబడతాయి. వేలల్లో విలువలు ఉన్న ఫీచర్ 0 మరియు 1 మధ్య విలువలు ఉన్న ఫీచర్పై ఆధిపత్యం చెలాయిస్తుంది.
సైన్ ఇన్ చర్చలో చేరండి
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X_train)
# Before: age=[22, 65, 34], income=[18000, 95000, 42000]
# After: age=[0.0, 1.0, 0.27], income=[0.0, 1.0, 0.31]
కనిష్ట-గరిష్ట స్కేలింగ్ కంటే అవుట్లైయర్లకు మరింత పటిష్టమైనది:
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)
# Transforms each feature to have mean=0, standard deviation=1
# Feature value → (value - mean) / std_dev
బొటనవేలు నియమం: డిఫాల్ట్గా ప్రామాణికతను ఉపయోగించండి. మీకు నిర్దిష్ట పరిమిత పరిధిలో (ఉదా., న్యూరల్ నెట్వర్క్ ఇన్పుట్లు) విలువలు అవసరమైనప్పుడు min-maxని ఉపయోగించండి.
"ఎరుపు/ఆకుపచ్చ/నీలం" లేదా "లండన్/మాంచెస్టర్/బర్మింగ్హామ్" వంటి వర్గాలకు సహజ సంఖ్యా క్రమం లేదు. మీరు వాటిని చాలా అల్గారిథమ్లకు ఫీడ్ చేయడానికి ముందు వాటిని ఎన్కోడ్ చేయాలి.
ప్రతి వర్గానికి బైనరీ నిలువు వరుసను సృష్టిస్తుంది. వర్గాలకు స్వాభావిక క్రమం లేనప్పుడు ఉత్తమం:
import pandas as pd
# Original: colour = ['red', 'green', 'blue', 'red']
df = pd.DataFrame({'colour': ['red', 'green', 'blue', 'red']})
encoded = pd.get_dummies(df['colour'], prefix='colour')
print(encoded)
# colour_blue colour_green colour_red
# 0 0 0 1
# 1 0 1 0
# 2 1 0 0
# 3 0 0 1
ప్రతి వర్గాన్ని పూర్ణాంకానికి మ్యాప్ చేస్తుంది. వర్గాలకు సహజమైన క్రమం ఉన్నప్పుడు మాత్రమే ఉపయోగించండి:
from sklearn.preprocessing import LabelEncoder
# Works for: ['low', 'medium', 'high'] → [0, 1, 2]
# DANGER: Don't use for unordered categories like cities —
# the model will incorrectly assume London(0) < Paris(1) < Tokyo(2)
le = LabelEncoder()
df['education_level'] = le.fit_transform(df['education_level'])
# 'school' → 0, 'undergraduate' → 1, 'postgraduate' → 2
వాస్తవ ప్రపంచ డేటాసెట్లలో మిస్సింగ్ డేటా దాదాపు సార్వత్రికమైనది. మీకు అనేక ఎంపికలు ఉన్నాయి:
తప్పిపోయిన విలువలను లెక్కించిన ప్రత్యామ్నాయంతో పూరించండి:
from sklearn.impute import SimpleImputer
import numpy as np
# Strategy options: 'mean', 'median', 'most_frequent', 'constant'
imputer = SimpleImputer(strategy='median')
X_imputed = imputer.fit_transform(X)
# For numerical data: median is robust to outliers
# For categorical data: use 'most_frequent'
కొన్నిసార్లు డేటా లేదు అనే వాస్తవం సమాచారంగా ఉంటుంది:
# Create a binary flag: 1 if income was missing, 0 if present
df['income_missing'] = df['income'].isna().astype(int)
# Then impute the original column
df['income'].fillna(df['income'].median(), inplace=True)
కాలమ్లో ~70-80% కంటే ఎక్కువ తప్పిపోయిన విలువలు ఉంటే (అరుదుగా ఇన్ఫర్మేటివ్) ఉంటే దానిని వదలండి. మీరు పుష్కలంగా డేటాను కలిగి ఉంటే మరియు అడ్డు వరుస యాదృచ్ఛికంగా తప్పిపోయినట్లయితే మాత్రమే అడ్డు వరుసను వదలండి (క్రమబద్ధంగా కాదు).
ఇక్కడే ఫీచర్ ఇంజనీరింగ్ ఒక కళగా మారుతుంది. మీరు ముడి డేటాలో కనిపించని నమూనాలను క్యాప్చర్ చేసే లక్షణాలను రూపొందించడానికి డొమైన్ పరిజ్ఞానాన్ని ఉపయోగిస్తారు.
df['purchase_datetime'] = pd.to_datetime(df['purchase_datetime'])
# Extract meaningful components
df['hour_of_day'] = df['purchase_datetime'].dt.hour
df['day_of_week'] = df['purchase_datetime'].dt.dayofweek
df['is_weekend'] = (df['day_of_week'] >= 5).astype(int)
df['month'] = df['purchase_datetime'].dt.month
df['is_holiday'] = df['purchase_datetime'].isin(uk_holidays).astype(int)
ముడి టైమ్స్టాంప్ మోడల్కు నేరుగా ఏమీ చెప్పదు; ఈ ఉత్పన్నమైన ఫీచర్లు "ఉదయం 3 గంటలకు మోసపూరిత శిఖరాలు" లేదా "వారాంతాల్లో విక్రయాల పెరుగుదల" వంటి నమూనాలను బహిర్గతం చేస్తాయి.
# Square footage × number of bathrooms might be more predictive
# than either feature alone for house prices
df['size_per_bathroom'] = df['sqft'] / df['bathrooms']
# Ratio of income to loan amount — a classic credit risk feature
df['debt_to_income'] = df['loan_amount'] / df['annual_income']
from sklearn.feature_extraction.text import TfidfVectorizer
# Convert raw text to numerical feature matrix
vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
text_features = vectorizer.fit_transform(df['review_text'])
# Each word becomes a feature; its value reflects how important
# the word is in that document relative to the whole corpus
మీరు ఒక మోడల్ను రూపొందించిన తర్వాత, అది ఏ ఫీచర్లు అత్యంత ఉపయోగకరంగా ఉందో మీరు కొలవవచ్చు. ఇది మీ మోడల్ను అర్థం చేసుకోవడానికి మరియు ఏ ఫీచర్లను ఉంచాలో లేదా వదలాలో నిర్ణయించడానికి రెండింటికీ విలువైనది:
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
# Get feature importances
importances = pd.Series(
model.feature_importances_,
index=feature_names
).sort_values(ascending=False)
print(importances.head(10))
# income_to_debt_ratio 0.187
# days_since_last_payment 0.143
# credit_utilisation 0.121
# ...
పనితీరును ప్రభావితం చేయకుండా సున్నాకి సమీపంలో ఉన్న ఫీచర్లు సాధారణంగా వదలబడతాయి - మరియు వాటిని వదలడం మోడల్ను సులభతరం చేస్తుంది, శిక్షణ సమయాన్ని తగ్గిస్తుంది మరియు సాధారణీకరణను మెరుగుపరుస్తుంది.
మీకు వందల లేదా వేల ఫీచర్లు ఉన్నప్పుడు, మోడల్లు కష్టపడగలవు - దీనిని ** డైమెన్షియాలిటీ శాపం** అంటారు. డైమెన్షియాలిటీ తగ్గింపు పద్ధతులు అత్యంత ముఖ్యమైన నమూనాలను సంరక్షించేటప్పుడు లక్షణాలను కుదించాయి:
from sklearn.decomposition import PCA
# Reduce 100 features to 10 components that capture 95% of variance
pca = PCA(n_components=10)
X_reduced = pca.fit_transform(X_scaled)
print(f"Variance explained: {pca.explained_variance_ratio_.sum():.2%}")
# Variance explained: 94.7%
PCA (ప్రిన్సిపల్ కాంపోనెంట్ అనాలిసిస్) అనేది సర్వసాధారణమైన విధానం, అయితే ఇతరులు t-SNE (విజువలైజేషన్ కోసం) మరియు UMAP (స్థానిక నిర్మాణాన్ని సంరక్షించడం కోసం) ఉన్నాయి.
మీరు 50 విభిన్న నగర పేర్లను కలిగి ఉన్న 'నగరం' కాలమ్తో డేటాసెట్ని కలిగి ఉన్నారు. మీరు ఏ ఎన్కోడింగ్ విధానాన్ని ఉపయోగించాలి?