Monday, November 16, 2026

Bird Migration & Flight Pattern Analysis (Part-9)

၁။ နောက်ခံသဘောတရားများ (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


  1. အပိုင်း (၁) မူလဒေတာထဲမှ အကောင်းပကတိ ရှိနေသော speed_2d တန်ဖိုး ၁၅% ကို တမင်ဖျောက် (NaN လုပ်) ကြည့်ပြီး SimpleImputer (Mean) နှင့် KNNImputer တို့၏ အမှားပမာဏ (MAE) ကို နှိုင်းယှဉ်ပြခြင်း၊ ထို့နောက် ဖိုင်ထဲရှိ တကယ့် NaN အတန်းများကို ပြန်လည်ဖြည့်သွင်းပြခြင်း။

  2. အပိုင်း (၂) 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) ကို မသုံးဘဲ ပျံသန်းမှုအမူအကျင့် သက်သက်ဖြင့် ငှက် ၃ ကောင်ကို ပိုမိုတိကျစွာ ခွဲခြားနိုင်ရန် အောက်ပါနည်းလမ်းများဖြင့် အဆင့်မြှင့်တင်နိုင်ပါသည်။

  1. Rolling Window Statistics များ ဖန်တီးခြင်း စက္ကန့်ပိုင်း/မိနစ်ပိုင်း တစ်ခုချင်းစီ၏ တန်ဖိုးအစား ၁ နာရီအတွင်း ပျမ်းမျှအမြန်နှုန်း (rolling_mean_speed)၊ အမြန်နှုန်း အတက်အကျ ပြောင်းလဲမှု (rolling_std_speed) နှင့် အများဆုံး ရောက်ရှိခဲ့သည့် အမြင့် (rolling_max_alt) တို့ကို Feature အဖြစ် ထည့်သွင်းခြင်းဖြင့် ငှက်တစ်ကောင်ချင်းစီ၏ ခွန်အားနှင့် ပျံသန်းမှုစတိုင် ကွာခြားချက်ကို မော်ဒယ်က ပိုမိုဖမ်းယူနိုင်ပါလိမ့်မည်။

  2. 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.