AI/LLM Feature Engineering Sinhala Guide | දත්ත සකසමු

හැඳින්වීම: AI/LLM වලට හොඳ දත්ත අමුද්‍රව්‍ය!

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ Artificial Intelligence (AI) සහ Large Language Models (LLMs) වල සාර්ථකත්වයට අත්‍යවශ්‍යම දේවල් වලින් එකක් ගැන – ඒ තමයි Feature Engineering. මේක හරියට රසවත් කෑමක් හදනකොට හොඳම අමුද්‍රව්‍ය තෝරලා, ඒවා හොඳට සකස් කරලා ගන්නවා වගේ වැඩක්. අපි කොච්චර හොඳ chef කෙනෙක් වුණත්, අපේ අතේ තියෙන අමුද්‍රව්‍ය හොඳ නැත්නම්, අවසාන ප්‍රතිඵලයත් එච්චර හොඳ වෙන්නේ නැහැනේ, නේද? ඒ වගේ තමයි AI/LLM models වලටත්. අපේ models කොච්චර සංකීර්ණ වුණත්, ඒවාට දෙන data එක හරියට සකස් කරලා නැත්නම්, ඒවායේ ක්‍රියාකාරිත්වය දුර්වල වෙන්න පුළුවන්.

මේ tutorial එකෙන් අපි Feature Engineering කියන්නේ මොකක්ද, ඒක AI/LLM models වලට මෙච්චර වැදගත් ඇයි කියලා ගැඹුරින් බලමු. ඒ වගේම, Feature Engineering වල මූලික පියවරයන් වන Feature Selection (විශේෂාංග තෝරාගැනීම), Feature Extraction (විශේෂාංග උකහාගැනීම), Feature Transformation (විශේෂාංග පරිවර්තනය) වගේම, missing data (නැතිවූ දත්ත) සහ categorical variables (වර්ගීකරණ විචල්‍යයන්) වගේ දේවල් handle කරන්නේ කොහොමද කියලත් අපි කතා කරනවා. මේ හැමදේම practical examples එක්ක, සරලව තේරුම් ගන්න පුලුවන් විදියට පැහැදිලි කරන්න මම බලාපොරොත්තු වෙනවා.

ඉතින්, ඔයාලා AI/Machine Learning domain එකේ අලුත් කෙනෙක් වුණත්, දැනටමත් වැඩ කරන කෙනෙක් වුණත්, මේ tutorial එක ඔයාලට අලුත් දේවල් ගොඩක් එකතු කරගන්න උපකාරී වෙයි කියලා මට විශ්වාසයි. එහෙනම්, අපි පටන් ගමු!

Feature Engineering කියන්නේ මොකක්ද?

සරලවම කියනවා නම්, Feature Engineering කියන්නේ අපේ AI/LLM model එකට හොඳම විදියට ඉගෙන ගන්න පුළුවන් විදියට raw data එක වෙනස් කරන ක්‍රියාවලියක්. මේක හරියට අපේ data එකේ තියෙන 'අමු' තොරතුරු අරගෙන, model එකට තේරුම් ගන්න පුළුවන්, වඩාත් අර්ථවත් 'විශේෂාංග' (features) බවට පත් කරනවා වගේ වැඩක්. සමහර විට මේකෙන් model එකේ accuracy එක, speed එක සහ overall performance එක විශාල වශයෙන් වැඩි කරන්න පුළුවන්.

බොහෝ වෙලාවට, අපිට ලැබෙන data set එකක තියෙන features, model එකකට කෙලින්ම යොදන්න තරම් ප්‍රමාණවත් නැහැ. ඒ data එකේ තියෙනවා වටිනාකමක් නැති (noisy) features, නැත්නම් model එකට තේරුම් ගන්න බැරි formats වල data, එහෙමත් නැත්නම් එකිනෙකට සම්බන්ධ නැති වගේ පෙනුනත් ඇත්තටම සම්බන්ධකම් තියෙන features. Feature Engineering වලින් අපි කරන්නේ මේ වගේ දේවල් හඳුනගෙන, ඒවා නිවැරදි කරලා, model එකට අවශ්‍ය විදියට සකස් කරන එක.

මේක Machine Learning (ML) project එකකදී data scientist කෙනෙක්ට හෝ ML engineer කෙනෙක්ට තියෙන වැදගත්ම, ඒ වගේම නිර්මාණාත්මකම කාර්යයන්ගෙන් එකක්. හොඳ Feature Engineering එකකින්, සරල model එකකට වුණත් සංකීර්ණ ප්‍රශ්න විසඳන්න පුළුවන් වෙනවා.

Feature Engineering මෙතරම් වැදගත් වන්නේ ඇයි?

• Model Performance වැඩි කිරීම: හොඳ features මඟින් model එකට patterns වඩාත් හොඳින් හඳුනාගෙන, වඩාත් නිවැරදි අනාවැකි පල කරන්න පුළුවන්.
• Overfitting අඩු කිරීම: අනවශ්‍ය හෝ noisy features ඉවත් කිරීමෙන් model එකේ overfitting අඩු කරන්න පුළුවන්, ඒ කියන්නේ model එක train කළ data එකට විතරක් හොඳට වැඩ කරලා, අලුත් data වලට දුර්වල වීම නවත්වන්න පුළුවන්.
• Model Training වේගවත් කිරීම: අඩු features ප්‍රමාණයක් සමඟ model එකක් train කරන එකට අඩු කාලයක් සහ අඩු computational resources ප්‍රමාණයක් යනවා.
• Model Interpretability වැඩි කිරීම: සමහර වෙලාවට, හොඳින් තෝරාගත් features නිසා model එකේ තීරණ තේරුම් ගැනීම පහසු වෙනවා.

Feature Selection: නිවැරදි අමුද්‍රව්‍ය තෝරාගැනීම

Feature Selection කියන්නේ අපේ data set එකේ තියෙන features ගොඩකින්, model එකේ output එකට වඩාත්ම බලපාන, ඒ කියන්නේ වඩාත්ම වැදගත් features ටික තෝරාගන්න එක. මේක හරියට අපි රසවත් කෑමක් හදනකොට, හොඳම එළවළු, මස්, කුළුබඩු වගේ දේවල් තෝරාගන්නවා වගේ වැඩක්.

ඇයි Feature Selection කරන්න ඕන?

• Performance වැඩි කරන්න: අනවශ්‍ය (irrelevant) හෝ අනවශ්‍ය ලෙස එකිනෙකට සම්බන්ධ (redundant) features ඉවත් කිරීමෙන් model එකේ performance වැඩි වෙනවා.
• Overfitting අඩු කරන්න: විශේෂයෙන්ම, feature ගොඩක් තියෙනකොට model එක train කළ data එකට ඕනෑවට වඩා 'fit' වෙලා, අලුත් data වලට හොඳට වැඩ නොකර ඉන්න පුළුවන්. Features අඩු කිරීමෙන් මේ තත්ත්වය වළක්වා ගන්න පුළුවන්.
• Training කාලය අඩු කරන්න: අඩු features ප්‍රමාණයක් එක්ක model එකක් train කරන්න ගතවන කාලය සහ අවශ්‍ය computational power එක අඩුයි.
• Interpretability වැඩි කරන්න: අඩු features ප්‍රමාණයක් සමඟ model එකේ තීරණ තේරුම් ගැනීම පහසුයි.

Feature Selection ක්‍රම

1. Filter Methods: මේවා කරන්නේ model එකෙන් ස්වාධීනව, statistical measures (උදා: correlation, chi-squared, ANOVA) පාවිච්චි කරලා, එක් එක් feature එක model එකේ output එකට කොච්චර සම්බන්ධද කියලා බලන එක. High scores තියෙන features අපි තෝරාගන්නවා.
2. Wrapper Methods: මේවා කරන්නේ feature sub-sets නිර්මාණය කරලා, එක් එක් sub-set එකක් පාවිච්චි කරලා model එකක් train කරලා, ඒ model එකේ performance එක අනුව හොඳම sub-set එක තෝරාගන්න එක. Recursive Feature Elimination (RFE) මේකට හොඳ උදාහරණයක්.
3. Embedded Methods: මේ ක්‍රමවලදී feature selection එක model training ක්‍රියාවලිය ඇතුලෙම සිද්ධ වෙනවා. උදාහරණයක් විදියට, Lasso (L1 regularization) සහ Ridge (L2 regularization) regressions වලදී, less important features වල coefficients බිංදුවට කිට්ටු කරනවා. Tree-based models (Random Forest, Gradient Boosting) වලදී feature importance scores වලින් හොඳ features තෝරාගන්න පුළුවන්.

උදාහරණයක්: Correlation භාවිතයෙන් Feature Selection

අපි හිතමු අපිට housing prices predict කරන data set එකක් තියෙනවා කියලා. ඒකේ features ගොඩක් තියෙන්න පුළුවන් (e.g., number of rooms, square footage, neighborhood crime rate, age of house). මේවායින් 'house price' එකට වැඩිම සම්බන්ධයක් තියෙන features ටික තෝරාගන්න අපි correlation එක පාවිච්චි කරන හැටි බලමු.

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

# Sample Data - අපි හිතමු මේක housing data කියලා
data = {
    'SquareFootage': np.random.randint(1000, 3000, 100),
    'NumBedrooms': np.random.randint(2, 5, 100),
    'NumBathrooms': np.random.randint(1, 4, 100),
    'YearBuilt': np.random.randint(1980, 2020, 100),
    'NeighborhoodScore': np.random.randint(1, 10, 100),
    'SchoolRating': np.random.randint(1, 10, 100),
    'DistanceToCity': np.random.uniform(1, 50, 100),
    'CrimeRate': np.random.uniform(0.1, 5.0, 100),
    'HousePrice': np.random.randint(100000, 500000, 100) # Target variable
}
df = pd.DataFrame(data)

# HousePrice එකට අනෙක් features වල correlation එක ගණනය කිරීම
correlations = df.corr()['HousePrice'].abs().sort_values(ascending=False)
print("\nCorrelation with HousePrice (Absolute Value):\n", correlations)

# අපි හිතමු correlation එක 0.5 ට වඩා වැඩි features ටික විතරක් තෝරගන්නවා කියලා
selected_features = correlations[correlations > 0.5].index.tolist()
if 'HousePrice' in selected_features:
    selected_features.remove('HousePrice') # Target variable එක ඉවත් කිරීම

print("\nSelected Features (correlation > 0.5):\n", selected_features)

# Heatmap එකකින් correlation matrix එක බලන්න පුළුවන්
plt.figure(figsize=(10, 8))
sns.heatmap(df[selected_features + ['HousePrice']].corr(), annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Correlation Matrix of Selected Features with HousePrice')
plt.show()

මේ උදාහරණයෙන් පේනවා වගේ, අපි target variable එකට (HousePrice) වඩාත්ම සම්බන්ධ features ටික තෝරාගත්තා. මේක filter method එකකට හොඳ උදාහරණයක්.

Feature Extraction: අලුත් දේවල් හදාගැනීම

Feature Extraction කියන්නේ දැනට තියෙන features අරගෙන, ඒවා එකතු කරලා හෝ වෙනස් කරලා අලුත්, වඩාත් තොරතුරු සහිත features නිර්මාණය කරන ක්‍රියාවලියක්. මේක හරියට අපි කෑමක් හදනකොට, තියෙන අමුද්‍රව්‍ය ටික අරගෙන අලුත් සෝස් එකක් හදනවා වගේ වැඩක්. මේ අලුත් features වලට සමහර වෙලාවට මුල් features වලට වඩා හොඳට model එකේ output එක predict කරන්න පුළුවන්.

ඇයි Feature Extraction කරන්න ඕන?

• සංකීර්ණ සම්බන්ධතා හඳුනාගන්න: සමහර වෙලාවට data එකේ තියෙන සම්බන්ධතා සරල features වලින් කෙලින්ම පෙන්නන්නේ නැහැ. අලුත් features හදන එකෙන් ඒවා හඳුනාගන්න පුළුවන්.
• Dimensionality අඩු කරන්න: සමහර ක්‍රම (උදා: PCA) මඟින් features විශාල ප්‍රමාණයක් කුඩා, වඩාත් තොරතුරු සහිත features ප්‍රමාණයකට අඩු කරන්න පුළුවන්. මේකෙන් model එකේ training වේගවත් වෙනවා.
• Model Performance වැඩි කරන්න: වඩාත් අර්ථවත් features මඟින් model එකේ accuracy සහ generalization හැකියාව වැඩි කරන්න පුළුවන්.

Feature Extraction ක්‍රම

1. Dimensionality Reduction:
   • Principal Component Analysis (PCA): මේකෙන් කරන්නේ features ගොඩක් අරගෙන, ඒවායේ තියෙන variance (විචලනය) වැඩිම directions වලට projection කරලා, අලුත්, independent components හදන එක. මේවා මුල් features වල linear combinations.
2. Creating Interaction Features: Features දෙකක් හෝ වැඩි ගණනක් ගුණ කිරීමෙන්, එකතු කිරීමෙන් හෝ බෙදීමෙන් අලුත් features හදන එක. උදා: 'Area' = 'Length' * 'Width'.
3. Polynomial Features: දැනට තියෙන features වල powers අරගෙන අලුත් features හදන එක. උදා: x^2, x^3.
4. Domain-Specific Features: සමහර වෙලාවට අපි වැඩ කරන domain එක ගැන තියෙන දැනුම පාවිච්චි කරලා අලුත් features හදන්න පුළුවන්. උදා: time series data වලදී 'day of week', 'month', 'holiday status' වගේ features හදන එක.
5. Text Data සඳහා: LLMs වලදී Feature Extraction එක වෙනස් විදියකට සිද්ධ වෙනවා. TF-IDF (Term Frequency-Inverse Document Frequency), Word Embeddings (Word2Vec, GloVe, FastText), Sentence Embeddings වගේ දේවල් වලින් text data එක numerical features බවට පත් කරනවා.

උදාහරණයක්: Polynomial Features සහ Interaction Features

අපි හිතමු අපිට Temperature සහ Humidity කියන features දෙකක් තියෙනවා කියලා. මේවා පාවිච්චි කරලා අලුත් features හදන හැටි බලමු.

from sklearn.preprocessing import PolynomialFeatures
import pandas as pd
import numpy as np

# Sample Data
data = {
    'Temperature': np.random.uniform(15, 35, 10),
    'Humidity': np.random.uniform(40, 90, 10)
}
df = pd.DataFrame(data)
print("\nOriginal DataFrame:\n", df)

# Polynomial Features (degree=2)
# මෙයින් x1, x2, x1^2, x2^2, x1*x2 වගේ features හැදෙනවා.
poly = PolynomialFeatures(degree=2, include_bias=False)
poly_features = poly.fit_transform(df[['Temperature', 'Humidity']])
poly_df = pd.DataFrame(poly_features, columns=poly.get_feature_names_out(['Temperature', 'Humidity']))
print("\nPolynomial Features (degree=2):\n", poly_df)

# Interaction Feature: Temperature * Humidity
df['Temp_Humidity_Interaction'] = df['Temperature'] * df['Humidity']
print("\nDataFrame with Interaction Feature:\n", df)

මේ code එකෙන් අපේ මුල් features වලින් අලුත්, වඩාත් සංකීර්ණ features හැදෙන හැටි පෙන්වනවා. Temperature * Humidity වගේ feature එකකින් model එකට මේවා අතර තියෙන සම්බන්ධය වඩා හොඳින් තේරුම් ගන්න පුළුවන්.

Feature Transformation: අමුද්‍රව්‍ය සකස් කිරීම

Feature Transformation කියන්නේ දැනට තියෙන features වල scale එක හෝ distribution එක වෙනස් කරන එක. මේක හරියට අපි කෑම හදනකොට, එළවළු කපන හැටි, මස් marinated කරන හැටි වගේ. මේකෙන් model එකේ convergence එක වැඩි කරන්න, outliers handle කරන්න, සහ model assumptions meet කරන්න පුළුවන්.

ඇයි Feature Transformation කරන්න ඕන?

• Algorithm Performance: සමහර ML algorithms (උදා: Support Vector Machines, K-Nearest Neighbors, Neural Networks) features එකම scale එකක තියෙනකොට හොඳට වැඩ කරනවා. Gradient Descent වගේ optimization algorithms වලටත් මේක වැදගත්.
• Outliers handle කරන්න: Outliers නිසා model එකේ performance එකට හානි වෙන්න පුළුවන්. Transformations වලින් outliers වල බලපෑම අඩු කරන්න පුළුවන්.
• Normal Distribution එකකට ගේන්න: සමහර statistical models වලට features normal distribution එකක තියෙන්න ඕන. Log transform වගේ දේවල් වලින් skewed data normal distribution එකකට කිට්ටු කරන්න පුළුවන්.

Feature Transformation ක්‍රම

1. Scaling:
   • Min-Max Scaling (Normalization): Features වල අගයන් 0 ත් 1 ත් අතර පරාසයකට ගේනවා. X_scaled = (X - X_min) / (X_max - X_min)
   • Standardization (Z-score Normalization): Features වල mean එක 0, standard deviation එක 1 වෙන විදියට වෙනස් කරනවා. X_scaled = (X - mean) / standard_deviation
2. Log Transformation: Skewed (අසමමිතික) distribution එකක් තියෙන data වලට මේක හොඳයි. Positive values වලට විතරයි මේක කරන්න පුළුවන්. log(X)
3. Power Transformation (Box-Cox, Yeo-Johnson): මේවා log transform වලට වඩා සාමාන්‍යකරණය වූ transforms. මේවාට negative values වුණත් handle කරන්න පුළුවන්.

උදාහරණයක්: Min-Max Scaling සහ Standardization

අපි හිතමු අපිට Age සහ Salary කියන features දෙකක් තියෙනවා කියලා. මේවාට ගොඩක් වෙනස් scale තියෙන්න පුළුවන්. මේවා scale කරන හැටි බලමු.

from sklearn.preprocessing import MinMaxScaler, StandardScaler
import pandas as pd
import numpy as np

# Sample Data
data = {
    'Age': np.random.randint(18, 65, 10),
    'Salary': np.random.randint(30000, 150000, 10)
}
df = pd.DataFrame(data)
print("\nOriginal DataFrame:\n", df)

# Min-Max Scaling
min_max_scaler = MinMaxScaler()
df_min_max_scaled = pd.DataFrame(min_max_scaler.fit_transform(df), columns=df.columns)
print("\nMin-Max Scaled DataFrame:\n", df_min_max_scaled)

# Standardization
standard_scaler = StandardScaler()
df_standard_scaled = pd.DataFrame(standard_scaler.fit_transform(df), columns=df.columns)
print("\nStandardized DataFrame:\n", df_standard_scaled)

දැන් ඔයාලට පේනවා ඇති Age සහ Salary කියන features දෙකම එකම scale එකකට ආපු හැටි. මේකෙන් model එකේ performance එක හොඳ කරන්න පුළුවන්.

Missing Data Handling: නැතිවූ කොටස් සම්පූර්ණ කිරීම

ඕනෑම data set එකක missing values (නැතිවූ අගයන්) තියෙන්න පුළුවන්. මේවා නොසලකා හැරියොත් model එකේ performance එකට බරපතල බලපෑමක් වෙන්න පුළුවන්. Missing values handle කරන එකත් Feature Engineering වල වැදගත් පියවරක්.

ඇයි Missing Data Handling කරන්න ඕන?

• Model Errors: බොහෝ ML algorithms වලට missing values තියෙන data වලට වැඩ කරන්න බැහැ.
• Bias: Missing data එක pattern එකකට අනුව සිද්ධ වෙලා තියෙනවා නම් (e.g., අඩු ආදායම් ලබන අය salary එක නොදීම), ඒකෙන් model එකේ bias ඇති වෙන්න පුළුවන්.
• Reduced Performance: Missing values නිසා model එකේ accuracy සහ generalization හැකියාව අඩු වෙන්න පුළුවන්.

Missing Data Handling ක්‍රම

1. Deletion (ඉවත් කිරීම):
   • Row-wise Deletion (පේළි ඉවත් කිරීම): Missing values තියෙන හැම row එකක්ම (record එකක්ම) data set එකෙන් ඉවත් කරනවා. මේක කරන්න හොඳ data set එකේ missing values අඩු ප්‍රමාණයක් තියෙනවා නම් විතරයි. නැත්නම් වටිනා data ගොඩක් නැති වෙන්න පුළුවන්.
   • Column-wise Deletion (තීරු ඉවත් කිරීම): Missing values ගොඩක් තියෙන column එකක්ම (feature එකක්ම) ඉවත් කරනවා. මේක කරන්න පුළුවන් අදාළ feature එක එච්චර වැදගත් නැත්නම් විතරයි.
2. Imputation (පිරවීම): Missing values වෙනත් අගයකින් පිරවීම. මේක තමයි බහුලවම භාවිතා වෙන ක්‍රමය.
   • Mean, Median, Mode Imputation: Numerical data වලට අදාළ column එකේ mean (සාමාන්‍යය), median (මධ්‍යස්ථය) හෝ categorical data වලට mode (බහුලවම එන අගය) එකෙන් missing values පිරවීම. මේක සරලම ක්‍රමයක්.
   • Forward Fill / Backward Fill: Time series data වලට මේවා හොඳයි. කලින් හෝ ඊළඟට එන value එකෙන් missing value එක පිරවීම.
   • Advanced Imputation:
     • K-Nearest Neighbors (KNN) Imputer: Missing values තියෙන record එකට ආසන්නම records (neighbors) වල values පාවිච්චි කරලා missing value එක පුරවනවා.
     • Regression Imputation: Missing value එක තියෙන feature එක target variable එකක් විදියට අරගෙන, අනිත් features පාවිච්චි කරලා regression model එකක් train කරලා missing value එක predict කරලා පුරවනවා.

උදාහරණයක්: Mean Imputation

අපි හිතමු අපේ data set එකේ Age column එකේ missing values තියෙනවා කියලා. ඒවා mean එකෙන් පුරවන හැටි බලමු.

import pandas as pd
import numpy as np

# Sample Data with Missing Values
data = {
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, np.nan, 40, 35],
    'Score': [85, 90, 78, np.nan, 92]
}
df = pd.DataFrame(data)
print("\nOriginal DataFrame with Missing Values:\n", df)

# Missing values තියෙනවාද කියලා බලමු
print("\nMissing values before imputation:\n", df.isnull().sum())

# Age column එකේ mean එකෙන් missing values පිරවීම
df['Age'].fillna(df['Age'].mean(), inplace=True)

# Score column එකේ median එකෙන් missing values පිරවීම
df['Score'].fillna(df['Score'].median(), inplace=True)

print("\nDataFrame after Imputation:\n", df)
print("\nMissing values after imputation:\n", df.isnull().sum())

දැන් ඔයාලට පේනවා ඇති Age සහ Score columns වල තිබ්බ missing values පිරවිලා තියෙන හැටි. fillna() කියන function එක මේ වගේ වැඩ වලට ගොඩක් ප්‍රයෝජනවත්.

Categorical Variables Handling: වර්ගීකරණ දත්ත කළමනාකරණය

Data set වල categorical variables (වර්ගීකරණ විචල්‍යයන්) කියන්නේ අගයන් සීමිත ගණනක් (categories) ගන්න features. උදා: Gender (Male/Female), City (Colombo/Kandy/Galle), Education Level (High School/Degree/Masters). බොහෝ ML algorithms වලට text ආකාරයේ categorical data කෙලින්ම යොදාගන්න බැහැ. ඒවා numerical format එකකට convert කරන්න ඕන.

Categorical Variables වර්ග

• Nominal Categorical Variables: මේවාට කිසිම order එකක් නැති categories. උදා: Colors (Red, Blue, Green), Cities (Colombo, Kandy, Galle).
• Ordinal Categorical Variables: මේවාට order එකක් තියෙන categories. උදා: Education Level (High School < Degree < Masters), Rating (Bad < Neutral < Good).

Categorical Variables Handling ක්‍රම

1. One-Hot Encoding:
   • Nominal categorical variables වලට බහුලවම භාවිතා කරන ක්‍රමයක්. මේකෙන් කරන්නේ එක් එක් category එකට අලුත් binary (0 හෝ 1) feature column එකක් හදන එක. මේකෙන් model එකට categories අතර කිසිම order එකක් නැහැ කියලා තේරුම් ගන්න පුළුවන්.
   • උදා: Color column එකේ Red, Blue, Green තියෙනවා නම්, Color_Red, Color_Blue, Color_Green කියලා columns 3ක් හැදෙනවා.
2. Label Encoding / Ordinal Encoding:
   • Ordinal categorical variables වලට හොඳයි. මේකෙන් කරන්නේ එක් එක් category එකට අංකයක් (integer value) assign කරන එක.
   • උදා: Education Level column එකේ High School = 0, Degree = 1, Masters = 2 වගේ. මෙහිදී order එකක් තියෙන නිසා මේක ප්‍රයෝජනවත් වෙනවා. Nominal variables වලට මේක යොදාගත්තොත් model එකට වැරදි order එකක් තියෙනවා කියලා වැටහෙන්න පුළුවන්.
3. Target Encoding (Mean Encoding):
   • මේකෙන් කරන්නේ එක් එක් category එකක target variable එකේ සාමාන්‍යය (mean) හෝ වෙනත් statistical value එකක් assign කරන එක. උදා: City එකක් target variable එකට කොච්චර බලපානවද කියලා ඒ city එකේ records වල target variable එකේ average value එකෙන් predict කරනවා.

උදාහරණයක්: One-Hot Encoding සහ Label Encoding

අපි හිතමු අපිට City (nominal) සහ Education (ordinal) කියන categorical features දෙකක් තියෙනවා කියලා. මේවා convert කරන හැටි බලමු.

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Sample Data
data = {
    'CustomerID': [1, 2, 3, 4, 5],
    'City': ['Colombo', 'Kandy', 'Galle', 'Colombo', 'Kandy'],
    'Education': ['High School', 'Degree', 'Masters', 'Degree', 'High School']
}
df = pd.DataFrame(data)
print("\nOriginal DataFrame:\n", df)

# One-Hot Encoding for 'City' (Nominal)
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
city_encoded = ohe.fit_transform(df[['City']])
city_df = pd.DataFrame(city_encoded, columns=ohe.get_feature_names_out(['City']))

# Combine with original DataFrame
df_encoded = pd.concat([df.drop('City', axis=1), city_df], axis=1)
print("\nDataFrame after One-Hot Encoding 'City':\n", df_encoded)

# Label Encoding for 'Education' (Ordinal - manual mapping for order)
# අපි මෙතන order එක define කරගන්නවා
education_mapping = {'High School': 0, 'Degree': 1, 'Masters': 2}
df_encoded['Education_Encoded'] = df_encoded['Education'].map(education_mapping)

# Or, if order doesn't matter (or for simplicity with LabelEncoder):
# le = LabelEncoder()
# df_encoded['Education_Encoded'] = le.fit_transform(df_encoded['Education'])

print("\nDataFrame after Label Encoding 'Education':\n", df_encoded.drop('Education', axis=1))

දැන් ඔයාලට පේනවා ඇති City column එක වෙනුවට City_Colombo, City_Kandy, City_Galle කියලා අලුත් columns හැදිලා තියෙන හැටි. Education column එකත් numerical values බවට හැරිලා තියෙනවා. මේවා ML models වලට පහසුවෙන් යොදාගන්න පුළුවන්.

Feature Engineering for LLMs: විශේෂ අවධානය

Large Language Models (LLMs) වලට Feature Engineering කියන එක තව ටිකක් වෙනස් විදියකට බලපානවා. LLMs ගොඩක් වෙලාවට text data කෙලින්ම tokenize කරලා, embeddings හදාගෙන තමන්ටම features extract කරගන්නවා. ඒත්, ඒකෙන් අදහස් කරන්නේ LLM domain එකේ Feature Engineering වලට තැනක් නැහැ කියන එක නෙවෙයි.

බොහෝ විට LLMs පාවිච්චි කරන්නේ downstream tasks (අලුත් කාර්යයන්) වලට. උදා: sentiment analysis, text classification, question answering, summarization වගේ දේවල්. මේ වගේ කාර්යයන් වලදී, LLM එකේ output එක (embeddings, generated text) සමඟ අපිට තවත් external features එකතු කරන්න පුළුවන්, model එකේ performance එක වැඩි කරන්න.

LLMs සන්දර්භය තුළ Feature Engineering වලට උදාහරණ

1. Text Statistics Features:
   • Text Length (අකුරු ගණන/වචන ගණන): Text එකේ දිග, කෙටිකම සමහර කාර්යයන් වලට වැදගත් වෙන්න පුළුවන්.
   • Average Word Length (සාමාන්‍ය වචන දිග): Formal text වල දිග වචන වැඩි වෙන්න පුළුවන්.
   • Punctuation Count (විරාම ලකුණු ගණන): ප්‍රශ්නාර්ථ ලකුණු, ආශ්චර්යවාචක ලකුණු වැනි දේවලින් sentiment එක හෝ text type එක ගැන තොරතුරු දෙන්න පුළුවන්.
   • Stop Word Count / Unique Word Count: Text එකේ තියෙන වචන වල විවිධත්වය.
2. Readability Scores: Flesch-Kincaid Grade Level, Gunning Fog Index වැනි metrics වලින් text එකක කියවීමේ පහසුව මනිනවා. මේවා text classification වැනි කාර්යයන් වලට වැදගත් වෙන්න පුළුවන්.
3. Sentiment Scores: Pre-trained sentiment analysis models පාවිච්චි කරලා text එකේ sentiment (ධනාත්මක, සෘණාත්මක, මධ්‍යස්ථ) score එකක් අරගෙන feature එකක් විදියට පාවිච්චි කරන්න පුළුවන්.
4. Named Entity Recognition (NER) Counts: Text එකේ තියෙන පුද්ගලයන්ගේ නම්, ස්ථාන, සංවිධාන වැනි entities ගණන. මේවා news articles classification වගේ කාර්යයන් වලට හොඳයි.
5. Topic Modeling Features: Latent Dirichlet Allocation (LDA) වැනි methods පාවිච්චි කරලා text එකේ තියෙන topics extract කරලා ඒවා features විදියට පාවිච්චි කරන්න පුළුවන්.
6. LLM Embeddings as Features: LLM එකක් මඟින් generate කරන text embeddings (vector representations) අරගෙන ඒවා downstream ML models වලට input features විදියට දෙන්න පුළුවන්. මේකෙන් text එකේ semantic meaning එක capture වෙනවා.

උදාහරණයක්: Text Statistics Features

අපි හිතමු අපිට LLM එකකට දෙන්න ඕන කරන text set එකක් තියෙනවා. ඒකෙන් text length සහ word count වගේ features හදන හැටි බලමු.

import pandas as pd

# Sample Text Data
data = {
    'Document': [
        'This is a sample sentence for text analysis.',
        'AI and LLMs are revolutionizing the world.',
        'Short text.',
        'Feature Engineering is crucial for model performance in complex AI systems.'
    ]
}
df = pd.DataFrame(data)
print("\nOriginal Text Data:\n", df)

# Text Length (character count)
df['Text_Length'] = df['Document'].apply(len)

# Word Count
df['Word_Count'] = df['Document'].apply(lambda x: len(str(x).split()))

print("\nDataFrame with Text Statistics Features:\n", df)

මේවා සරල features වුණත්, LLM එකක performance එක වැඩි කරන්න, විශේෂයෙන්ම text classification, sentiment analysis වගේ tasks වලට මේවා ප්‍රයෝජනවත් වෙන්න පුළුවන්.

නිගමනය: දත්ත හොඳින් සකසමු, හොඳ ප්‍රතිඵල ලබමු!

ඉතින් යාළුවනේ, අපි මේ tutorial එකෙන් Feature Engineering කියන සංකල්පය ගැන ගැඹුරින් කතා කළා. අපිට පේනවා ඇති AI/LLM models වල සාර්ථකත්වයට මේක කොච්චර වැදගත්ද කියලා. හරියට කෑමක් හදනකොට අමුද්‍රව්‍ය තෝරලා, කපලා, සකස් කරලා ගන්නවා වගේ, අපේ data එකත් model එකට තේරෙන විදියට, වඩාත්ම ප්‍රයෝජනවත් විදියට සකස් කරගන්න එක අත්‍යාවශ්‍යයි.

අපි Feature Selection (නිවැරදි දේ තෝරාගැනීම), Feature Extraction (අලුත් දේවල් හදාගැනීම), Feature Transformation (පවතින දේ සකස් කිරීම) වගේ මූලික ක්‍රම ගැන ඉගෙන ගත්තා. ඒ වගේම, missing data සහ categorical variables වගේ සාමාන්‍යයෙන් එන ප්‍රශ්න handle කරන හැටිත් අපි බැලුවා. විශේෂයෙන්ම LLMs වගේ අති නවීන models වලට වුණත්, text statistics, sentiment scores, හෝ embeddings වගේ දේවල් පාවිච්චි කරලා external features එකතු කිරීමෙන් model එකේ හැකියාවන් තවත් වැඩි කරගන්න පුළුවන් බව අපි දැක්කා.

Feature Engineering කියන්නේ කලාවක් සහ විද්‍යාවක්. මේක කරන්නේ කොහොමද කියන්නට ස්ථිර නීති නැහැ. Data set එකෙන් data set එකට, problem එකෙන් problem එකට මේක වෙනස් වෙනවා. හැබැයි, මේක අත්හදාබැලීම් (experimentation) සහ domain knowledge එක පාවිච්චි කරලා හොඳට ඉගෙන ගන්න පුළුවන් දෙයක්.

මතක තියාගන්න, හොඳම models හැදෙන්නේ හොඳම algorithms වලින් විතරක් නෙවෙයි, හොඳම features වලින්. ඉතින්, ඔයාලගේ ඊළඟ AI/ML project එකේදී Feature Engineering වලට වැඩි අවධානයක් දීලා බලන්න. ඔයාලට පුදුම හිතෙන ප්‍රතිඵල ලබාගන්න පුළුවන් වෙයි!

මේ tutorial එක ඔයාලට ප්‍රයෝජනවත් වුණා කියලා මම හිතනවා. ඔයාලගේ අත්දැකීම්, ප්‍රශ්න, හෝ අදහස් පහතින් comment කරන්න. අලුත් දේවල් ඉගෙන ගන්න දිගටම උත්සාහ කරන්න!

නැවත හමුවෙමු!