ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared
ผู้เรียนจะคำนวณตัวชี้วัดค่าคลาดเคลื่อนจากผลลัพธ์การถดถอย เข้าใจการขึ้นกับสเกลของ MAE/RMSE และใช้ R-squared เป็นค่ามาตรฐานวัดความสอดคล้องของแบบจำลอง
ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared เป็นบทเรียน Machine Learning Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Machine Learning Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดการถดถอยจึงต้องใช้เมตริกที่แตกต่างกัน
แบบจำลองการถดถอยทำนาย ค่าต่อเนื่อง เช่น ราคาบ้าน อุณหภูมิ และปริมาณการขาย แตกต่างจากการจำแนกที่ผลทำนายถูกหรือผิด การทำนายแบบถดถอยแทบไม่มีทางถูกต้องตรงทั้งหมด คำถามคือ ผลทำนายคลาดเคลื่อนไปมากเพียงใด เมตริกการถดถอยใช้วัดความแตกต่างระหว่างค่าที่ทำนายกับค่าจริง เมตริกแต่ละแบบให้น้ำหนักกับข้อผิดพลาดแตกต่างกัน บางแบบลงโทษข้อผิดพลาดขนาดใหญ่มากกว่าขนาดเล็ก บางแบบทนต่อค่าผิดปกติ และบางแบบปรับให้อยู่ในรูปที่ตีความได้เป็นสัดส่วนของความแปรปรวนที่อธิบายได้ การเลือกเมตริกที่เหมาะสมขึ้นอยู่กับโครงสร้างต้นทุนของข้อผิดพลาดในปัญหานั้น
import numpy as np
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
errors = y_pred - y_true
print('Actual: ', y_true)
print('Predicted:', y_pred)
print('Errors: ', errors) # Some positive, some negative
print('We need metrics that summarise these errors into a single number.')MAE: ค่าเฉลี่ยความคลาดเคลื่อนสัมบูรณ์
MAE = mean(|y_true - y_pred|) ค่าเฉลี่ยความคลาดเคลื่อนสัมบูรณ์คำนวณค่าเฉลี่ยของผลต่างสัมบูรณ์ระหว่างค่าที่ทำนายกับค่าจริง โดยมี หน่วยเดียวกับตัวแปรเป้าหมาย เช่น MAE ของราคาบ้านเท่ากับ $15,000 หมายความว่าผลทำนายคลาดเคลื่อนโดยเฉลี่ย $15,000 MAE ให้น้ำหนักกับข้อผิดพลาดทุกขนาดแบบเชิงเส้น ผลทำนายที่ผิดเป็นสองเท่าจะมีต้นทุนเป็นสองเท่าพอดี MAE ทนต่อค่าผิดปกติ เพราะไม่ได้ยกกำลังสองข้อผิดพลาด ควรใช้เมตริกนี้เมื่อการกระจายของข้อผิดพลาดค่อนข้างสมมาตร และไม่ต้องการให้ข้อผิดพลาดจากค่าผิดปกติมีอิทธิพลต่อค่ารวมมากเกินไป
import numpy as np
from sklearn.metrics import mean_absolute_error
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
# Manual calculation
mae_manual = np.mean(np.abs(y_true - y_pred))
print('Manual MAE:', mae_manual) # |10|+|10|+|10|+|10|+|20| / 5 = 12
# Sklearn
mae = mean_absolute_error(y_true, y_pred)
print('Sklearn MAE:', mae)
print(f'Interpretation: predictions are off by {mae:.1f} units on average')MSE: ค่าเฉลี่ยความคลาดเคลื่อนกำลังสอง
MSE = mean((y_true - y_pred)^2) ค่าเฉลี่ยความคลาดเคลื่อนกำลังสองจะยกกำลังสองข้อผิดพลาดแต่ละรายการก่อนหาค่าเฉลี่ย ทำให้ MSE ไวต่อค่าผิดปกติ ข้อผิดพลาด 10 จากผลทำนายเพียงรายการเดียวมีส่วนต่อ MSE เท่ากับ 100 ขณะที่ข้อผิดพลาด 1 มีส่วนเพียง 1 ดังนั้นข้อผิดพลาดจากค่าผิดปกติจึงถูกขยายแบบกำลังสอง MSE เป็นฟังก์ชันการสูญเสียตามธรรมชาติของการถดถอยเชิงเส้น (การทำให้ MSE ต่ำที่สุดจะได้คำตอบกำลังสองน้อยที่สุดแบบปกติ) หน่วยของ MSE เป็นกำลังสองของตัวแปรเป้าหมาย (ดอลลาร์^2 สำหรับราคาบ้าน) จึงตีความได้ยากกว่า MAE แต่สะดวกในทางคณิตศาสตร์สำหรับการหาค่าที่เหมาะสม
import numpy as np
from sklearn.metrics import mean_squared_error
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
# Squaring emphasises large errors
errors = y_true - y_pred
print('Squared errors:', errors**2) # 100, 100, 100, 100, 400
mse = mean_squared_error(y_true, y_pred)
print(f'MSE: {mse}') # 160.0
print(f'Units: (target units)^2 -- less interpretable than MAE')
print(f'The large error at last sample contributes 400/5=80 to MSE alone')RMSE: รากที่สองของค่าเฉลี่ยความคลาดเคลื่อนกำลังสอง
RMSE = sqrt(MSE) รากที่สองของค่าเฉลี่ยความคลาดเคลื่อนกำลังสองจะนำ MSE กลับมาเป็นหน่วยเดิมของตัวแปรเป้าหมาย (ดอลลาร์ ไม่ใช่ดอลลาร์^2) ด้วยการหารากที่สอง นี่เป็นเมตริกการถดถอยที่มีการรายงานอย่างแพร่หลายที่สุด เพราะ ตีความได้ในหน่วยเดียวกับตัวแปรเป้าหมาย และยังคงลงโทษข้อผิดพลาดขนาดใหญ่มากกว่าขนาดเล็ก RMSE ของราคาบ้านเท่ากับ $20,000 หมายความว่าขนาดข้อผิดพลาดโดยทั่วไปอยู่ที่ $20,000 แม้ข้อผิดพลาดจากค่าผิดปกติจะได้รับน้ำหนักมากกว่าใน MAE RMSE จะมีค่า >= MAE เสมอ สำหรับผลทำนายชุดเดียวกัน โดยช่องว่างระหว่างค่านี้จะเพิ่มขึ้นเมื่อมีข้อผิดพลาดจากค่าผิดปกติ
import numpy as np
from sklearn.metrics import mean_squared_error
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
print(f'MSE: {mse:.2f} (units: target^2)')
print(f'RMSE: {rmse:.2f} (units: same as target)')
# RMSE always >= MAE
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(y_true, y_pred)
print(f'MAE: {mae:.2f}')
print(f'MAE <= RMSE: {mae <= rmse}')MAE เทียบกับ RMSE: ควรใช้แบบใดเมื่อใด
เลือก MAE เมื่อ: คาดว่าจะมีค่าผิดปกติและไม่ต้องการให้ค่าผิดปกติเหล่านั้นครอบงำเมตริก ต้องการเมตริกที่ตีความได้ง่ายว่าเป็นข้อผิดพลาดโดยเฉลี่ย และข้อผิดพลาดที่มีขนาดต่างกันมีความสำคัญตามสัดส่วนเท่า ๆ กัน เลือก RMSE เมื่อ: ข้อผิดพลาดขนาดใหญ่มีต้นทุนสูงกว่าข้อผิดพลาดขนาดเล็กมาก (เช่น การทำนายความต้องการใช้ไฟฟ้า ซึ่งการคลาดเคลื่อน 10 เท่ามีต้นทุนสูงกว่าการคลาดเคลื่อน 1 เท่ามาก) ฟังก์ชันการสูญเสียที่ใช้ฝึกคือ MSE และต้องการให้การประเมินสอดคล้องกับการฝึก หรือความแปรปรวนของผลทำนายสำคัญกว่าข้อผิดพลาดมัธยฐาน ในทางปฏิบัติ ให้รายงานทั้ง MAE และ RMSE เสมอ หาก RMSE >> MAE แสดงว่าข้อผิดพลาดจากค่าผิดปกติมีอิทธิพลสูง หาก RMSE ≈ MAE แสดงว่าข้อผิดพลาดกระจายตัวอย่างสม่ำเสมอ
import numpy as np
from sklearn.metrics import mean_absolute_error, mean_squared_error
# Two prediction sets with same MAE but different RMSE
y_true = np.array([100.0, 200.0, 300.0, 400.0, 500.0])
# Set 1: uniform errors of 10
pred1 = y_true + 10
# Set 2: mostly 0 error, one huge error of 50
pred2 = y_true.copy()
pred2[-1] += 50
pred2[0:4] += 0
for name, pred in [('Uniform errors', pred1), ('One outlier error', pred2)]:
mae = mean_absolute_error(y_true, pred)
rmse = np.sqrt(mean_squared_error(y_true, pred))
print(f'{name}: MAE={mae:.2f}, RMSE={rmse:.2f}')R-Squared: สัมประสิทธิ์การกำหนด
R^2 = 1 - MSE(model) / Var(y_true) R-squared ใช้วัด สัดส่วนความแปรปรวนของตัวแปรเป้าหมายที่แบบจำลองอธิบายได้ R^2 = 1.0 หมายถึงผลทำนายสมบูรณ์แบบ (ความแปรปรวนของส่วนเหลือเป็นศูนย์) R^2 = 0.0 หมายถึงแบบจำลองไม่ได้ดีกว่าการทำนายค่าเฉลี่ยของ y ให้กับทุกตัวอย่าง R^2 อาจเป็น ค่าลบ หากแบบจำลองแย่กว่าค่าพื้นฐานที่ใช้ค่าเฉลี่ย R^2 ไม่ขึ้นกับสเกล ค่า 0.85 มีความหมายเหมือนกันไม่ว่าตัวแปรเป้าหมายจะเป็นราคาบ้านหรืออุณหภูมิ จึงเป็นเมตริกหลักสำหรับเปรียบเทียบแบบจำลองการถดถอยในปัญหาหรือสเกลที่แตกต่างกัน
import numpy as np
from sklearn.metrics import r2_score
y_true = np.array([100, 150, 200, 250, 300], dtype=float)
y_pred = np.array([110, 140, 210, 240, 320], dtype=float)
y_mean = np.mean(y_true)
# Manual R^2
ss_res = np.sum((y_true - y_pred)**2) # Residual sum of squares
ss_tot = np.sum((y_true - y_mean)**2) # Total sum of squares
r2_manual = 1 - ss_res / ss_tot
print(f'SS_res (model): {ss_res}')
print(f'SS_tot (mean): {ss_tot}')
print(f'R^2 manual: {r2_manual:.4f}')
print(f'R^2 sklearn: {r2_score(y_true, y_pred):.4f}')Adjusted R-Squared: การลงโทษตัวแปรคุณลักษณะที่เพิ่มเข้ามา
การเพิ่มตัวแปรคุณลักษณะให้กับแบบจำลองการถดถอยจะทำให้ R^2 บนข้อมูลฝึกเพิ่มขึ้นเสมอ (หรือคงเดิม) แม้ตัวแปรเหล่านั้นจะเป็นเพียงสัญญาณรบกวนแบบสุ่ม Adjusted R^2 แก้ไขปัญหานี้ด้วยการลงโทษตามจำนวนตัวแปรคุณลักษณะ โดยค่าจะลดลงเมื่อเพิ่มตัวแปรที่ไม่ได้ช่วยปรับปรุงแบบจำลองมากพอที่จะคุ้มกับความซับซ้อนที่เพิ่มขึ้น สูตรคือ Adj R^2 = 1 - (1 - R^2) * (n-1) / (n-p-1) โดย n = จำนวนตัวอย่าง และ p = จำนวนตัวแปรคุณลักษณะ ใช้ adjusted R^2 เมื่อ เปรียบเทียบแบบจำลองที่มีจำนวนตัวแปรคุณลักษณะแตกต่างกัน เพื่อหลีกเลี่ยงการเลือกแบบจำลองที่ซับซ้อนเกินไป
import numpy as np
def adjusted_r2(y_true, y_pred, n_features):
n = len(y_true)
r2 = r2_score(y_true, y_pred)
return 1 - (1 - r2) * (n - 1) / (n - n_features - 1)
from sklearn.metrics import r2_score
from sklearn.linear_model import LinearRegression
import numpy as np
np.random.seed(42)
n = 100
X_2 = np.random.randn(n, 2)
X_10 = np.random.randn(n, 10) # 8 noise features added
y = X_2[:, 0] * 2 + X_2[:, 1] + np.random.randn(n) * 0.5
for X, p in [(X_2, 2), (X_10, 10)]:
pred = LinearRegression().fit(X, y).predict(X)
print(f'p={p}: R^2={r2_score(y,pred):.3f}, Adj R^2={adjusted_r2(y,pred,p):.3f}')MAPE: ค่าเฉลี่ยความคลาดเคลื่อนสัมบูรณ์แบบเปอร์เซ็นต์
MAPE = 100 * mean(|y_true - y_pred| / |y_true|) ค่าเฉลี่ยความคลาดเคลื่อนสัมบูรณ์แบบเปอร์เซ็นต์แสดงข้อผิดพลาดเป็น เปอร์เซ็นต์ของค่าจริง ทำให้ไม่ขึ้นกับสเกลและตีความได้ง่าย เช่น MAPE 5% หมายความว่าผลทำนายคลาดเคลื่อนจากค่าจริงโดยเฉลี่ย 5% ข้อจำกัด: MAPE ไม่สามารถนิยามได้เมื่อค่าจริงเป็นศูนย์ (การหารด้วยศูนย์) และไม่สมมาตร โดยการทำนายต่ำกว่าค่าจริงจะให้ข้อผิดพลาดสูงกว่าการทำนายสูงกว่าค่าจริงในปริมาณเท่ากัน ใช้ MAPE กับงานพยากรณ์ (ยอดขาย ความต้องการ) ที่ผู้มีส่วนเกี่ยวข้องเข้าใจความคลาดเคลื่อนเป็นเปอร์เซ็นต์ได้โดยธรรมชาติ
import numpy as np
def mape(y_true, y_pred):
y_true = np.array(y_true, dtype=float)
# Avoid division by zero
mask = y_true != 0
return 100 * np.mean(np.abs((y_true[mask] - np.array(y_pred)[mask]) / y_true[mask]))
y_true = [100, 200, 300, 400, 500]
y_pred = [110, 190, 315, 380, 510]
print(f'MAPE: {mape(y_true, y_pred):.2f}%')
# Asymmetry example
print(f'Over by 50: MAPE = {mape([100],[150]):.1f}%')
print(f'Under by 50: MAPE = {mape([100],[50]):.1f}%')
# Underprediction by 50% gives 50% error; overprediction by 50% also 50% (same amount, asymmetric impact)การคำนวณเมตริกการถดถอยด้วย scikit-learn
ไซคิต-เลิร์นมีเมตริกการถดถอยหลักทั้งหมดอยู่ใน sklearn.metrics เมื่อใช้ cross_val_score ให้ส่ง scoring='neg_mean_squared_error' (เป็นค่าลบเพราะตามธรรมเนียมแล้วค่าที่สูงกว่าถือว่าดีกว่า) แล้วกลับเครื่องหมายผลลัพธ์ หรือใช้ 'neg_root_mean_squared_error' เพื่อรับค่า RMSE โดยตรง สำหรับ R^2 ให้ใช้ scoring='r2' ให้รายงานหลายเมตริกเสมอ: MAE สำหรับข้อผิดพลาดสัมบูรณ์โดยเฉลี่ย RMSE เพื่อแสดงความไวต่อค่าผิดปกติ และ R^2 สำหรับความแปรปรวนที่อธิบายได้ วิธีนี้ทำให้เห็นภาพประสิทธิภาพของแบบจำลองได้ครบถ้วน
from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
for metric in ['neg_mean_absolute_error', 'neg_root_mean_squared_error', 'r2']:
scores = cross_val_score(LinearRegression(), X, y, cv=5, scoring=metric)
mean_val = scores.mean()
if 'neg' in metric:
mean_val = -mean_val
print(f'{metric.replace("neg_",""):30}: {mean_val:.4f}')การวิเคราะห์ส่วนเหลือ: การวินิจฉัยคุณภาพแบบจำลอง
นอกเหนือจากเมตริกสรุปแล้ว การวิเคราะห์ส่วนเหลือ จะเผยให้เห็นว่าสมมติฐานของแบบจำลองเป็นไปตามที่กำหนดหรือไม่ ให้พล็อตส่วนเหลือ (y_true - y_pred) เทียบกับค่าที่ทำนาย แบบจำลองที่ดีจะแสดงว่า: (1) ส่วนเหลือกระจายตัวแบบสุ่มรอบศูนย์โดยไม่มีรูปแบบ (ความแปรปรวนคงที่) (2) ไม่มีความสัมพันธ์ระหว่างขนาดของส่วนเหลือกับค่าที่ทำนาย (ไม่มีความแปรปรวนไม่คงที่) สัญญาณเตือน: รูปทรงกรวย (ส่วนเหลือเพิ่มขึ้นตามค่าที่ทำนาย) บ่งชี้ว่าแบบจำลองอาจต้องแปลงลอการิทึม ส่วนรูปแบบโค้งบ่งชี้ว่าความสัมพันธ์ไม่เป็นเชิงเส้นและกำหนดแบบจำลองไม่ถูกต้อง ควรวิเคราะห์ส่วนเหลือก่อนนำแบบจำลองการถดถอยใด ๆ ไปใช้งานเสมอ
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
X, y = fetch_california_housing(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=42)
model = LinearRegression()
model.fit(X_tr, y_tr)
y_pred = model.predict(X_te)
residuals = y_te - y_pred
plt.figure(figsize=(8, 4))
plt.scatter(y_pred, residuals, alpha=0.3, s=10)
plt.axhline(0, color='red', linestyle='--')
plt.xlabel('Predicted Value')
plt.ylabel('Residual (Actual - Predicted)')
plt.title('Residual Plot')
plt.show()การเลือกเมตริกการถดถอยที่เหมาะสม
แนวทางปฏิบัติ: ใช้ MAE เมื่อคุณต้องการลดข้อผิดพลาดสัมบูรณ์โดยเฉลี่ย และไม่ต้องการเน้นค่าผิดปกติมากเกินไป ซึ่งเป็นตัวเลือกที่ทนทานสำหรับการรายงานทั่วไป ใช้ RMSE เมื่อแบบจำลองของคุณลด MSE ระหว่างการฝึกและต้องการให้การประเมินสอดคล้องกัน หรือเมื่อข้อผิดพลาดขนาดใหญ่มีต้นทุนสูงเป็นพิเศษ (การพยากรณ์ความต้องการ การทำนายพลังงาน) ใช้ R^2 เพื่อเปรียบเทียบแบบจำลองบนชุดข้อมูลเดียวกัน หรืออธิบายคุณภาพของแบบจำลองแก่ผู้มีส่วนเกี่ยวข้องที่ไม่ใช่ผู้เชี่ยวชาญทางเทคนิคในรูปของ “เปอร์เซ็นต์ความแปรปรวนที่อธิบายได้” ใช้ MAPE สำหรับการพยากรณ์ทางธุรกิจที่ผู้มีส่วนเกี่ยวข้องคุ้นเคยกับการพูดถึงความคลาดเคลื่อนจากค่าจริงเป็นเปอร์เซ็นต์
# Metric selection guide
def recommend_metric(has_outliers, need_interpretable_units, compare_across_scales):
if compare_across_scales:
return 'R^2 (scale-independent, 0-1 range)'
elif need_interpretable_units and has_outliers:
return 'MAE (same units as target, robust to outliers)'
elif need_interpretable_units:
return 'RMSE (same units, penalises large errors more)'
else:
return 'MSE (convenient for optimisation, same loss as linear regression)'
print(recommend_metric(True, True, False)) # MAE
print(recommend_metric(False, True, False)) # RMSE
print(recommend_metric(False, False, True)) # R^2ตรวจสอบความเข้าใจอย่างรวดเร็ว
ทดสอบความเข้าใจแนวคิดการเรียนรู้ของเครื่องด้วย Python จากบทเรียนนี้
สรุปบทเรียน
ในบทเรียนนี้ คุณได้เรียนรู้ว่า MAE หาค่าเฉลี่ยของข้อผิดพลาดสัมบูรณ์และทนต่อค่าผิดปกติ RMSE ยกกำลังสองข้อผิดพลาดและลงโทษความคลาดเคลื่อนขนาดใหญ่มากกว่า R^2 ใช้วัดสัดส่วนความแปรปรวนที่อธิบายได้ (0 = ค่าพื้นฐานจากค่าเฉลี่ย, 1 = สมบูรณ์แบบ) และ ช่องว่างระหว่าง MAE กับ RMSE เผยให้เห็นการกระจุกตัวของข้อผิดพลาดจากค่าผิดปกติ ต่อไปเราจะสำรวจการเลือกเมตริกที่เหมาะสมกับปัญหาทางธุรกิจเฉพาะของคุณ
เรียนรู้ Python ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 30
- บทเรียน
- 120
คำถามที่พบบ่อย
บทเรียน “ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Machine Learning Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared”
ผู้เรียนจะคำนวณตัวชี้วัดค่าคลาดเคลื่อนจากผลลัพธ์การถดถอย เข้าใจการขึ้นกับสเกลของ MAE/RMSE และใช้ R-squared เป็นค่ามาตรฐานวัดความสอดคล้องของแบบจำลอง คุณปฏิบัติ Machine Learning Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Machine Learning Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Machine Learning Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Machine Learning Academy นี้ได้ไหม
ได้ บทเรียน Machine Learning Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ตัวชี้วัดการจำแนก: Accuracy, Precision, Recall, F1
- เส้นโค้ง ROC และ AUC-ROC
- ตัวชี้วัดการถดถอย: MAE, MSE, RMSE และ R-Squared
- การเลือกตัวชี้วัดที่เหมาะสมสำหรับปัญหาทางธุรกิจ