Daripada Regresi kepada Pengelasan: Keputusan Ambang
Pelajar akan memahami sebab regresi linear gagal untuk hasil binari dan melihat cara penambahan ambang menukar skor kepada label kelas.
Daripada Regresi kepada Pengelasan: Keputusan Ambang ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah Pengelasan?
Pengelasan ialah tugas pembelajaran diselia untuk meramalkan kategori yang dimiliki oleh sesuatu input, bukannya meramalkan nombor berterusan. Contohnya:
- Meramalkan sama ada e-mel ialah spam atau bukan spam (binari).
- Meramalkan digit yang manakah (0-9) terdapat dalam imej (berbilang kelas).
- Meramalkan penyakit yang dihidapi oleh pesakit berdasarkan simptom (berbilang kelas).
Perbezaan utama daripada regresi: output ialah label diskret, bukannya nombor nyata. Perubahan yang kelihatan kecil ini memerlukan algoritma, fungsi kerugian dan metrik penilaian yang berbeza.
Mengapa Regresi Linear Gagal untuk Pengelasan
Pendekatan yang menarik ialah mengekod kelas 0 dan kelas 1 sebagai nombor, kemudian menggunakan regresi linear. Contohnya, mengekod 'bukan spam' sebagai 0 dan 'spam' sebagai 1, kemudian melatih model regresi linear. Masalah serta-merta ialah regresi linear menghasilkan output dari -∞ hingga +∞, sedangkan kebarangkalian mesti berada antara 0 dan 1. Ramalan 1.7 untuk keahlian kelas tidak mempunyai makna.
Masalah kedua ialah regresi linear cuba menarik garis padanan terbaik melalui semua contoh. Menambahkan satu pencilan jelas yang jauh dari sempadan boleh memutarkan garis itu sehingga banyak contoh yang sebelum ini dikelaskan dengan betul menjadi tersalah kelas. Fungsi kerugian itu pada asasnya tidak sesuai untuk hasil binari.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
# Binary dataset: 1 = spam, 0 = not spam
word_count = np.array([10, 20, 25, 30, 40, 50, 200]).reshape(-1, 1)
spam = np.array([0, 0, 0, 1, 1, 1, 1])
model = LinearRegression()
model.fit(word_count, spam)
# Problematic: predictions outside [0,1]
predictions = model.predict([[5], [25], [200]])
print('Linear regression predictions (should be 0 or 1):')
print(predictions) # might be negative or >1Keputusan Ambang: Menukar Skor kepada Label
Pendekatan paling mudah untuk pengelasan ialah menggunakan output model regresi sebagai skor dan menggunakan ambang untuk menukarnya kepada label binari. Jika skor melebihi ambang, ramalkan kelas 1; jika di bawahnya, ramalkan kelas 0.
Dengan output regresi linear, Anda mungkin memilih ambang 0.5: apa-apa yang melebihi 0.5 ialah spam, manakala yang di bawahnya ialah bukan spam. Ini dipanggil pengelas ambang. Walaupun kasar, pendekatan ini menerangkan konsep utama: skor mesti ditukar kepada keputusan, dan pemilihan ambang melibatkan pertukaran antara jenis ralat yang berbeza.
import numpy as np
from sklearn.linear_model import LinearRegression
X = np.array([10, 20, 25, 30, 40, 50]).reshape(-1, 1)
y = np.array([0, 0, 0, 1, 1, 1])
model = LinearRegression()
model.fit(X, y)
# Apply threshold to convert scores to labels
X_new = np.array([[15], [28], [45]])
scores = model.predict(X_new)
threshold = 0.5
labels = (scores >= threshold).astype(int)
for x, score, label in zip(X_new.ravel(), scores, labels):
print(f'x={x}: score={score:.2f} -> label={label}')Masalah dengan Ambang Tetap
Memilih ambang 0.5 adalah sewenang-wenangnya. Ambang optimum bergantung pada kos relatif bagi jenis ralat yang berbeza:
- Positif palsu (meramalkan spam sedangkan bukan spam) bermaksud e-mel yang sah masuk ke dalam folder spam.
- Negatif palsu (meramalkan bukan spam sedangkan ia spam) bermaksud e-mel sarap sampai ke peti masuk.
Dalam diagnosis perubatan, kosnya jauh lebih tidak seimbang: negatif palsu (gagal mengesan penyakit sebenar) mungkin membawa akibat buruk, jadi Anda merendahkan ambang untuk mengesan lebih banyak positif benar walaupun terpaksa menerima lebih banyak penggera palsu. Ambang ialah keputusan perniagaan, bukan keputusan matematik.
import numpy as np
# Same scores, different thresholds give different label distributions
scores = np.array([0.2, 0.45, 0.55, 0.7, 0.85, 0.95])
y_true = np.array([0, 0, 1, 1, 1, 1])
for threshold in [0.3, 0.5, 0.7]:
labels = (scores >= threshold).astype(int)
correct = (labels == y_true).sum()
print(f'Threshold {threshold}: labels={labels.tolist()}, correct={correct}/{len(y_true)}')Pengelasan Binari berbanding Berbilang Kelas
Pengelasan binari mempunyai tepat dua kelas output yang mungkin (spam/bukan spam, berpenyakit/sihat, penipuan/sah). Pengelasan berbilang kelas mempunyai tiga kelas atau lebih (digit yang manakah antara 0-9, spesies bunga yang manakah, kategori produk yang manakah).
Kebanyakan pengelas binari diperluas kepada pengelasan berbilang kelas melalui dua strategi:
- Satu-lawan-Selebihnya (OvR): latih satu pengelas binari bagi setiap kelas, kemudian ramalkan kelas yang pengelasnya paling yakin.
- Satu-lawan-Satu (OvO): latih pengelas binari bagi setiap pasangan kelas, kemudian ambil undian majoriti.
Scikit-learn mengendalikan perkara ini secara automatik untuk kebanyakan algoritma.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# Iris has 3 classes: sklearn handles multi-class automatically
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
model = LogisticRegression(multi_class='ovr', max_iter=200)
model.fit(X_train, y_train)
print('Test accuracy:', model.score(X_test, y_test).round(3))
print('Classes:', model.classes_)Sempadan Keputusan: Tempat Model Membuat Keputusan
Sesuatu pengelas membahagikan ruang ciri kepada beberapa rantau, satu bagi setiap kelas. Sempadan antara rantau-rantau ini dipanggil sempadan keputusan. Bagi pengelas linear, sempadan keputusan ialah garis lurus (dalam 2D), satah (dalam 3D) atau hipersatah (dalam dimensi lebih tinggi).
Lokasi dan bentuk sempadan keputusan ialah perkara yang dipelajari oleh algoritma semasa latihan. Memvisualisasikan sempadan keputusan pada set data 2D ialah salah satu cara terbaik untuk membina intuisi tentang cara pengelas berfungsi dan sebab ramalannya betul atau salah di rantau tertentu dalam ruang ciri.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, random_state=42)
model = LogisticRegression()
model.fit(X, y)
# Plot decision boundary
xx, yy = np.meshgrid(np.linspace(-3, 3, 200), np.linspace(-3, 3, 200))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', alpha=0.8)
plt.title('Linear Decision Boundary')
plt.show()Ketepatan: Metrik yang Paling Intuitif
Ketepatan ialah pecahan ramalan yang betul: accuracy = correct_predictions / total_predictions. Ini ialah metrik yang paling intuitif dan sesuai apabila kelas adalah seimbang serta semua ralat mempunyai kos yang sama.
Walau bagaimanapun, ketepatan boleh mengelirukan bagi set data tidak seimbang. Jika 95% e-mel adalah sah dan model Anda meramalkan 'bukan spam' untuk segala-galanya, model itu mencapai ketepatan 95% walaupun gagal sepenuhnya menjalankan tugasnya — tidak pernah mengesan satu pun e-mel spam. Inilah paradoks ketepatan, yang mendorong penggunaan metrik yang lebih bermaklumat seperti kejituan dan dapatan semula.
from sklearn.metrics import accuracy_score
import numpy as np
# Balanced dataset
y_true_balanced = np.array([0, 1, 0, 1, 0, 1, 0, 1])
y_pred_balanced = np.array([0, 1, 0, 0, 0, 1, 1, 1])
print(f'Balanced accuracy: {accuracy_score(y_true_balanced, y_pred_balanced):.2f}') # 0.75
# Imbalanced: 95% class 0
y_true_imb = np.array([0]*95 + [1]*5)
y_pred_always0 = np.zeros(100, dtype=int)
print(f'Imbalanced accuracy (always predict 0): {accuracy_score(y_true_imb, y_pred_always0):.2f}') # 0.95!Perbezaan antara Predict dengan Predict_proba
Kebanyakan pengelas scikit-learn menyediakan dua kaedah ramalan:
predict(X)— mengembalikan label kelas muktamad selepas menggunakan ambang lalai (biasanya 0.5 untuk pengelasan binari).predict_proba(X)— mengembalikan tatasusunan kebarangkalian berbentuk(n_samples, n_classes), yang memberikan tahap keyakinan model bagi setiap kelas.
Menggunakan predict_proba memberikan Anda lebih banyak kawalan kerana Anda boleh menggunakan apa-apa ambang. Ini penting untuk aplikasi perniagaan yang ambang optimumnya bukan 0.5.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np
X, y = make_classification(n_samples=200, n_features=5, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LogisticRegression()
model.fit(X_train, y_train)
# Hard labels
hard_labels = model.predict(X_test[:5])
print('Hard labels:', hard_labels)
# Probabilities
probas = model.predict_proba(X_test[:5])
print('Probabilities (class 0, class 1):')
for row in probas:
print(f' Not spam: {row[0]:.2f} | Spam: {row[1]:.2f}')Ambang Tersuai dalam Amalan
Menggunakan ambang tersuai pada output kebarangkalian membolehkan Anda melaraskan pertukaran antara positif palsu dan negatif palsu tanpa melatih semula model. Ini dipanggil pengalihan ambang dan merupakan langkah pascapemprosesan yang biasa dalam sistem pengeluaran.
Ambang lebih rendah → model menandakan lebih banyak contoh sebagai positif → lebih banyak positif benar tetapi juga lebih banyak positif palsu. Ambang lebih tinggi → model menjadi lebih berhati-hati → lebih sedikit positif palsu tetapi lebih banyak negatif palsu. Ambang yang betul ditentukan oleh kos setiap jenis ralat dalam aplikasi khusus Anda.
import numpy as np
from sklearn.metrics import confusion_matrix
# Get probability scores for positive class
spam_probas = model.predict_proba(X_test)[:, 1]
print('Confusion matrices at different thresholds:')
for threshold in [0.3, 0.5, 0.7]:
y_pred = (spam_probas >= threshold).astype(int)
cm = confusion_matrix(y_test, y_pred)
tp = cm[1, 1]
fp = cm[0, 1]
fn = cm[1, 0]
tn = cm[0, 0]
print(f'\nThreshold {threshold}: TP={tp} FP={fp} FN={fn} TN={tn}')Gambaran Keseluruhan Algoritma Pengelasan Biasa
Regresi linear dengan ambang hanyalah permulaan. Scikit-learn menyediakan banyak algoritma pengelasan khusus, setiap satunya mempunyai kekuatan dan kelemahan:
- Regresi Logistik — pengelas linear kebarangkalian yang sesuai (pelajaran seterusnya).
- Jiran Terdekat K — mengelaskan berdasarkan undian majoriti contoh latihan yang paling hampir.
- Pohon Keputusan — berasaskan peraturan dan boleh ditafsir sepenuhnya.
- Hutan Rawak — gabungan pohon yang teguh dan berkuasa.
- SVM — mencari hipersatah dengan margin maksimum.
- Bayes Naif — pantas, berasaskan kebarangkalian dan sangat baik untuk teks.
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
for name, clf in [('Logistic Regression', LogisticRegression(max_iter=1000)),
('Decision Tree', DecisionTreeClassifier()),
('KNN', KNeighborsClassifier()),
('Random Forest', RandomForestClassifier())]:
score = cross_val_score(clf, X, y, cv=5, scoring='accuracy').mean()
print(f'{name}: {score:.3f}')Semakan Pantas
Uji pemahaman Anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.
Imbas Kembali Pelajaran
Dalam pelajaran ini, Anda mempelajari bahawa: regresi linear gagal untuk pengelasan binari kerana menghasilkan output tidak terbatas yang tidak dapat mewakili kebarangkalian, penggunaan ambang menukar skor kebarangkalian kepada label kelas dengan pertukaran yang boleh dilaraskan antara positif palsu dan negatif palsu, dan ketepatan boleh mengelirukan bagi set data tidak seimbang — dapatan semula dan kejituan memberikan gambaran yang lebih lengkap. Seterusnya, kita akan mempelajari regresi logistik — pengelas linear kebarangkalian yang sesuai dan menggunakan fungsi sigmoid untuk menghasilkan kebarangkalian yang ditentukur.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Daripada Regresi kepada Pengelasan: Keputusan Ambang” percuma?
Ya — teks penuh “Daripada Regresi kepada Pengelasan: Keputusan Ambang” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Daripada Regresi kepada Pengelasan: Keputusan Ambang”?
Pelajar akan memahami sebab regresi linear gagal untuk hasil binari dan melihat cara penambahan ambang menukar skor kepada label kelas. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.
Berapa lamakah pelajaran “Daripada Regresi kepada Pengelasan: Keputusan Ambang” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Daripada Regresi kepada Pengelasan: Keputusan Ambang
- Regresi Logistik dan Fungsi Sigmoid
- Penjelasan Matriks Kekeliruan
- Kejituan, Ingatan Semula dan Skor F1 dalam Amalan