Python机器学习之逻辑回归

逻辑回归（Logistic Regression）是一种常用的分类算法，它可以用于二分类和多分类问题。在这篇文章中，我们将介绍如何使用Python实现逻辑回归算法，并详细讲解实现原理。

实现原理

逻辑回归是一种基于概率的分类算法，它的目标是根据输入特征预测样本属于哪个类别。逻辑回归的实现原理如下：

1. 首先定义一个逻辑回归模型，包含权重向量和偏置项。
2. 然后定义一个损失函数，用于衡量模型预测结果与真实结果之间的差距。
3. 接着使用梯度下降算法来最小化损失函数，从而得到最优的权重向量和偏置项。
4. 最后使用训练好的模型来预测新的样本类别。

Python实现

下面是一个使用Python实现逻辑回归算法的示例：

import numpy as np

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

            if self.verbose and i % 10000 == 0:
                z = np.dot(X, self.theta)
                h = self.__sigmoid(z)
                print(f'loss: {self.__loss(h, y)} \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, threshold=0.5):
        return self.predict_prob(X) >= threshold

在这个示例中，我们首先定义了一个名为LogisticRegression的类，用于实现逻辑回归算法。在LogisticRegression类中，我们首先定义了一个__add_intercept函数，用于添加截距项。然后定义了一个__sigmoid函数，用于计算sigmoid函数的值。接着定义了一个__loss函数，用于计算损失函数的值。最后定义了一个fit函数，用于训练模型；一个predict_prob函数，用于预测样本属于正类的概率；一个predict函数，用于预测样本类别。

示例1：使用逻辑回归进行二分类

在这个示例中，我们将使用逻辑回归进行二分类。我们首先生成一个二分类数据集，然后使用逻辑回归模型进行训练，并使用测试集评估模型的性能。

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(0)
X = np.random.randn(200, 2)
y = np.array([0 if x[0] + x[1] 0 else 1 for x in X])

model = LogisticRegression(lr=0.1, num_iter=300000)
model.fit(X, y)

plt.scatter(X[:, 0], X[:, 1], c=y)
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')
plt.show()

在这个示例中，我们首先使用numpy模块生成一个二分类数据集。然后使用逻辑回归模型进行训练，并使用测试集评估模型的性能。最后使用matplotlib模块绘制出决策边界。

示例2：使用逻辑回归进行多分类

在这个示例中，我们将使用逻辑回归进行多分类。我们首先加载一个手写数字数据集，然后使用逻辑回归模型进行训练，并使用测试集评估模型的性能。

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.3, random_state=0)

model = LogisticRegression(lr=0.1, num_iter=300000)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy: {accuracy}")

fig, axes = plt.subplots(4, 4, figsize=(8, 8))
fig.subplots_adjust(hspace=0.3, wspace=0.3)

for i, ax in enumerate(axes.flat):
    ax.imshow(X_test[i].reshape(8, 8), cmap='binary', interpolation='nearest')
    ax.text(0.05, 0.05, str(y_pred[i]), transform=ax.transAxes, color='green' if y_pred[i] == y_test[i] else 'red')
    ax.set_xticks([])
    ax.set_yticks([])

plt.show()

在这个示例中，我们首先使用sklearn.datasets模块加载一个手写数字数据集。然后使用逻辑回归模型进行训练，并使用测试集评估模型的性能。最后使用matplotlib模块绘制出预测结果。