၁။ နောက်ခံသဘောတရားများ (KNNImputer နှင့် GroupKFold)
လက်တွေ့ကမ္ဘာမှ GPS ဒေတာများကို Machine Learning မော်ဒယ်များတွင် အသုံးပြုသည့်အခါ အဓိက စိန်ခေါ်မှု (၂) ခု ရှိပါသည်—(၁) အချို့အတန်းများတွင် အာရုံခံကိရိယာ အချက်အလက် (
speed_2d, direction) ပျောက်ဆုံးနေခြင်း (NaN) နှင့် (၂) အချိန်နှင့်အမျှ ဆက်တိုက်မှတ်တမ်းတင်ထားသော ဒေတာများကြောင့် မော်ဒယ်စစ်ဆေးရာတွင် အမှန်တကယ်ထက် တိကျမှု ပိုမြင့်နေသယောင် အထင်မှားစေခြင်း (Data Leakage) တို့ ဖြစ်ပါသည်။(က) KNNImputer ဖြင့် ဒေတာကွက်လပ်များကို ML သုံး၍ ပြန်ဖြည့်ခြင်း
ယခင်ကုဒ်များတွင်
NaN ပါဝင်သော အတန်းများကို .dropna() ဖြင့် အလွယ်တကူ ဖျက်ပစ်ခဲ့ပါသည်။ သို့သော် ထိုသို့ဖျက်ပစ်လိုက်ခြင်းဖြင့် ၎င်းအတန်းထဲတွင် အကောင်းပကတိ ပါဝင်နေသော latitude, longitude, altitude, date_time အချက်အလက်များပါ ဆုံးရှုံးသွားပြီး Time-Series အဆက်အစပ် ပြတ်တောက်သွားပါသည်။| ကွက်လပ်ဖြည့်နည်းစနစ် | အလုပ်လုပ်ပုံ | အားနည်းချက် / အားသာချက် |
SimpleImputer (Mean/Median) | ပျောက်ဆုံးနေသော speed_2d နေရာအားလုံးကို တစ်ဖိုင်လုံး၏ ပျမ်းမျှကိန်းသေ (ဥပမာ 2.5 m/s) တစ်ခုတည်းဖြင့် အစားထိုးသည်။ | ငှက်သည် အမြင့်ပေ 1,000m တွင် အရှိန်ပြင်းပြင်း ပျံသန်းနေချိန်ဖြစ်စေကာမူ 2.5 m/s ဟု မှားယွင်းဖြည့်သွင်းမိတတ်သည်။ |
KNNImputer (ML-Based) | ကွက်လပ်ဖြစ်နေသော အတန်းနှင့် အခြားအချက်အလက်များ (altitude, latitude, longitude, hour) အနီးစပ်ဆုံး တူညီသော အိမ်နီးချင်း $k$ ခုကို ရှာဖွေ၍ ပျမ်းမျှပြန်ယူ ဖြည့်သွင်းသည်။ | အမြင့်ပေနှင့် တည်နေရာကို ကြည့်၍ နားနေချိန်ဆိုလျှင် အမြန်နှုန်းနည်းနည်း၊ ခရီးဝေးပျံနေချိန်ဆိုလျှင် အမြန်နှုန်းများများ အလိုအလျောက် ခန့်မှန်းဖြည့်သွင်းပေးနိုင်သည်။ |
Pipeline စည်းမျဉ်းKNNImputerသည် Euclidean Distance ကို အသုံးပြုသောကြောင့်StandardScalerဖြင့် အရင်စကေးညှိရပါမည်။ ထို့အပြင်Test Set၏ အချက်အလက်များ မပေါက်ကြားစေရန်Pipelineအတွင်း ထည့်သွင်းပြီးTrain Setတစ်ခုတည်းဖြင့်သာ တွက်ချက်စေရပါမည်။
(ခ) GroupKFold ဖြင့် စနစ်တကျ Cross-Validation စစ်ဆေးခြင်း
bird_tracking.csv ဖိုင်ထဲတွင် GPS မှတ်တမ်းများကို မိနစ်ပိုင်းသာ ခြား၍ ဆက်တိုက်မှတ်တမ်းတင်ထားပါသည်။ ထို့ကြောင့် မနက် 10:15 မှတ်တမ်းနှင့် 10:20 မှတ်တမ်းတို့သည် altitude, speed_2d, direction တန်ဖိုးများ ထပ်တူနီးပါး တူညီနေတတ်ပါသည် (Temporal Autocorrelation)။- သာမန်
KFold/train_test_split၏ ထောင်ချောက် ဒေတာအတန်းများကို ကျပန်း (Random) ခွဲထုတ်လိုက်ပါက10:15အတန်းသည်Train Setထဲရောက်သွားပြီး10:20အတန်းသည်Test Setထဲ ရောက်သွားပါမည်။ ထိုအခါ မော်ဒယ်သည် မိနစ်ပိုင်းသာ ခြားသော အတန်းကို အလွတ်ကျက်မှတ်မိနေသဖြင့် Accuracy ကို 90% ကျော် အထိ အတုအယောင် မြင့်မားစွာ ပြသတတ်ပါသည်။ GroupKFold၏ ဖြေရှင်းချက် ဒေတာများကို တစ်တန်းချင်းစီ ကျပန်းမခွဲဘဲ ရက်စွဲ (date) အလိုက် အုပ်စုဖွဲ့၍ ခွဲခြားစစ်ဆေးခြင်း ဖြစ်ပါသည်။GroupKFold(n_splits=5)ကို သုံးလိုက်ပါက ရက်စွဲတစ်ခုတည်းမှ ဒေတာအားလုံးသည်Trainသို့မဟုတ်Testတစ်ဖက်တည်းတွင်သာ အပြည့်အဝ ပါဝင်ရမည် ဖြစ်သောကြောင့် မော်ဒယ်က တစ်ခါမှ မမြင်ဖူးသေးသော နေ့ရက်အသစ်များအပေါ် မည်မျှအမှန်တကယ် ခန့်မှန်းနိုင်သနည်း ဆိုသည့် စစ်မှန်သော တိကျမှု (True Generalization Score) ကို ရရှိစေပါသည်။
၂။ Python Code Implementation
- အပိုင်း (၁) မူလဒေတာထဲမှ အကောင်းပကတိ ရှိနေသော
speed_2dတန်ဖိုး ၁၅% ကို တမင်ဖျောက် (NaNလုပ်) ကြည့်ပြီးSimpleImputer (Mean)နှင့်KNNImputerတို့၏ အမှားပမာဏ (MAE) ကို နှိုင်းယှဉ်ပြခြင်း၊ ထို့နောက် ဖိုင်ထဲရှိ တကယ့်NaNအတန်းများကို ပြန်လည်ဖြည့်သွင်းပြခြင်း။ - အပိုင်း (၂)
StandardScaler -> KNNImputer -> RandomForestClassifierပါဝင်သော ML Pipeline တစ်ခုတည်ဆောက်ပြီး သာမန်StratifiedKFold(Leaky) နှင့်GroupKFold(Honest by Date) တို့၏ Accuracy ရလဒ်ကွာဟချက်ကို နှိုင်းယှဉ်ပြသခြင်း။
Python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, GroupKFold, cross_val_score
from sklearn.metrics import mean_absolute_error
# ၁။ ဒေတာဖတ်ရှုခြင်းနှင့် အခြေခံ ပြင်ဆင်ခြင်း
birddata = pd.read_csv("bird_tracking.csv")
birddata['date_time'] = pd.to_datetime(birddata['date_time'], format='mixed')
birddata['date'] = birddata['date_time'].dt.date
birddata['hour'] = birddata['date_time'].dt.hour
print("=== မူလ bird_tracking.csv ဖိုင်ထဲရှိ ပျောက်ဆုံးနေသော (NaN) အရေအတွက် ===")
print(birddata.isna().sum()[birddata.isna().sum() > 0])
print()
# =============================================================================
# အပိုင်း (၁) - SimpleImputer (Mean) နှင့် KNNImputer (ML) တိကျမှု နှိုင်းယှဉ်စစ်ဆေးခြင်း
# =============================================================================
# အကောင်းပကတိ ရှိနေသော Eric ၏ ဒေတာများကို ယူ၍ 15% ကို တမင် NaN ဖန်တီးကာ စမ်းသပ်ပါမည်
eric_clean = birddata[(birddata['bird_name'] == 'Eric')].dropna(
subset=['speed_2d', 'altitude', 'latitude', 'longitude', 'hour']
).reset_index(drop=True)
imp_features = ['speed_2d', 'altitude', 'latitude', 'longitude', 'hour']
X_true = eric_clean[imp_features].copy()
# ကျပန်း 15% သော အတန်းများ၏ speed_2d ကို NaN အဖြစ် ဖျောက်ထားခြင်း
rng = np.random.default_rng(42)
mask = rng.random(len(X_true)) < 0.15
X_masked = X_true.copy()
X_masked.loc[mask, 'speed_2d'] = np.nan
true_speeds = X_true.loc[mask, 'speed_2d'].to_numpy()
# (က) SimpleImputer (ပျမ်းမျှကိန်းသေဖြင့် ဖြည့်ခြင်း)
mean_imp = SimpleImputer(strategy='mean')
X_mean_filled = mean_imp.fit_transform(X_masked)
pred_speed_mean = X_mean_filled[mask, 0]
# (ခ) KNNImputer (StandardScaler ဖြင့် စကေးညှိပြီး အနီးစပ်ဆုံး 7 ခုဖြင့် တွက်ဖြည့်ခြင်း)
scaler_imp = StandardScaler()
X_scaled_masked = scaler_imp.fit_transform(X_masked)
knn_imp = KNNImputer(n_neighbors=7, weights='distance')
X_scaled_filled = knn_imp.fit_transform(X_scaled_masked)
# မူလယူနစ် (m/s) သို့ ပြန်ပြောင်းခြင်း
X_knn_filled = scaler_imp.inverse_transform(X_scaled_filled)
pred_speed_knn = X_knn_filled[mask, 0]
mae_mean = mean_absolute_error(true_speeds, pred_speed_mean)
mae_knn = mean_absolute_error(true_speeds, pred_speed_knn)
print("=== အပိုင်း (၁) - Missing Value Imputation တိကျမှု နှိုင်းယှဉ်ချက် ===")
print(f"စမ်းသပ်ဖျောက်ထားသော အတန်းအရေအတွက် : {np.sum(mask)} ခု")
print(f"SimpleImputer (Mean) ပျမ်းမျှအမှား (MAE) : {mae_mean:.3f} m/s")
print(f"KNNImputer (ML-Based) ပျမ်းမျှအမှား (MAE): {mae_knn:.3f} m/s\n")
# ဖိုင်ထဲတွင် အမှန်တကယ် NaN ဖြစ်နေသော Eric ၏ အတန်းများကို KNNImputer ဖြင့် ပြန်ဖြည့်ကြည့်ခြင်း
eric_all = birddata[birddata['bird_name'] == 'Eric'][imp_features].copy()
real_nan_mask = eric_all['speed_2d'].isna()
eric_all_filled = scaler_imp.inverse_transform(knn_imp.transform(scaler_imp.transform(eric_all)))
eric_all['imputed_speed_2d'] = eric_all_filled[:, 0]
print("--- ဖိုင်ထဲရှိ တကယ့် NaN အတန်းများကို KNNImputer မှ ခန့်မှန်းဖြည့်သွင်းပေးမှု နမူနာ ၅ ခု ---")
print(eric_all[real_nan_mask][['altitude', 'latitude', 'longitude', 'hour', 'imputed_speed_2d']].head(5).round(2))
print()
# =============================================================================
# အပိုင်း (၂) - StratifiedKFold (Random) vs. GroupKFold (Grouped by Date)
# =============================================================================
# Cyclical direction ဖန်တီးခြင်း (direction တွင် NaN ရှိသောနေရာများကို KNNImputer က အလိုအလျောက် ဖြည့်ပေးပါမည်)
dir_rad = np.radians(birddata['direction'])
birddata['dir_sin'] = np.sin(dir_rad)
birddata['dir_cos'] = np.cos(dir_rad)
clf_features = ['speed_2d', 'altitude', 'dir_sin', 'dir_cos', 'hour']
# တွက်ချက်မှု မြန်ဆန်စေရန် ရက်စွဲအပြည့်အစုံ ၂၅၀ ရက်စာကို စနစ်တကျ ရွေးထုတ်ပါမည်
unique_dates = birddata['date'].unique()
selected_dates = rng.choice(unique_dates, size=min(250, len(unique_dates)), replace=False)
cv_df = birddata[birddata['date'].isin(selected_dates)].reset_index(drop=True)
X_cv = cv_df[clf_features]
y_cv = cv_df['bird_name']
groups_date = cv_df['date']
# End-to-End ML Pipeline (Data Leakage ကင်းစင်စေရန် Fold တိုင်းတွင် သီးခြားစီ Fit လုပ်ပါမည်)
ml_pipeline = Pipeline([
('scaler', StandardScaler()),
('imputer', KNNImputer(n_neighbors=5, weights='distance')),
('classifier', RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1))
])
# ၁။ သာမန် Random StratifiedKFold (အချိန်ဆက်စပ်မှု Leakage ရှိသော စစ်ဆေးနည်း)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_random = cross_val_score(ml_pipeline, X_cv, y_cv, cv=skf, scoring='accuracy', n_jobs=-1)
# ၂။ GroupKFold by Date (ရက်စွဲအလိုက် သီးခြားခွဲ၍ စစ်ဆေးသော စစ်မှန်သည့် နည်းလမ်း)
gkf = GroupKFold(n_splits=5)
scores_grouped = cross_val_score(ml_pipeline, X_cv, y_cv, cv=gkf, groups=groups_date, scoring='accuracy', n_jobs=-1)
print("=== အပိုင်း (၂) - 5-Fold Cross-Validation Accuracy နှိုင်းယှဉ်ချက် ===")
print(f"1. StratifiedKFold (Random Split - Leaky) : {scores_random.mean()*100:.2f}% (+/- {scores_random.std()*100:.2f}%)")
print(f"2. GroupKFold (Grouped by Date - Honest) : {scores_grouped.mean()*100:.2f}% (+/- {scores_grouped.std()*100:.2f}%)")
# =============================================================================
# အပိုင်း (၃) - ရလဒ်များကို ဂရပ် (၂) ခုဖြင့် ပုံဖော်ခြင်း
# =============================================================================
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6.5))
# --- ဘယ်ဘက်ဂရပ် (ax1): Altitude vs Imputed Speed (Mean Imputer vs KNNImputer) ---
sample_alt = X_true.loc[mask, 'altitude'].to_numpy()
ax1.scatter(sample_alt, true_speeds, color='lightgray', s=18, alpha=0.6, label='Actual Speed (Hidden Ground Truth)')
ax1.scatter(sample_alt, pred_speed_knn, color='#2ca02c', s=20, alpha=0.65, label=f'KNNImputer Prediction (MAE={mae_knn:.2f})')
ax1.axhline(pred_speed_mean[0], color='#d62728', linestyle='--', linewidth=2, label=f'SimpleImputer Mean (MAE={mae_mean:.2f})')
ax1.set_title("Imputation Behavior: Altitude vs. Reconstructed Speed", fontsize=12, fontweight='bold')
ax1.set_xlabel("Altitude (meters)")
ax1.set_ylabel("Flight Speed 2D (m/s)")
ax1.set_xlim(-50, 1200)
ax1.set_ylim(-1, 22)
ax1.legend(loc='upper left')
ax1.grid(True, linestyle='--', alpha=0.5)
# --- ညာဘက်ဂရပ် (ax2): 5-Fold Accuracy (Random Split vs GroupKFold by Date) ---
folds = np.arange(1, 6)
width = 0.35
rects1 = ax2.bar(folds - width/2, scores_random * 100, width, label='StratifiedKFold (Random / Leaky)', color='#e67e22', edgecolor='black')
rects2 = ax2.bar(folds + width/2, scores_grouped * 100, width, label='GroupKFold (Grouped by Date / Honest)', color='#1f77b4', edgecolor='black')
ax2.set_title("Cross-Validation Trap: Random Split vs. GroupKFold (by Date)", fontsize=12, fontweight='bold')
ax2.set_xlabel("Cross-Validation Fold Number")
ax2.set_ylabel("Classification Accuracy (%)")
ax2.set_xticks(folds)
ax2.set_xticklabels([f'Fold {i}' for i in folds], fontweight='bold')
ax2.set_ylim(0, 105)
ax2.legend(loc='lower right')
ax2.grid(True, axis='y', linestyle='--', alpha=0.5)
for rect in rects1:
h = rect.get_height()
ax2.text(rect.get_x() + rect.get_width()/2., h + 1.2, f'{h:.1f}%', ha='center', va='bottom', fontsize=8.5, fontweight='bold')
for rect in rects2:
h = rect.get_height()
ax2.text(rect.get_x() + rect.get_width()/2., h + 1.2, f'{h:.1f}%', ha='center', va='bottom', fontsize=8.5, fontweight='bold')
plt.tight_layout()
plt.show()
၃။ ရလဒ်များနှင့် ဂရပ်များကို အဓိပ္ပာယ်ဖွင့်ဆိုခြင်း
အထက်ပါဂရပ်ပုံသည် Machine Learning လက်တွေ့နယ်ပယ်၏ အလွန်အရေးကြီးသော သဘောတရား (၂) ခုကို ထင်ရှားစွာ ပြသနေပါသည်— ။
KNNImputer သည် ရိုးရိုးပျမ်းမျှကိန်းသေဖြင့် ဖြည့်ခြင်းထက် အမှားပမာဏ (MAE) ကို သိသိသာသာ လျှော့ချပေးနိုင်ခဲ့ပြီး၊ ညာဘက်ဂရပ်တွင်မူ Feature ရွေးချယ်မှုနှင့် မျိုးစိတ်တူငှက်များ၏ အပြုအမူ ထပ်တူကျနေမှုကြောင့် Classification Accuracy မှာ ၄၇% မှ ၄၉% ဝန်းကျင် တွင်သာ ရှိနေကြောင်း တွေ့ရပါသည်၁။ ဘယ်ဘက်ဂရပ် ဝေဖန်သုံးသပ်ချက် (KNNImputer vs. SimpleImputer)
- အမှားပမာဏ လျော့ကျသွားမှု (Error Reduction)
SimpleImputer (Mean)သည် ပျောက်ဆုံးနေသော အမြန်နှုန်းအားလုံးကို2.4 m/sဝန်းကျင်ရှိ အနီရောင်မျဉ်းပြတ် တစ်ကြောင်းတည်းဖြင့် တစ်သမတ်တည်း ဖြည့်သွင်းသဖြင့် ပျမ်းမျှအမှားMAE = 2.22 m/sရှိနေပါသည်။ KNNImputerကမူ အမြင့်ပေနှင့် တည်နေရာကို ကြည့်၍ ခန့်မှန်းပေးနိုင်သောကြောင့်MAE = 1.90 m/sအထိ လျော့ကျသွားပြီး တိကျမှု ၁၄.၄% ခန့် ပိုမိုကောင်းမွန်လာပါသည်။ - ဒေတာဖြန့်ကျက်မှုကို ဖမ်းယူနိုင်စွမ်း အစိမ်းရောင်အစက်များ (
KNNImputer) သည် အမြင့်ပေ0–180mနှင့် အမြန်နှုန်း0–4 m/sကြားရှိ သိပ်သည်းသော အနားယူ/အစာရှာဇုန်ကိုသာမက အမြင့်ပေ400mမှ1,100mကျော်အထိ ပျံသန်းနေသော အမှတ်များ၏ အမြန်နှုန်းမြင့်မားမှု (5–18 m/s) ကိုပါ မူလမီးခိုးရောင်အစက်များ၏ ပုံသဏ္ဌာန်အတိုင်း လိုက်ပါပုံဖော်နိုင်ခဲ့သည်။ - ဝေဖန်ထောက်ပြစရာ အားနည်းချက် (Smoothing / Regression Toward the Mean) မီးခိုးရောင်အစက်များတွင်
15 m/sမှ22 m/sအထိ အလွန်မြန်သော အမှတ်အချို့ ရှိနေသော်လည်း အစိမ်းရောင်အစက်များတွင်15 m/sအထက် အမှတ်အရေအတွက် အလွန်နည်းပါးနေသည်ကို သတိပြုမိပါလိမ့်မည်။ အကြောင်းမှာ KNNImputerသည် အနီးစပ်ဆုံး အိမ်နီးချင်းk=7ခု၏ ပျမ်းမျှကို ပြန်ယူတွက်ချက်ရသဖြင့် အလွန်အမင်း အစွန်းရောက်နေသော အမြန်နှုန်းများ (Extreme Spikes) ကို အလယ်အလတ်တန်ဖိုးဘက်သို့ ပြန်လည်ဆွဲချလိုက်သောကြောင့် ဖြစ်သည်။
၂။ ညာဘက်ဂရပ် ဝေဖန်သုံးသပ်ချက် (StratifiedKFold vs. GroupKFold)
ညာဘက်ဂရပ်ရှိ ရလဒ်ကိန်းဂဏန်းများသည် Data Science ရှုထောင့်မှ ကြည့်လျှင် အလွန်စိတ်ဝင်စားဖွယ်ရာ ကောင်းပါသည်-
- Accuracy ၄၇%–၄၉% ဝန်းကျင်သာ ရှိနေရခြင်း အကြောင်းရင်း
- Fold ၅ ခုလုံးတွင်
StratifiedKFold၏ ပျမ်းမျှ Accuracy မှာ48.68%(48.7%,49.3%,48.6%,48.1%,48.7%) ဖြစ်ပြီးGroupKFold၏ ပျမ်းမျှ Accuracy မှာ47.52%(48.3%,47.4%,47.0%,47.5%,47.4%) ဖြစ်ပါသည်။ - ဝေဖန်သုံးသပ်ချက် ငှက် ၃ ကောင် (
Eric,Nico,Sanne) ကို ကျပန်းခန့်မှန်းလျှင်33.3%ရမည်ဖြစ်ရာ ယခုရလဒ်~48%သည် ကျပန်းထက် ပိုကောင်းသော်လည်း တိကျမှု နည်းပါးနေပါသည်။ အဘယ်ကြောင့်ဆိုသော် ဤငှက် ၃ ကောင်စလုံးသည် မျိုးစိတ်တူ စင်ရော်ငှက်များ (Lesser Black-backed Gulls) ဖြစ်ကြသောကြောင့် ၎င်းတို့၏ တစ်ခဏတာ အမြန်နှုန်း ( speed_2d)၊ အမြင့် (altitude) နှင့် ဦးတည်ရာ (direction) တို့သည် ရုပ်ပိုင်းဆိုင်ရာအရ ထပ်တူနီးပါး တူညီနေသောကြောင့် ဖြစ်သည်။
- Leakage ကွာဟချက် (Optimism Gap)
~1.16%သာ ရှိနေခြင်း အကြောင်းရင်း- Fold ၁ ခုချင်းစီတိုင်းတွင် လိမ္မော်ရောင်တိုင် (
StratifiedKFold) သည် အပြာရောင်တိုင် (GroupKFold) ထက်0.4%မှ1.9%အထိ တစ်သမတ်တည်း ပိုမြင့်နေခြင်း ကမိနစ်ပိုင်းခြား မှတ်တမ်းများကြောင့် ဖြစ်ပေါ်သည့် Temporal Leakage ရှိနေကြောင်း အတည်ပြုပေးပါသည်။ - သို့သော် ကွာဟချက်
1.16%သာ ရှိပြီး မကြီးမားရခြင်းမှာ ကျွန်ုပ်တို့သည်latitudeနှင့်longitudeကို Feature စာရင်းထဲမှ တမင်ချန်လှပ်ထားခဲ့သောကြောင့် ဖြစ်သည်။ အကယ်၍latitudeနှင့်longitudeကိုပါ ထည့်သွင်းခဲ့ပါက ငှက်တစ်ကောင်ချင်းစီ၏ နေ့စဉ်ကျက်စားရာ တည်နေရာ မတူညီမှုကြောင့်StratifiedKFoldသည်95%ကျော်အထိ ထိုးတက်သွားပြီးGroupKFoldနှင့် ကွာဟချက် အလွန်ကြီးမားသွားမည် ဖြစ်သည်။
၃။ မော်ဒယ်စွမ်းဆောင်ရည် ပိုမိုကောင်းမွန်လာစေရန် အကြံပြုချက်များ
တည်နေရာ (
latitude, longitude) ကို မသုံးဘဲ ပျံသန်းမှုအမူအကျင့် သက်သက်ဖြင့် ငှက် ၃ ကောင်ကို ပိုမိုတိကျစွာ ခွဲခြားနိုင်ရန် အောက်ပါနည်းလမ်းများဖြင့် အဆင့်မြှင့်တင်နိုင်ပါသည်။- Rolling Window Statistics များ ဖန်တီးခြင်း စက္ကန့်ပိုင်း/မိနစ်ပိုင်း တစ်ခုချင်းစီ၏ တန်ဖိုးအစား ၁ နာရီအတွင်း ပျမ်းမျှအမြန်နှုန်း (
rolling_mean_speed)၊ အမြန်နှုန်း အတက်အကျ ပြောင်းလဲမှု (rolling_std_speed) နှင့် အများဆုံး ရောက်ရှိခဲ့သည့် အမြင့် (rolling_max_alt) တို့ကို Feature အဖြစ် ထည့်သွင်းခြင်းဖြင့် ငှက်တစ်ကောင်ချင်းစီ၏ ခွန်အားနှင့် ပျံသန်းမှုစတိုင် ကွာခြားချက်ကို မော်ဒယ်က ပိုမိုဖမ်းယူနိုင်ပါလိမ့်မည်။ - Class Balance စစ်ဆေးခြင်း
bird_tracking.csvဖိုင်ထဲတွင် ငှက် ၃ ကောင်၏ မှတ်တမ်းအရေအတွက် မညီမျှမှု (Class Imbalance) ရှိနေနိုင်သဖြင့်RandomForestClassifier(class_weight='balanced')ကို အသုံးပြုကြည့်သင့်ပါသည်။

No comments:
Post a Comment
Note: Only a member of this blog may post a comment.