博客

python的numpy模块实现逻辑回归模型

  • Post category:Python

逻辑回归是一种常见的分类算法，可以用于二分类和多分类问题。在Python中，可以使用NumPy模块实现逻辑回归模型。本文将详细讲解Python的NumPy模块实现逻辑回归模型的完整攻略，包括数据预处理、模型训练、模型预测等，并提供两个示例。

数据预处理

在使用NumPy模块实现逻辑回归模型之前，需要对数据进行预处理。预处理包括数据清洗、特征选择、特征缩放等。下面是一个示例：

import numpy as np
import pandas as pd

# 读取数据
data = pd.read_csv('data.csv')

# 数据清洗
data = data.dropna()

# 特征选择
X = data[['feature1', 'feature2', 'feature3']]
y = data['label']

# 特征缩放
X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)

在上面的示例中，我们使用pandas模块读取了数据，并进行了数据清洗、特征选择、特征缩放等预处理操作。

模型训练

在数据预处理完成后，可以使用NumPy模块训练逻辑回归模型。下面是一个示例：

import numpy as np

# 定义sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# 初始化参数
theta = np.zeros((X.shape[1], 1))

# 定义损失函数
def cost_function(X, y, theta):
    m = len(y)
    h = sigmoid(X @ theta)
    J = -1 / m * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))
    return J

# 定义梯度下降函数
def gradient_descent(X, y, theta, alpha, num_iters):
    m = len(y)
    J_history = np.zeros((num_iters, 1))
    for i in range(num_iters):
        h = sigmoid(X @ theta)
        theta = theta - alpha / m * X.T @ (h - y)
        J_history[i] = cost_function(X, y, theta)
    return theta, J_history

# 训练模型
alpha = 0.01
num_iters = 1000
theta, J_history = gradient_descent(X, y, theta, alpha, num_iters)

在上面的示例中，我们定义了sigmoid函数、损失函数和梯度下降函数，并使用gradient_descent()函数训练了逻辑回归模型。

模型预测

在模型训练完成后，可以使用NumPy模块进行模型预测。下面是一个示例：

import numpy as np

# 预测函数
def predict(X, theta):
    h = sigmoid(X @ theta)
    p = np.round(h)
    return p

# 预测结果
p = predict(X, theta)

在上面的示例中，我们定义了预测函数，并使用predict函数预测了结果。

示例一：使用NumPy模块实现二分类逻辑回归模型

import numpy as np
import pandas as pd

# 读取数据
data = pd.read_csv('data.csv')

# 数据清洗
data = data.dropna()

# 特征选择
X = data[['feature1', 'feature2', 'feature3']]
y = data['label']

# 特征缩放
X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)

# 初始化参数
theta = np.zeros((X.shape[1], 1))

# 定义sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# 定义损失函数
def cost_function(X, y, theta):
    m = len(y)
    h = sigmoid(X @ theta)
    J = -1 / m * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))
    return J

# 定义梯度下降函数
def gradient_descent(X, y, theta, alpha, num_iters):
    m = len(y)
    J_history = np.zeros((num_iters, 1))
    for i in range(num_iters):
        h = sigmoid(X @ theta)
        theta = theta - alpha / m * X.T @ (h - y)
        J_history[i] = cost_function(X, y, theta)
    return theta, J_history

# 训练模型
alpha = 0.01
num_iters = 1000
theta, J_history = gradient_descent(X, y, theta, alpha, num_iters)

# 预测函数
def predict(X, theta):
    h = sigmoid(X @ theta)
    p = np.round(h)
    return p

# 预测结果
p = predict(X, theta)

在上面的示例中，我们使用NumPy模块实现了二分类逻辑回归模型，并了数据预处理、模型训练和模型预测等步骤。

示例二：使用NumPy模块实现多分类逻辑回归模型

import numpy as np
import pandas as pd

# 读取数据
data = pd.read_csv('data.csv')

# 数据清洗
data = data.dropna()

# 特征选择
X = data[['feature1', 'feature2', 'feature3']]
y = data['label']

# 特征缩放
X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)

# 初始化参数
theta = np.zeros((X.shape[1], len(np.unique(y))))

# 定义sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# 定义损失函数
def cost_function(X, y, theta):
    m = len(y)
    h = sigmoid(X @ theta)
    J = -1 / m * np.sum(y * np.log(h) + (1 - y) * np.log(1 - h))
    return J

# 定义梯度下降函数
def gradient_descent(X, y, theta, alpha, num_iters):
    m = len(y)
    J_history = np.zeros((num_iters, 1))
    for i in range(num_iters):
        h = sigmoid(X @ theta)
        theta = theta - alpha / m * X.T @ (h - y)
        J_history[i] = cost_function(X, y, theta)
    return theta, J_history

# 将标签转换为独热编码
def one_hot_encode(y):
    n_values = np.max(y) + 1
    return np.eye(n_values)[y]

# 训练模型
alpha = 0.01
num_iters = 1000
y_one_hot = one_hot_encode(y)
theta, J_history = gradient_descent(X, y_one_hot, theta, alpha, num_iters)

# 预测函数
def predict(X, theta):
    h = sigmoid(X @ theta)
    p = np.argmax(h, axis=1)
    return p

# 预测结果
p = predict(X, theta)

在上面的示例中，我们使用NumPy模块实现了多分类逻辑回归模型，并使用了数据预处理、模型训练和模型预测等步骤。同时，我们还使用了独热码将标签转换为多个二分类问题。

Tags: