Machine Learning Academy · Pelajaran

Regresi Logistik dan Fungsi Sigmoid

Pelajar akan menggunakan sigmoid untuk menghasilkan kebarangkalian, mentafsir output sebagai keyakinan kelas, dan melatih model logistik dengan scikit-learn.

Pelajaran 2 daripada 413 langkah

Regresi Logistik dan Fungsi Sigmoid ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 2 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.

Regresi Logistik: Pengelas Kebarangkalian

Regresi logistik ialah algoritma pilihan utama untuk pengelasan binari. Walaupun namanya begitu, ia ialah pengelas, bukannya model regresi. Ia mengembangkan model linear dengan memampatkan output melalui fungsi khas yang dipanggil sigmoid, bagi memastikan ramalan sentiasa merupakan kebarangkalian yang sah antara 0 dan 1.

Regresi logistik ialah salah satu model Pembelajaran Mesin yang paling banyak digunakan dalam sistem pengeluaran. Model ini pantas dilatih, mudah ditafsir dan menyediakan anggaran kebarangkalian yang ditentukur. Model ini selalunya merupakan pengelas pertama yang patut Anda cuba untuk masalah pengelasan binari baharu sebelum menggunakan kaedah yang lebih kompleks.

Fungsi Sigmoid

Fungsi sigmoid (juga dipanggil fungsi logistik) memetakan sebarang nombor nyata kepada julat (0, 1):

σ(z) = 1 / (1 + e^(-z))

Sifat utama: σ(0) = 0.5, σ(+∞) → 1, σ(-∞) → 0. Lengkung berbentuk S beralih dengan lancar daripada 0 kepada 1. Apabila z ialah nombor positif besar (isyarat kuat untuk kelas 1), output menghampiri 1. Apabila z ialah nombor negatif besar (isyarat kuat untuk kelas 0), output menghampiri 0.

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

z = np.linspace(-10, 10, 200)
y = sigmoid(z)

plt.plot(z, y, 'b-', linewidth=2)
plt.axhline(y=0.5, color='red', linestyle='--', alpha=0.5, label='threshold=0.5')
plt.axvline(x=0, color='gray', linestyle='--', alpha=0.5)
plt.xlabel('z (linear score)')
plt.ylabel('sigmoid(z) = probability')
plt.title('The Sigmoid Function')
plt.legend()
plt.show()

print('sigmoid(0):', sigmoid(0))   # 0.5
print('sigmoid(5):', sigmoid(5))   # ~0.993
print('sigmoid(-5):', sigmoid(-5)) # ~0.007

Cara Regresi Logistik Mengira Kebarangkalian

Regresi logistik mula-mula mengira gabungan linear yang sama seperti regresi linear (z = w₁x₁ + w₂x₂ + ... + b), kemudian menghantarnya melalui sigmoid untuk mendapatkan kebarangkalian:

P(y=1|x) = σ(wᵀx + b) = 1 / (1 + e^(-(wᵀx+b)))

Model ini mengeluarkan kebarangkalian bahawa input tergolong dalam kelas 1. Jika kebarangkalian ini melebihi 0.5, model meramalkan kelas 1; jika tidak, kelas 0. Pemberat w dipelajari semasa latihan untuk memaksimumkan kebolehjadian label yang diperhatikan — proses yang dipanggil anggaran kebolehjadian maksimum.

import numpy as np

def logistic_predict_proba(X, weights, bias):
    z = X @ weights + bias  # linear score
    probability = 1 / (1 + np.exp(-z))  # sigmoid
    return probability

# Example: spam classification
# Features: word_count, exclamation_marks, capital_ratio
weights = np.array([0.05, 0.3, 2.0])
bias = -3.0

new_email = np.array([50, 5, 0.6])  # 50 words, 5 '!', 60% capitals
prob_spam = logistic_predict_proba(new_email, weights, bias)
print(f'P(spam): {prob_spam:.3f}')
print('Predicted label:', 1 if prob_spam >= 0.5 else 0)

Log Loss: Fungsi Kos yang Tepat

Regresi logistik tidak menggunakan MSE sebagai fungsi kosnya. Sebaliknya, regresi ini menggunakan Entropi Silang Binari (kerugian log):

Loss = -(y × log(ŷ) + (1-y) × log(1-ŷ))

Kaedah ini mengenakan penalti yang amat berat terhadap ramalan salah yang dibuat dengan penuh keyakinan. Jika label sebenar ialah 1 dan model meramalkan kebarangkalian 0.001, kerugian log ialah -log(0.001) ≈ 6.9 — sangat besar. Jika model meramalkan 0.99, kerugiannya ialah -log(0.99) ≈ 0.01 — sangat kecil. Pengenaan penalti yang tidak simetri ini sememangnya tepat untuk penentukuran kebarangkalian.

import numpy as np

def log_loss_single(y_true, y_pred_proba, epsilon=1e-9):
    # Clip to avoid log(0)
    p = np.clip(y_pred_proba, epsilon, 1 - epsilon)
    return -(y_true * np.log(p) + (1 - y_true) * np.log(1 - p))

# True label = 1 (spam)
print('P(spam)=0.95, loss:', log_loss_single(1, 0.95).round(3))  # small
print('P(spam)=0.5,  loss:', log_loss_single(1, 0.50).round(3))  # moderate
print('P(spam)=0.05, loss:', log_loss_single(1, 0.05).round(3))  # large!
print('P(spam)=0.001,loss:', log_loss_single(1, 0.001).round(3)) # very large!

Melatih Regresi Logistik dengan scikit-learn

LogisticRegression scikit-learn menggunakan pengoptimum berasaskan kecerunan (LBFGS secara lalai) untuk meminimumkan kerugian log dan mencari pemberat yang optimum. API-nya sama seperti LinearRegression: bina tika, padankan, ramalkan.

Parameter penting termasuk C (songsangan kekuatan regularisasi — C yang lebih kecil bermaksud regularisasi yang lebih kuat) dan max_iter (bilangan maksimum langkah pengoptimuman). Jika anda melihat amaran penumpuan, tingkatkan max_iter atau skalakan ciri anda terlebih dahulu.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features (important for logistic regression)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

model = LogisticRegression(C=1.0, max_iter=1000)
model.fit(X_train_s, y_train)
print('Test accuracy:', model.score(X_test_s, y_test).round(3))

Output Kebarangkalian dan Tahap Keyakinan

Regresi logistik ialah salah satu daripada beberapa pengelas yang menghasilkan anggaran kebarangkalian yang ditentukur dengan baik. Kebarangkalian 0.85 untuk kelas 1 bermaksud kira-kira 85% daripada ramalan dengan tahap keyakinan tersebut sepatutnya benar-benar merupakan kelas 1. Penentukuran ini penting untuk aplikasi pengurusan risiko (pemarkahan kredit, diagnosis perubatan) yang memerlukan nilai kebarangkalian itu sendiri, bukan sekadar label binari.

Gunakan predict_proba() untuk mendapatkan semula vektor kebarangkalian penuh. Dua lajur tersebut mewakili P(kelas 0) dan P(kelas 1). Jumlahnya sentiasa 1.0.

import numpy as np

# Get class probabilities
probas = model.predict_proba(X_test_s[:8])
labels = model.predict(X_test_s[:8])

print('Sample | P(benign) | P(malignant) | Predicted')
for i, (proba, label) in enumerate(zip(probas, labels)):
    print(f'  {i+1}    |   {proba[0]:.3f}   |    {proba[1]:.3f}     | {label}')

print('\nClass names:', model.classes_)  # [0, 1] or ['benign', 'malignant']

Mentafsir Pekali Regresi Logistik

Pekali regresi logistik tidak boleh ditafsir secara langsung seperti pekali regresi linear, tetapi masih membawa maklumat yang bermakna. Pekali w bagi sesuatu ciri mewakili perubahan dalam log-odds kelas positif bagi peningkatan satu unit pada ciri tersebut:

log(P(y=1)/P(y=0)) = wᵀx + b

Nisbah odds bagi sesuatu ciri ialah exp(w). Jika exp(w) = 2, ciri tersebut menggandakan odds kelas positif. Pekali positif yang besar menunjukkan ciri yang sangat kuat meramalkan kelas 1; pekali negatif yang besar pula sangat kuat meramalkan kelas 0.

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer

data = load_breast_cancer()
feature_names = data.feature_names

# Coefficient table with odds ratios
coef_df = pd.DataFrame({
    'Feature': feature_names,
    'Coefficient': model.coef_[0],
    'Odds_Ratio': np.exp(model.coef_[0])
}).sort_values('Coefficient', key=abs, ascending=False)

print(coef_df.head(5).to_string(index=False))
# Features with largest |coef| drive predictions most strongly

Regularisasi dalam Regresi Logistik

Regresi logistik dalam scikit-learn menggunakan regularisasi L2 secara lalai, yang dikawal oleh parameter C. Tidak seperti kebanyakan parameter regularisasi, C ialah songsangan kekuatan regularisasi: C yang lebih kecil bermaksud regularisasi yang lebih kuat (lebih banyak pengecutan pemberat), manakala C yang lebih besar bermaksud regularisasi yang lebih lemah.

Gunakan penalty='l1' dan penyelesai 'liblinear' untuk regularisasi L1, yang melakukan pemilihan ciri secara automatik dengan menetapkan pemberat ciri yang tidak relevan kepada sifar. Regresi logistik L1 amat berguna apabila anda mempunyai banyak ciri dan mengesyaki bahawa kebanyakannya tidak relevan.

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# Compare regularisation strengths
for C in [0.01, 0.1, 1.0, 10.0, 100.0]:
    model_c = LogisticRegression(C=C, max_iter=1000)
    scores = cross_val_score(model_c, X_train_s, y_train, cv=5)
    print(f'C={C:6}: CV Accuracy = {scores.mean():.3f} (+/- {scores.std():.3f})')

Laporan Pengelasan

Satu nombor ketepatan menyembunyikan maklumat penting. classification_report() scikit-learn mencetak ketepatan positif, dapatan semula dan skor F1 bagi setiap kelas, serta purata makro dan wajaran. Inilah cara standard untuk melaporkan prestasi pengelasan dalam penyelidikan dan industri.

Cara membaca laporan: lajur 'sokongan' menunjukkan bilangan contoh bagi setiap kelas dalam set ujian. Jika nilai sokongan sangat tidak seimbang (ketidakseimbangan kelas), lihat dapatan semula mengikut kelas dan bukannya ketepatan keseluruhan untuk memahami bahagian yang gagal diramalkan oleh model.

from sklearn.metrics import classification_report

y_pred = model.predict(X_test_s)
print(classification_report(y_test, y_pred, target_names=['benign', 'malignant']))
# Shows for each class:
#   precision: of all predicted positive, how many were actually positive
#   recall: of all actual positive, how many did we catch
#   f1-score: harmonic mean of precision and recall
#   support: number of true instances of each class in test set

Perbandingan Regresi Logistik dengan Regresi Linear

Berikut ialah perbandingan yang jelas tentang masa untuk menggunakan setiap satunya:

Jenis sasaran: Regresi linear → nombor berterusan; regresi logistik → kebarangkalian / label binari.
Julat output: Linear → (-∞, +∞); logistik → (0, 1).
Fungsi kerugian: Linear → MSE; logistik → Entropi Silang Binari (kerugian log).
Penilaian: Linear → RMSE, R²; logistik → Ketepatan, F1, AUC-ROC.
Sifat sepunya: Kedua-duanya ialah model linear — sempadan keputusan ialah hiper satah, dan kedua-duanya mendapat manfaat daripada penskalaan ciri serta regularisasi.

Regresi Logistik Berbilang Kelas

Untuk masalah yang mempunyai lebih daripada dua kelas, regresi logistik digeneralisasikan kepada regresi Softmax (juga dipanggil regresi logistik multinomial). Daripada menggunakan satu sigmoid, regresi ini mengira satu skor linear bagi setiap kelas dan menghantar kesemuanya melalui fungsi softmax, lalu menghasilkan taburan kebarangkalian merentas semua kelas.

Dalam scikit-learn, tetapkan multi_class='multinomial' dan gunakan penyelesai 'lbfgs' atau 'saga'. Model menghasilkan satu kebarangkalian bagi setiap kelas, dan kelas yang diramalkan ialah kelas dengan kebarangkalian tertinggi.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train_s = StandardScaler().fit_transform(X_train)
X_test_s = StandardScaler().fit_transform(X_test)

# Multinomial for 3 classes
model = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000)
model.fit(X_train_s, y_train)
print('Test accuracy:', model.score(X_test_s, y_test).round(3))
print('Proba shape:', model.predict_proba(X_test_s[:1]).shape)  # (1, 3)

Semakan Pantas

Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: fungsi sigmoid memampatkan sebarang skor linear menjadi kebarangkalian sah antara 0 dan 1, regresi logistik menggunakan kerugian entropi silang binari yang mengenakan penalti berat terhadap ramalan salah yang dibuat dengan penuh keyakinan, dan pekali mewakili perubahan dalam log-odds, manakala nisbah odds exp(w) memberikan tafsiran yang lebih intuitif serta tidak bergantung pada skala. Seterusnya, kita akan membina matriks kekeliruan daripada ramalan dan kebenaran sebenar untuk mendapatkan pecahan terperinci tentang bahagian yang berjaya dan gagal dikendalikan oleh pengelas.

Percuma untuk bermula

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

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Regresi Logistik dan Fungsi Sigmoid” percuma?

Ya — teks penuh “Regresi Logistik dan Fungsi Sigmoid” 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 “Regresi Logistik dan Fungsi Sigmoid”?

Pelajar akan menggunakan sigmoid untuk menghasilkan kebarangkalian, mentafsir output sebagai keyakinan kelas, dan melatih model logistik dengan scikit-learn. 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 2 daripada 4.

Berapa lamakah pelajaran “Regresi Logistik dan Fungsi Sigmoid” 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

← Kembali ke Machine Learning Academy