อัลกอริทึมการจำแนกประเภท - การถดถอยโลจิสติก

ความรู้เบื้องต้นเกี่ยวกับ Logistic Regression

การถดถอยโลจิสติกเป็นอัลกอริธึมการจำแนกประเภทการเรียนรู้ภายใต้การดูแลที่ใช้ในการทำนายความน่าจะเป็นของตัวแปรเป้าหมาย ลักษณะของเป้าหมายหรือตัวแปรตามเป็นแบบ dichotomous ซึ่งหมายความว่าจะมีคลาสที่เป็นไปได้เพียงสองคลาส

กล่าวง่ายๆคือตัวแปรตามเป็นไบนารีโดยมีรหัสข้อมูลเป็น 1 (ย่อมาจากความสำเร็จ / ใช่) หรือ 0 (ย่อมาจากความล้มเหลว / ไม่ใช่)

ในทางคณิตศาสตร์แบบจำลองการถดถอยโลจิสติกส์คาดการณ์ว่า P (Y = 1) เป็นฟังก์ชันของ X เป็นหนึ่งในอัลกอริทึม ML ที่ง่ายที่สุดที่สามารถใช้สำหรับปัญหาการจำแนกประเภทต่างๆเช่นการตรวจจับสแปมการทำนายโรคเบาหวานการตรวจหามะเร็งเป็นต้น

ประเภทของ Logistic Regression

โดยทั่วไปการถดถอยโลจิสติกหมายถึงการถดถอยโลจิสติกแบบไบนารีที่มีตัวแปรเป้าหมายแบบไบนารี แต่ตัวแปรเป้าหมายยังมีอีกสองประเภทที่สามารถทำนายได้ ตามจำนวนประเภทเหล่านั้นการถดถอยโลจิสติกสามารถแบ่งออกเป็นประเภทต่อไปนี้ -

ไบนารีหรือทวินาม

ในการจำแนกประเภทดังกล่าวตัวแปรตามจะมีเพียง 2 ประเภทที่เป็นไปได้คือ 1 และ 0 ตัวอย่างเช่นตัวแปรเหล่านี้อาจแสดงถึงความสำเร็จหรือความล้มเหลวใช่หรือไม่ใช่ชนะหรือแพ้เป็นต้น

พหุนาม

ในการจำแนกประเภทดังกล่าวตัวแปรตามสามารถมีได้ 3 ประเภทหรือมากกว่าที่ไม่ได้เรียงลำดับหรือประเภทที่ไม่มีนัยสำคัญเชิงปริมาณ ตัวอย่างเช่นตัวแปรเหล่านี้อาจแสดงถึง“ ประเภท A” หรือ“ ประเภท B” หรือ“ ประเภท C”

ลำดับ

ในการจำแนกประเภทดังกล่าวตัวแปรตามสามารถมีประเภทลำดับที่เป็นไปได้ 3 ประเภทขึ้นไปหรือประเภทที่มีนัยสำคัญเชิงปริมาณ ตัวอย่างเช่นตัวแปรเหล่านี้อาจแสดงถึง "ไม่ดี" หรือ "ดี" "ดีมาก" "ดีเยี่ยม" และแต่ละหมวดหมู่สามารถมีคะแนนได้เช่น 0,1,2,3

สมมติฐานการถดถอยโลจิสติก

ก่อนที่จะดำดิ่งสู่การใช้การถดถอยโลจิสติกส์เราต้องตระหนักถึงสมมติฐานต่อไปนี้เกี่ยวกับสิ่งเดียวกัน -

• ในกรณีของการถดถอยโลจิสติกแบบไบนารีตัวแปรเป้าหมายจะต้องเป็นไบนารีเสมอและผลลัพธ์ที่ต้องการจะแสดงด้วยปัจจัยระดับ 1

• แบบจำลองไม่ควรมีหลาย collinearity ซึ่งหมายความว่าตัวแปรอิสระจะต้องเป็นอิสระจากกัน

• เราต้องรวมตัวแปรที่มีความหมายไว้ในแบบจำลองของเรา

• เราควรเลือกขนาดตัวอย่างที่ใหญ่สำหรับการถดถอยโลจิสติกส์

แบบจำลองการถดถอยโลจิสติกแบบไบนารี

รูปแบบที่ง่ายที่สุดของการถดถอยโลจิสติกส์คือการถดถอยโลจิสติกแบบไบนารีหรือทวินามซึ่งเป้าหมายหรือตัวแปรตามสามารถมีได้เพียง 2 ประเภทคือ 1 หรือ 0 ช่วยให้เราสามารถจำลองความสัมพันธ์ระหว่างตัวแปรทำนายหลายตัวและตัวแปรเป้าหมายไบนารี / ทวินาม ในกรณีของการถดถอยโลจิสติกโดยทั่วไปแล้วฟังก์ชันเชิงเส้นจะใช้เป็นอินพุตไปยังฟังก์ชันอื่นเช่นในความสัมพันธ์ต่อไปนี้ -

$$ h _ {\ theta} {(x)} = g (\ theta ^ {T} x) ℎ0≤h _ {\ theta} ≤1 $$

นี่คือฟังก์ชันโลจิสติกส์หรือซิกมอยด์ซึ่งสามารถระบุได้ดังนี้ -

$$ g (z) = \ frac {1} {1 + e ^ {- z}} ℎ = \ theta ^ {T} $$

เส้นโค้งซิกมอยด์สามารถแสดงด้วยความช่วยเหลือของกราฟต่อไปนี้ เราสามารถดูค่าของแกน y อยู่ระหว่าง 0 ถึง 1 และข้ามแกนที่ 0.5

ชั้นเรียนสามารถแบ่งออกเป็นบวกหรือลบ ผลลัพธ์จะอยู่ภายใต้ความน่าจะเป็นของคลาสบวกหากอยู่ระหว่าง 0 ถึง 1 สำหรับการนำไปใช้งานของเราเรากำลังตีความผลลัพธ์ของฟังก์ชันสมมติฐานเป็นค่าบวกหากเป็น≥0.5หรือเป็นลบ

นอกจากนี้เรายังต้องกำหนดฟังก์ชันการสูญเสียเพื่อวัดว่าอัลกอริทึมทำงานได้ดีเพียงใดโดยใช้น้ำหนักของฟังก์ชันซึ่งแสดงโดยทีต้าดังนี้ -

ℎ = ()

$$ J (\ theta) = \ frac {1} {m} (- y ^ {T} log (h) - (1 -y) ^ Tlog (1-h)) $$

ตอนนี้หลังจากกำหนดฟังก์ชันการสูญเสียเป้าหมายหลักของเราคือการลดฟังก์ชันการสูญเสียให้น้อยที่สุด สามารถทำได้ด้วยความช่วยเหลือของการปรับน้ำหนักซึ่งหมายถึงการเพิ่มหรือลดน้ำหนัก ด้วยความช่วยเหลือของอนุพันธ์ของฟังก์ชันการสูญเสียเขียนแต่ละน้ำหนักเราจะสามารถรู้ได้ว่าพารามิเตอร์ใดควรมีน้ำหนักสูงและสิ่งที่ควรมีน้ำหนักน้อยกว่า

สมการการไล่ระดับสีต่อไปนี้บอกเราว่าการสูญเสียจะเปลี่ยนไปอย่างไรหากเราแก้ไขพารามิเตอร์ -

$$ \ frac {()} {\ theta_ {j}} = \ frac {1} {m} X ^ {T} (() -) $$

การใช้งานใน Python

ตอนนี้เราจะใช้แนวคิดข้างต้นของการถดถอยโลจิสติกแบบทวินามใน Python เพื่อจุดประสงค์นี้เราใช้ชุดข้อมูลดอกไม้หลายตัวแปรชื่อ 'ไอริส' ซึ่งมี 3 คลาสละ 50 อินสแตนซ์ แต่เราจะใช้คอลัมน์คุณลักษณะสองคอลัมน์แรก ทุกชั้นเป็นตัวแทนของดอกไอริสชนิดหนึ่ง

ขั้นแรกเราต้องนำเข้าไลบรารีที่จำเป็นดังนี้ -

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets

จากนั้นโหลดชุดข้อมูลม่านตาดังต่อไปนี้ -

iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1

เราสามารถลงจุดข้อมูลการฝึกของเราได้ดังนี้ -

plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();

ต่อไปเราจะกำหนดฟังก์ชัน sigmoid ฟังก์ชันการสูญเสียและการไล่ระดับสีลงดังนี้ -

class LogisticRegression:
   def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
      self.lr = lr
      self.num_iter = num_iter
      self.fit_intercept = fit_intercept
      self.verbose = verbose
   def __add_intercept(self, X):
      intercept = np.ones((X.shape[0], 1))
      return np.concatenate((intercept, X), axis=1)
   def __sigmoid(self, z):
      return 1 / (1 + np.exp(-z))
   def __loss(self, h, y):
      return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
   def fit(self, X, y):
      if self.fit_intercept:
         X = self.__add_intercept(X)

ตอนนี้เริ่มต้นน้ำหนักดังต่อไปนี้ -

self.theta = np.zeros(X.shape[1])
   for i in range(self.num_iter):
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      gradient = np.dot(X.T, (h - y)) / y.size
      self.theta -= self.lr * gradient
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      loss = self.__loss(h, y)
      if(self.verbose ==True and i % 10000 == 0):
         print(f'loss: {loss} \t')

ด้วยความช่วยเหลือของสคริปต์ต่อไปนี้เราสามารถทำนายความน่าจะเป็นของผลลัพธ์ -

def predict_prob(self, X):
   if self.fit_intercept:
      X = self.__add_intercept(X)
   return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
   return self.predict_prob(X).round()

ต่อไปเราสามารถประเมินโมเดลและพล็อตได้ดังนี้ -

model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()

plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');

Multinomial Logistic Regression Model

รูปแบบการถดถอยโลจิสติกที่มีประโยชน์อีกรูปแบบหนึ่งคือการถดถอยโลจิสติกแบบพหุนามซึ่งเป้าหมายหรือตัวแปรตามสามารถมีได้ 3 ประเภทขึ้นไปโดยไม่เรียงลำดับ ได้แก่ ประเภทที่ไม่มีนัยสำคัญเชิงปริมาณ

การใช้งานใน Python

ตอนนี้เราจะใช้แนวคิดข้างต้นเกี่ยวกับการถดถอยโลจิสติกแบบพหุนามใน Python เพื่อจุดประสงค์นี้เรากำลังใช้ชุดข้อมูลจาก sklearn ชื่อหลัก

ขั้นแรกเราต้องนำเข้าไลบรารีที่จำเป็นดังนี้ -

Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split

ต่อไปเราต้องโหลดชุดข้อมูลหลัก -

digits = datasets.load_digits()

ตอนนี้กำหนดคุณสมบัติเมทริกซ์ (X) และเวกเตอร์การตอบสนอง (y) ดังนี้ -

X = digits.data
y = digits.target

ด้วยความช่วยเหลือของโค้ดบรรทัดถัดไปเราสามารถแยก X และ y ออกเป็นชุดการฝึกอบรมและการทดสอบ -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)

ตอนนี้สร้างวัตถุของการถดถอยโลจิสติกดังนี้ -

digreg = linear_model.LogisticRegression()

ตอนนี้ต้องฝึกโมเดลโดยใช้ชุดฝึกดังนี้ -

digreg.fit(X_train, y_train)

จากนั้นทำการคาดคะเนชุดการทดสอบดังนี้ -

y_pred = digreg.predict(X_test)

ถัดไปพิมพ์ความถูกต้องของแบบจำลองดังต่อไปนี้ -

print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)

เอาต์พุต

Accuracy of Logistic Regression model is: 95.6884561891516

จากผลลัพธ์ข้างต้นเราจะเห็นความแม่นยำของแบบจำลองของเราอยู่ที่ประมาณ 96 เปอร์เซ็นต์