python 实现逻辑回归

逻辑回归是一种常用的分类算法，它可以将数据集划分为两个或多个类别。在本攻略中，我们将介绍如何使用Python实现逻辑回归算法。

步骤1：导入库

在Python实现逻辑回归算法之前，我们需要导入相关的库。在本攻略中，我们将使用NumPy库和Matplotlib库来处理数据和可视化结果，使用sklearn库中的LogisticRegression类来实现逻辑回归算法。

# 示例1：导入库
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression

步骤2：生成数据集

在实现逻辑回归算法之前，我们需要一个数据集。在本攻略中，我们将使用NumPy库中的random块来生成一个包含100个数据点的二维数据集。

# 示例2：生成数据集
np.random.seed(0)
X = np.random.randn(100, 2)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

步骤3：训练模型

在使用sklearn库中的LogisticRegression类实现逻辑回归算法之前，我们需要先创建一个LogisticRegression对象，并使用fit()方法来训练模型。

# 示例3：训练模型
model = LogisticRegression()
model.fit(X, y)

步骤4：可视化结果

在使用sklearn库中的LogisticRegression类实现逻辑回归算法之后，我们可以使用Matplotlib库来可视化分类结果。在本攻略中，我们使用不同色的散点图来表示不同类别的数据点，并使用一条直线来表示分类边界。

# 示例4：可视化结果
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red')
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue')
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))
Z = model.predict(np.c_[xx1.ravel(), xx2.ravel()])
Z = Z.reshape(xx1.shape)
plt.contour(xx1, xx2, Z, colors='black')
plt.show()

完整代码

# 示例5：完整代码
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression

# 生成数据集
np.random.seed(0)
X = np.random.randn(100, 2)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# 训练模型
model = LogisticRegression()
model.fit(X, y)

# 可视化结果
plt.scatter(X[y == 0, 0], X[y == 0, 1], color='red')
plt.scatter(X[y == 1, 0], X[y == 1, 1], color='blue')
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))
Z = model.predict(np.c_[xx1.ravel(), xx2.ravel()])
Z = Z.reshape(xx1.shape)
plt.contour(xx1, xx2, Z, colors='black')
plt.show()

示例说明

在示例代码，我们首先生成了一个包含100个数据点的二维数据集。接着，我们使用sklearn库中的LogisticRegression类来实现逻辑回归算法，并使用fit()方法来训练模型。然后，我们使用Matplotlib库来可视化分类结果，其中不同颜色的散点图表示不同类别的数据点，黑色的直线表示分类边界。

在这个示例中，我们使用了NumPy库和Matplotlib库来处理数据和可视化结果。我们还使用了sklearn库中的LogisticRegression类来实现逻辑回归算法，并使用fit()方法来训练模型。我们还使用了np.meshgrid()函数来生成网格点，并使用predict()方法来预测每个网格点的类别。最后，我们使用Matplotlib库来可视化分类结果，其中不同颜色的散点图表示不同类别的数据点，黑色的直线表示分类边界。

示例：使用自定义函数实现逻辑回归算法

除了使用sklearn库中的LogisticRegression类实现逻辑回归算法，我们还可以使用自定义函数来实现逻辑回归算法。下面是一个使用自定义函数实现逻辑回归算法的示例代码。

# 示例6：使用自定义函数实现逻辑回归算法
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def cost_function(X, y, theta):
    m = len(y)
    h = sigmoid(X.dot(theta))
    J = -1/m * (y.T.dot(np.log(h)) + (1-y).T.dot(np.log(1-h)))
    grad = 1/m * X.T.dot(h-y)
    return J, grad

def gradient_descent(X, y, theta, alpha, num_iters):
    m = len(y)
    J_history = []
    for i in range(num_iters):
        J, grad = cost_function(X, y, theta)
        theta = theta - alpha * grad
        J_history.append(J)
    return theta, J_history

X = np.hstack((np.ones((len(X), 1)), X))
initial_theta = np.zeros(X.shape[1])
alpha = 0.1
num_iters = 1000
theta, J_history = gradient_descent(X, y, initial_theta, alpha, num_iters)

plt.plot(J_history)
plt.xlabel('Iterations')
plt.ylabel('Cost')
plt.show()

plt.scatter(X[y == 0, 1], X[y == 0, 2], color='red')
plt.scatter(X[y == 1, 1], X[y == 1, 2], color='blue')
x1_min, x1_max = X[:, 1].min(), X[:, 1].max()
x2_min, x2_max = X[:, 2].min(), X[:, 2].max()
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
Z = sigmoid(np.c_[np.ones((len(xx1.ravel()), 1)), xx1.ravel(), xx2.ravel()].dot(theta))
Z = Z.reshape(xx1.shape)
plt.contour(xx1, xx2, Z, colors='black')
plt.show()

在这个示例中，我们首先定义了sigmoid()函数来计算sigmoid函数的值，定义了cost_function()函数来计算代价函数的值和梯度，定义了gradient_descent()函数来实现梯度下降算法。然后，我们使用np.hstack()函数来添加一列全为1的列向量到数据集中，并使用gradient_descent()函数来训练模型。最后，我们使用Matplotlib库来可视化分类结果。

在这个示例中，我们使用了NumPy库和Matplotlib库来处理数据和可视化结果。我们还使用了自定义函数来实现逻辑回归算法，并使用梯度下降算法来训练模型。我们还使用了np.meshgrid()函数来生成网格点，并使用sigmoid()函数来计算每个网格点的类别。最后，我们使用Matplotlib库来可视化分类结果，其中不同颜色的散点图表示不同类别的数据点，黑色的直线表示分类边界。