基于Python的机器学习系列（7）：多元逻辑回归

        在本篇博文中，我们将探讨多元逻辑回归，它是一种扩展的逻辑回归方法，适用于分类数量超过两个的场景。与二元逻辑回归不同，多元逻辑回归使用Softmax函数将多个类别的概率输出映射到[0, 1]范围内，并确保所有类别的概率和为1。本文将通过具体的代码实现详细介绍多元逻辑回归的工作机制。

1. Softmax函数

        在多元逻辑回归中，我们使用Softmax函数来处理多类别的概率分布。Softmax函数可以将模型的线性输出转化为各类别的概率值。公式如下：

        其中c表示类别，k表示类别的总数。

Softmax函数的作用如下：

• 它将每个类别的得分转化为非负的概率值。
• Softmax函数通过分母的求和操作确保所有类别的概率和为1。
• Softmax函数的分子和分母都包含指数函数$e$，这使得其导数易于计算，并能与交叉熵损失函数配合良好。

def softmax(x):
    return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)

X = np.array([[1, 2, 3],
             [2, 4, 5]])

Y = np.array([[0, 0, 1, 0],
              [1, 0, 0, 0]])  # one-hot encoded classes

W = np.array([[1, 2, 3, 4],
              [2, 3, 1, 0],
              [1, 2, 5, 1]])

softmax_output = softmax(X @ W)
print("Softmax Output:\n", softmax_output)
print("Check sum of probabilities:", softmax_output.sum(axis=1))

2. 交叉熵损失函数

        在多元逻辑回归中，我们继续使用交叉熵作为损失函数。对于每个样本，交叉熵损失可以表示为：

        与二元逻辑回归的交叉熵损失不同，损失函数现在对所有类别进行求和，从而扩展到多类场景。

def cross_entropy_loss(Y, h):
    return - np.sum(Y * np.log(h))

loss = cross_entropy_loss(Y, softmax_output)
print("Cross Entropy Loss:", loss)

3. 梯度计算

        对于每个参数theta，损失函数J的梯度计算公式为：

        其中H和Y分别为预测值矩阵和真实值的one-hot编码矩阵。

        通过链式法则，我们可以详细推导出每个参数的梯度，并将其应用于梯度下降算法中。

4. 多元逻辑回归的实现

        下面是多元逻辑回归的完整实现步骤：

1. 准备数据，包括添加截距项、one-hot编码标签、标准化特征等。
2. 使用Softmax函数进行预测，并计算交叉熵损失。
3. 基于损失函数计算梯度，并更新参数。
4. 迭代上述步骤，直至达到收敛条件。

class LogisticRegression:
    
    def __init__(self, k, n, method, alpha=0.001, max_iter=5000):
        self.k = k
        self.n = n
        self.alpha = alpha
        self.max_iter = max_iter
        self.method = method
    
    def fit(self, X, Y):
        self.W = np.random.rand(self.n, self.k)
        self.losses = []
        
        if self.method == "batch":
            for i in range(self.max_iter):
                loss, grad = self.gradient(X, Y)
                self.losses.append(loss)
                self.W -= self.alpha * grad
                if i % 500 == 0:
                    print(f"Loss at iteration {i}: {loss}")
        
        elif self.method == "minibatch":
            batch_size = int(0.3 * X.shape[0])
            for i in range(self.max_iter):
                ix = np.random.randint(0, X.shape[0] - batch_size)
                batch_X = X[ix:ix + batch_size]
                batch_Y = Y[ix:ix + batch_size]
                loss, grad = self.gradient(batch_X, batch_Y)
                self.losses.append(loss)
                self.W -= self.alpha * grad
                if i % 500 == 0:
                    print(f"Loss at iteration {i}: {loss}")
        
        else:
            raise ValueError('Method must be "batch" or "minibatch".')
        
    def gradient(self, X, Y):
        m = X.shape[0]
        h = self.h_theta(X)
        loss = - np.sum(Y * np.log(h)) / m
        error = h - Y
        grad = X.T @ error
        return loss, grad

    def h_theta(self, X):
        return self.softmax(X @ self.W)

    def softmax(self, x):
        return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)
    
    def predict(self, X):
        return np.argmax(self.h_theta(X), axis=1)
    
    def plot_losses(self):
        plt.plot(self.losses)
        plt.xlabel('Iteration')
        plt.ylabel('Loss')
        plt.title('Loss over time')
        plt.show()

# 使用模型进行训练
model = LogisticRegression(k=3, n=X_train.shape[1], method="minibatch")
model.fit(X_train, Y_train_encoded)
model.plot_losses()

# 预测并评估
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

结语

        在本文中，我们探讨了多元逻辑回归，扩展了二元逻辑回归的概念，以适应多个类别的分类任务。通过软最大化函数（softmax）和交叉熵损失函数，我们能够有效地训练模型，并根据多个类别预测结果的概率分布来进行分类。这些技术在多类别分类问题中具有广泛的应用。

        通过理解多元逻辑回归的数学推导和代码实现，我们可以更好地应对实际的分类任务，尤其是在数据维度较高、类别较多的情况下。

        敬请期待下一篇博文：基于Python的机器学习系列（8）：Newton Raphson逻辑回归，我们将探索一种更为高级的优化方法，用于进一步提高逻辑回归的效率和性能。

如果你觉得这篇博文对你有帮助，请点赞、收藏、关注我，并且可以打赏支持我！

欢迎关注我的后续博文，我将分享更多关于人工智能、自然语言处理和计算机视觉的精彩内容。

谢谢大家的支持！