机器学习——逻辑回归算法实验

目录

一、算法概述

二、算法原理

1.Sigmoid函数

2.线性回归模型

3.概率预测

三、算法步骤

1.选择预测函数

2.构造损失函数

3.优化算法

四、算法实现

1.引用的库

2.设置训练集并计算准确度

3.计算损失值（逻辑回归模型）

4.绘制决策图

5.完整代码展示

6.运行结果图

五、实验小结

---

一、算法概述

        逻辑回归，虽然名字中包含“回归”，但实际上是一种分类算法，主要用于处理二分类问题。它的基本原理是通过一个称为“逻辑函数”或“Sigmoid函数”的数学函数，将输入的特征向量映射到一个概率值，该概率值用于描述样本属于正类的可能性。

二、算法原理

1. Sigmoid函数：逻辑回归的核心是Sigmoid函数，它将线性回归的输出值映射到(0, 1)区间，从而得到样本属于正类的概率。Sigmoid函数的公式为：(g(z) = \frac{1}{1+e^{-z}})，其中(z)是输入的特征向量和对应的权重的线性组合。
2. 线性回归模型：逻辑回归基于线性回归模型，通过权重（或称为系数）表示每个特征对分类结果的重要性。线性回归方程可以表示为：(z = w_1x_1 + w_2x_2 + ... + w_nx_n + b)，其中(w_i)是权重，(x_i)是特征值，(b)是偏置项。
3. 概率预测：将线性回归的输出值代入Sigmoid函数，得到样本属于正类的概率。通常，当概率值大于或等于某个阈值（如0.5）时，将样本预测为正类；否则，预测为负类。

三、算法步骤

1.Sigmoid函数

        逻辑回归的核心是Sigmoid函数，它将线性回归的输出值映射到(0, 1)区间，从而得到样本属于正类的概率。Sigmoid函数的公式为：(g(z) = \frac{1}{1+e^{-z}})，其中(z)是输入的特征向量和对应的权重的线性组合。

2.线性回归模型

        逻辑回归基于线性回归模型，通过权重（或称为系数）表示每个特征对分类结果的重要性。线性回归方程可以表示为：(z = w_1x_1 + w_2x_2 + ... + w_nx_n + b)，其中(w_i)是权重，(x_i)是特征值，(b)是偏置项。

3.概率预测

        将线性回归的输出值代入Sigmoid函数，得到样本属于正类的概率。通常，当概率值大于或等于某个阈值（如0.5）时，将样本预测为正类；否则，预测为负类。

三、算法步骤

1.选择预测函数

通常选择Sigmoid函数作为预测函数，用于将线性回归的输出值转换为概率值。

2.构造损失函数

损失函数用于衡量预测结果与实际结果之间的差异。在逻辑回归中，常用的损失函数是交叉熵损失函数（又称对数损失函数）。

3.优化算法

通过优化算法（如梯度下降法）来最小化损失函数，从而得到最优的权重和偏置项。优化过程通过迭代更新权重和偏置项，使得损失函数逐渐减小。

四、算法实现

1.引用的库

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

2.设置训练集并计算准确度

# 设置随机种子
seed_value = 2023
np.random.seed(seed_value)

# 导入数据
iris = load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1
 
# 划分训练集、测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=seed_value)
 
# 训练模型
model = LogisticRegression(learning_rate=0.03, iterations=1000)
model.fit(X_train, y_train)
 
# 结果
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
 
score_train = model.score(y_train_pred, y_train)
score_test = model.score(y_test_pred, y_test)
 
print('训练集Accuracy: ', score_train)
print('测试集Accuracy: ', score_test)

3.计算损失值（逻辑回归模型）

# Sigmoid激活函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))
 
# 定义逻辑回归算法
class LogisticRegression:
    def __init__(self, learning_rate=0.003, iterations=100):
        self.learning_rate = learning_rate # 学习率
        self.iterations = iterations # 迭代次数
 
    def fit(self, X, y):
        # 初始化参数
        self.weights = np.random.randn(X.shape[1])
        self.bias = 0
 
        # 梯度下降
        for i in range(self.iterations):
            # 计算sigmoid函数的预测值, y_hat = w * x + b
            y_hat = sigmoid(np.dot(X, self.weights) + self.bias)
 
            # 计算损失函数
            loss = (-1 / len(X)) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))
 
            # 计算梯度
            dw = (1 / len(X)) * np.dot(X.T, (y_hat - y))
            db = (1 / len(X)) * np.sum(y_hat - y)
 
            # 更新参数
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
 
            # 打印损失函数值
            if i % 10 == 0:
                print(f"Loss after iteration {i}: {loss} ",end='')
 
    # 预测
    def predict(self, X):
        y_hat = sigmoid(np.dot(X, self.weights) + self.bias)
        y_hat[y_hat >= 0.5] = 1
        y_hat[y_hat < 0.5] = 0
        return y_hat
    
    # 精度
    def score(self, y_pred, y):
        accuracy = (y_pred == y).sum() / len(y)
        return accuracy

4.绘制决策图

# 可视化决策边界
x1_min, x1_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
x2_min, x2_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max, 100), np.linspace(x2_min, x2_max, 100))
Z = model.predict(np.c_[xx1.ravel(), xx2.ravel()])
Z = Z.reshape(xx1.shape)
plt.contourf(xx1, xx2, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
plt.xlabel("Sepal length")
plt.ylabel("Sepal width")
plt.show()

5.完整代码展示

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
 
# 设置随机种子
seed_value = 2023
np.random.seed(seed_value)
 
# Sigmoid激活函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))
 
# 定义逻辑回归算法
class LogisticRegression:
    def __init__(self, learning_rate=0.003, iterations=100):
        self.learning_rate = learning_rate # 学习率
        self.iterations = iterations # 迭代次数
 
    def fit(self, X, y):
        # 初始化参数
        self.weights = np.random.randn(X.shape[1])
        self.bias = 0
 
        # 梯度下降
        for i in range(self.iterations):
            # 计算sigmoid函数的预测值, y_hat = w * x + b
            y_hat = sigmoid(np.dot(X, self.weights) + self.bias)
 
            # 计算损失函数
            loss = (-1 / len(X)) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))
 
            # 计算梯度
            dw = (1 / len(X)) * np.dot(X.T, (y_hat - y))
            db = (1 / len(X)) * np.sum(y_hat - y)
 
            # 更新参数
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
 
            # 打印损失函数值
            if i % 10 == 0:
                print(f"Loss after iteration {i}: {loss} ",end='')
 
    # 预测
    def predict(self, X):
        y_hat = sigmoid(np.dot(X, self.weights) + self.bias)
        y_hat[y_hat >= 0.5] = 1
        y_hat[y_hat < 0.5] = 0
        return y_hat
    
    # 精度
    def score(self, y_pred, y):
        accuracy = (y_pred == y).sum() / len(y)
        return accuracy
 
# 导入数据
iris = load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1
 
# 划分训练集、测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=seed_value)
 
# 训练模型
model = LogisticRegression(learning_rate=0.03, iterations=1000)
model.fit(X_train, y_train)
 
# 结果
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
 
score_train = model.score(y_train_pred, y_train)
score_test = model.score(y_test_pred, y_test)
 
print('训练集Accuracy: ', score_train)
print('测试集Accuracy: ', score_test)
 
# 可视化决策边界
x1_min, x1_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
x2_min, x2_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max, 100), np.linspace(x2_min, x2_max, 100))
Z = model.predict(np.c_[xx1.ravel(), xx2.ravel()])
Z = Z.reshape(xx1.shape)
plt.contourf(xx1, xx2, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
plt.xlabel("Sepal length")
plt.ylabel("Sepal width")
plt.show()

6.运行结果图

本次实验我们使用鸢尾花数据集来实现逻辑回归算法，得到了如上一百个损失行数值与训练集和·测试集的准确度。

调用函数可以看到绘制的数据集及最佳拟合直线展示在坐标图中。分类结果较好，仅错分几个数据。

五、实验小结

        实验我们学习了对逻辑回归算法的具体实现，逻辑回归应用于分类问题，常用于二分类问题。逻辑回归的目的就是找到Sigmoid函数的最佳拟合参数，求解最佳拟合参数的过程可以通过最优化算法实现，最优化算法有很多种，比如梯度上升、梯度下降等等。对于后续的机器学习打下了坚实的基础。