哈工大机器学习实验二（基于梯度下降法和牛顿法的逻辑回归）

已于 2024-09-20 23:54:23 修改
阅读量1.1k 收藏 28
点赞数 27
文章标签： 机器学习 人工智能 python
于 2024-09-20 23:53:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73423690/article/details/142397662
版权

哈工大机器学习实验二（基于梯度下降法和牛顿法的逻辑回归）

1. 数据准备

1.1 生成数据

def Data(N, naive_bayes=True, true_rate=0.5):
    number_true = np.ceil(N * true_rate).astype(np.int32)
    sigma = [0.2, 0.3]
    cov12 = 0.2
    miu_true = [0.9, 1.1]
    miu_false = [-1, -1.3]
    x = np.zeros((N, 2))
    y = np.zeros(N).astype(np.int32)
    if naive_bayes:
        x[:number_true, :] = np.random.multivariate_normal(
            mean=miu_true, cov=[[sigma[0], 0], [0, sigma[1]]], size=number_true
        )
        x[number_true:, :] = np.random.multivariate_normal(
            mean=miu_false, cov=[[sigma[0], 0], [0, sigma[1]]], size=N - number_true
        )
        y[:number_true] = 1
        y[number_true:] = 0
    else:
        x[:number_true, :] = np.random.multivariate_normal(
            mean=miu_true, cov=[[sigma[0], cov12], [cov12, sigma[1]]], size=number_true
        )
        x[number_true:, :] = np.random.multivariate_normal(
            mean=miu_false,
            cov=[[sigma[0], cov12], [cov12, sigma[1]]],
            size=N - number_true,
        )
        y[:number_true] = 1
        y[number_true:] = 0
    return x,y

符合朴素贝叶斯假设与不符合朴素贝叶斯假设的关键：cov12是否为0，即特征之间是否相互独立

1.2 绘制生成的数据图来对比

def plot_data(x, y):
    plt.figure(figsize=(8, 6))
    plt.scatter(x[y == 1, 0], x[y == 1, 1], color='red', label='Class 1', alpha=0.5)
    plt.scatter(x[y == 0, 0], x[y == 0, 1], color='blue', label='Class 0', alpha=0.5)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.title('Data Visualization')
    plt.legend()
    plt.grid(True)
    plt.savefig("ml_lab2\data.png")
    plt.show()

符合朴素贝叶斯假设的数据：
在这里插入图片描述

不符合朴素贝叶斯假设的数据：
在这里插入图片描述
数据点呈现 长条状 ，说明X的两个维度之间存在线性相关性

1.3 数据分割

将数据分为6：2：2的比例

def split_data(X, Y, train_size=0.6, val_size=0.2, test_size=0.2):
    # 分割数据集为训练集、验证集和测试集
    X_train, X_temp, Y_train, Y_temp = train_test_split(X, Y, train_size=train_size)
    X_val, X_test, Y_val, Y_test = train_test_split(
        X_temp, Y_temp, test_size=test_size / (val_size + test_size)
    )
    return X_train, X_val, X_test, Y_train, Y_val, Y_test

2. 问题求解

逻辑回归的损失函数为：
l o s s ( w ) = ∑ l ( − Y l w T X l + ln ⁡ ( 1 + exp ⁡ ( w T X l ) ) ) + λ 2 w T w {loss}(w) = \sum_{l} \left( -Y^l {w}^T {X}^l + \ln(1 + \exp({w}^T {X}^l)) \right) + \frac{\lambda}{2} {w}^T {w} loss(w)=l∑​(−YlwTXl+ln(1+exp(wTXl)))+2λ​wTw

2.1 梯度下降法

2.1.1 没有惩罚项的情况

def compute_loss(X, Y, W):
    m = len(Y)
    predictions = sigmoid(np.dot(X, W))
    loss = -np.sum(Y * np.log(predictions) + (1 - Y) * np.log(1 - predictions)) / m
    return loss


def gradient_descent(
    X_train, Y_train, X_test, Y_test, learning_rate=0.01, iterations=10000
):
    # 初始化权重
    W = np.zeros(X_train.shape[1])
    m = len(Y_train)
    for i in range(iterations):
        predictions = sigmoid(np.dot(X_train, W))
        updates = np.dot(X_train.T, predictions - Y_train) / m
        W -= learning_rate * updates
    # 计算测试集的准确率
    predictions = predict(X_test, W)
    accuracy = np.mean(predictions == Y_test)  # 计算准确率
    print("Accuracy:", accuracy)
    # 绘制数据和决策边界
    plot_data_boundary(X_test[:, 1:], Y_test, W)  # 传递不包括偏置项的特征


def plot_data_boundary(x, y, W):
    plt.figure(figsize=(8, 6))
    plt.scatter(x[y == 1, 0], x[y == 1, 1], color="red", label="Class 1", alpha=0.5)
    plt.scatter(x[y == 0, 0], x[y == 0, 1], color="blue", label="Class 0", alpha=0.5)
    # 绘制决策边界
    plot_x = np.linspace(x[:, 0].min() - 1, x[:, 0].max() + 1, 100)
    plot_y = -(W[0] + W[1] * plot_x) / W[2]
    plt.plot(plot_x, plot_y, label="Decision Boundary")
    plt.xlabel("Feature 1")
    plt.ylabel("Feature 2")
    plt.title("Data Visualization with Decision Boundary")
    plt.legend()
    plt.grid(True)
    plt.savefig("ml_lab2\data_with_boundary.png")
    plt.show()

符合朴素贝叶斯假设的情况下，测试集的准确率为1.0，绘制下图
在这里插入图片描述

符合朴素贝叶斯假设的情况下，测试集的准确率为0.985，绘制下图
在这里插入图片描述

2.1.2 有惩罚项的情况

先通过验证集来找适合的正则化参数

def find_best_lambda(X_train, Y_train, X_val, Y_val, learning_rate=0.01, iterations=10000):
    idx = np.linspace(-30, 5)
    lambda_candidates = np.exp(idx)
    losses = []
    for lambd in lambda_candidates:
        W = np.zeros(X_train.shape[1])
        m = len(Y_train)
        for i in range(iterations):
            predictions = sigmoid(np.dot(X_train, W))
            updates = np.dot(X_train.T, predictions - Y_train) / m
            updates += lambd * W / m
            W -= learning_rate * updates
        # 计算验证集的损失
        loss = compute_loss(X_val, Y_val, W, lambd)
        losses.append(loss)
    best_lambda = lambda_candidates[np.argmin(losses)]
    best_loss = min(losses)
    plt.figure(figsize=(10, 6))
    plt.plot(idx, losses, marker='o')
    plt.xlabel('Lambda')
    plt.ylabel('Validation Loss')
    plt.title('Validation Loss vs. Lambda')
    plt.axvline(idx[np.argmin(losses)], color='r', linestyle='--', label='Best Lambda')
    plt.legend()
    plt.show()
    return best_lambda, best_loss

在这里插入图片描述
选择 λ = e x p ( − 30 ) \lambda=exp(-30) λ=exp(−30)，并在loss计算和参数更新中加入正则化参数

def compute_loss(X, Y, W, lambd=0):
    m = len(Y)
    predictions = sigmoid(np.dot(X, W))
    loss = -np.sum(Y * np.log(predictions) + (1 - Y) * np.log(1 - predictions)) / m
    loss += lambd * np.sum(W**2) / (2 * m)
    return loss


def gradient_descent(
    X_train, Y_train, X_test, Y_test, learning_rate=0.01, iterations=10000, lambd=0
):
    # 初始化权重
    W = np.zeros(X_train.shape[1])
    m = len(Y_train)
    for i in range(iterations):
        predictions = sigmoid(np.dot(X_train, W))
        updates = np.dot(X_train.T, predictions - Y_train) / m
        updates += lambd * W / m
        W -= learning_rate * updates
    # 计算测试集的准确率
    predictions = predict(X_test, W)
    accuracy = np.mean(predictions == Y_test)  # 计算准确率
    print("Accuracy:", accuracy)
    # 绘制数据和决策边界
    plot_data_boundary(X_test[:, 1:], Y_test, W)  # 传递不包括偏置项的特征

符合朴素贝叶斯假设的情况下，测试集的准确率为0.998，绘制下图
在这里插入图片描述

符合朴素贝叶斯假设的情况下，测试集的准确率为0.992，绘制下图
在这里插入图片描述

2.2 牛顿法

2.2.1 公式推导

针对无条件极值/最优化问题： min ⁡ x f ( x ) \min_{x} f(x) minx​f(x)

假设 f ( x ) f(x) f(x) 有二阶连续偏导数，若第 k k k 次迭代值为 x k x^k xk，则可以将 f ( x ) f(x) f(x) 在 x k x^k xk 附近进行二阶泰勒展开：
f ( x ) = f ( x k ) + g k T ( x − x k ) + 1 2 ( x − x k ) T H ( x k ) ( x − x k ) f(x) = f(x^k) + g_k^T (x - x^k) + \frac{1}{2} (x - x^k)^T H(x^k) (x - x^k) f(x)=f(xk)+gkT​(x−xk)+21​(x−xk)TH(xk)(x−xk)
其中， g k = ∇ f ( x ) g_k = \nabla f(x) gk​=∇f(x) 是梯度向量， H ( x ) H(x) H(x) 是黑塞矩阵：
H ( x ) = [ ∂ 2 f ∂ x i ∂ x j ] n × n H(x) = \left[ \frac{\partial^2 f}{\partial x_i \partial x_j} \right]_{n \times n} H(x)=[∂xi​∂xj​∂2f​]n×n​

在极值点处 g k = 0 g_k = 0 gk​=0；其中，当 H ( x ) H(x) H(x) 正定时， f ( x ) f(x) f(x) 的极值是极小值。

为了得到 g k = 0 g_k = 0 gk​=0 的点，对展开式求导：
d f ( x ) d x = g k + H k ( x − x k ) \frac{df(x)}{dx} = g_k + H_k (x - x^k) dxdf(x)​=gk​+Hk​(x−xk)
则极值点处：
d f ( x ) d x = 0 \frac{df(x)}{dx} = 0 dxdf(x)​=0
x k + 1 = x k − H k − 1 g k x^{k+1} = x^k - H_k^{-1} g_k xk+1=xk−Hk−1​gk​

得到迭代公式。

将其应用到我们的损失函数就是：
w k + 1 = w k − ( ∂ 2 l o s s ( w ) ∂ w ∂ w T ) − 1 ∂ l o s s ( w ) ∂ w w^{k+1} = w^k - \left(\frac{\partial^2 loss(w)}{\partial w \partial w^T}\right)^{-1} \frac{\partial loss(w)}{\partial w} wk+1=wk−(∂w∂wT∂2loss(w)​)−1∂w∂loss(w)​
我们的损失函数为：
l o s s ( w ) = ∑ l ( − Y l w T X l + ln ⁡ ( 1 + exp ⁡ ( w T X l ) ) ) + λ 2 w T w {loss}(w) = \sum_{l} \left( -Y^l {w}^T {X}^l + \ln(1 + \exp({w}^T {X}^l)) \right) + \frac{\lambda}{2} {w}^T {w} loss(w)=l∑​(−YlwTXl+ln(1+exp(wTXl)))+2λ​wTw
所以得到：
∂ l o s s ( w ) ∂ w = − ∑ l x l ( Y l − σ ( w T X ) ) + λ w \frac{\partial loss(w)}{\partial w} = -\sum_l x^l (Y^l - \sigma(w^T X)) + \lambda w ∂w∂loss(w)​=−l∑​xl(Yl−σ(wTX))+λw
∂ 2 l o s s ( w ) ∂ w ∂ w T = ∑ l ( X X T σ ( w T X ) σ ( − w T X ) ) + λ I \frac{\partial^2 loss(w)}{\partial w \partial w^T} = \sum_l (X X^T \sigma(w^T X) \sigma(-w^T X)) + \lambda I ∂w∂wT∂2loss(w)​=l∑​(XXTσ(wTX)σ(−wTX))+λI
这里直接写一个牛顿法的类，代码如下：

class LogisticRegressionNewton:
    def __init__(self, X, y, hyper=0.01, w_0=None, delta=1e-6):
        self.x = X
        self.y = y
        self.__m = len(y)
        self.__n = X.shape[1]
        self.hyper = hyper
        if w_0 is None:
            self.w_0 = np.zeros(self.__n)
        else:
            self.w_0 = w_0
        self.delta = delta

    def __derivative(self, w):
        result = np.zeros(self.__n)
        for i in range(self.__m):
            result += self.x[i] * (self.y[i] - sigmoid(w @ self.x[i]))
        return -1 * result + self.hyper * w

    def __second_derivative(self, w):
        ans = np.eye(self.__n) * self.hyper
        for i in range(self.__m):
            temp = sigmoid(w @ self.x[i])
            ans += self.x[i] * np.transpose([self.x[i]]) * temp * (1 - temp)
        return np.linalg.pinv(ans)

    def fit(self):
        w = self.w_0
        while True:
            gradient = self.__derivative(w)
            if np.linalg.norm(gradient) < self.delta:
                break
            hessian_inv = self.__second_derivative(w)
            w = w - hessian_inv @ gradient
        self.w_0 = w
        return w

    def predict(self, X):
        return sigmoid(np.dot(X, self.w_0)) >= 0.5

2.2.2 没有惩罚项的情况

符合朴素贝叶斯假设的情况下，测试集的准确率为0.998，绘制下图
在这里插入图片描述

符合朴素贝叶斯假设的情况下，测试集的准确率为0.987，绘制下图
在这里插入图片描述

2.2.3 有惩罚项的情况

符合朴素贝叶斯假设的情况下，测试集的准确率为0.999，绘制下图
在这里插入图片描述

符合朴素贝叶斯假设的情况下，测试集的准确率为0.991，绘制下图
在这里插入图片描述

2.3 运行代码

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


def Data(N, naive_bayes=True, true_rate=0.5):
    number_true = np.ceil(N * true_rate).astype(np.int32)
    sigma = [0.2, 0.3]
    cov12 = 0.2
    miu_true = [0.9, 1.1]
    miu_false = [-1, -1.3]
    x = np.zeros((N, 2))
    y = np.zeros(N).astype(np.int32)
    if naive_bayes:
        x[:number_true, :] = np.random.multivariate_normal(
            mean=miu_true, cov=[[sigma[0], 0], [0, sigma[1]]], size=number_true
        )
        x[number_true:, :] = np.random.multivariate_normal(
            mean=miu_false, cov=[[sigma[0], 0], [0, sigma[1]]], size=N - number_true
        )
        y[:number_true] = 1
        y[number_true:] = 0
    else:
        x[:number_true, :] = np.random.multivariate_normal(
            mean=miu_true, cov=[[sigma[0], cov12], [cov12, sigma[1]]], size=number_true
        )
        x[number_true:, :] = np.random.multivariate_normal(
            mean=miu_false,
            cov=[[sigma[0], cov12], [cov12, sigma[1]]],
            size=N - number_true,
        )
        y[:number_true] = 1
        y[number_true:] = 0
    return x, y


def split_data(X, Y, train_size=0.6, val_size=0.2, test_size=0.2):
    # 分割数据集为训练集、验证集和测试集
    X_train, X_temp, Y_train, Y_temp = train_test_split(X, Y, train_size=train_size)
    X_val, X_test, Y_val, Y_test = train_test_split(
        X_temp, Y_temp, test_size=test_size / (val_size + test_size)
    )
    return X_train, X_val, X_test, Y_train, Y_val, Y_test


def plot_data(x, y):
    plt.figure(figsize=(8, 6))
    plt.scatter(x[y == 1, 0], x[y == 1, 1], color="red", label="Class 1", alpha=0.5)
    plt.scatter(x[y == 0, 0], x[y == 0, 1], color="blue", label="Class 0", alpha=0.5)
    plt.xlabel("Feature 1")
    plt.ylabel("Feature 2")
    plt.title("Data Visualization")
    plt.legend()
    plt.grid(True)
    plt.savefig("ml_lab2\data.png")
    plt.show()


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def predict(X, W):
    return sigmoid(np.dot(X, W)) >= 0.5


def compute_loss(X, Y, W, lambd=0):
    m = len(Y)
    predictions = sigmoid(np.dot(X, W))
    loss = -np.sum(Y * np.log(predictions) + (1 - Y) * np.log(1 - predictions)) / m
    loss += lambd * np.sum(W**2) / (2 * m)
    return loss


def gradient_descent(
    X_train, Y_train, X_test, Y_test, learning_rate=0.01, iterations=10000, lambd=0
):
    # 初始化权重
    W = np.zeros(X_train.shape[1])
    m = len(Y_train)
    for i in range(iterations):
        predictions = sigmoid(np.dot(X_train, W))
        updates = np.dot(X_train.T, predictions - Y_train) / m
        updates += lambd * W / m
        W -= learning_rate * updates
    # 计算测试集的准确率
    predictions = predict(X_test, W)
    accuracy = np.mean(predictions == Y_test)  # 计算准确率
    print("Accuracy:", accuracy)
    # 绘制数据和决策边界
    plot_data_boundary(X_test[:, 1:], Y_test, W)  # 传递不包括偏置项的特征


def find_best_lambda(
    X_train, Y_train, X_val, Y_val, learning_rate=0.01, iterations=10000
):
    idx = np.linspace(-30, 5)
    lambda_candidates = np.exp(idx)
    losses = []
    for lambd in lambda_candidates:
        W = np.zeros(X_train.shape[1])
        m = len(Y_train)
        for i in range(iterations):
            predictions = sigmoid(np.dot(X_train, W))
            updates = np.dot(X_train.T, predictions - Y_train) / m
            updates += lambd * W / m
            W -= learning_rate * updates
        # 计算验证集的损失
        loss = compute_loss(X_val, Y_val, W, lambd)
        losses.append(loss)
    best_lambda = lambda_candidates[np.argmin(losses)]
    best_loss = min(losses)
    plt.figure(figsize=(10, 6))
    plt.plot(idx, losses, marker="o")
    plt.xlabel("Lambda")
    plt.ylabel("Validation Loss")
    plt.title("Validation Loss vs. Lambda")
    plt.axvline(idx[np.argmin(losses)], color="r", linestyle="--", label="Best Lambda")
    plt.legend()
    plt.show()
    return best_lambda, best_loss


def plot_data_boundary(x, y, W):
    plt.figure(figsize=(8, 6))
    plt.scatter(x[y == 1, 0], x[y == 1, 1], color="red", label="Class 1", alpha=0.5)
    plt.scatter(x[y == 0, 0], x[y == 0, 1], color="blue", label="Class 0", alpha=0.5)
    # 绘制决策边界
    plot_x = np.linspace(x[:, 0].min() - 1, x[:, 0].max() + 1, 1000)
    plot_y = -(W[0] + W[1] * plot_x) / W[2]
    plt.plot(plot_x, plot_y, label="Decision Boundary")
    plt.xlabel("Feature 1")
    plt.ylabel("Feature 2")
    plt.title("Data Visualization with Decision Boundary")
    plt.legend()
    plt.grid(True)
    plt.savefig("ml_lab2\data_with_boundary.png")
    plt.show()


class LogisticRegressionNewton:
    def __init__(self, X, y, hyper=0.01, w_0=None, delta=1e-6):
        self.x = X
        self.y = y
        self.__m = len(y)
        self.__n = X.shape[1]
        self.hyper = hyper
        if w_0 is None:
            self.w_0 = np.zeros(self.__n)
        else:
            self.w_0 = w_0
        self.delta = delta

    def __derivative(self, w):
        result = np.zeros(self.__n)
        for i in range(self.__m):
            result += self.x[i] * (self.y[i] - sigmoid(w @ self.x[i]))
        return -1 * result + self.hyper * w

    def __second_derivative(self, w):
        ans = np.eye(self.__n) * self.hyper
        for i in range(self.__m):
            temp = sigmoid(w @ self.x[i])
            ans += self.x[i] * np.transpose([self.x[i]]) * temp * (1 - temp)
        return np.linalg.pinv(ans)

    def fit(self):
        w = self.w_0
        while True:
            gradient = self.__derivative(w)
            if np.linalg.norm(gradient) < self.delta:
                break
            hessian_inv = self.__second_derivative(w)
            w = w - hessian_inv @ gradient
        self.w_0 = w
        return w

    def predict(self, X):
        return sigmoid(np.dot(X, self.w_0)) >= 0.5


if __name__ == "__main__":
    N = 5000  # 数据点的数量
    naive_bayes = True  # 是否使用朴素贝叶斯假设
    true_rate = 0.5  # 正例的比例
    X, Y = Data(N, naive_bayes, true_rate)
    # 添加偏置项
    X = np.hstack((np.ones((N, 1)), X))  # 添加第一列的1
    # 分割数据集
    X_train, X_val, X_test, Y_train, Y_val, Y_test = split_data(X, Y)
    # 寻找最佳的lambda
    # best_lambda, best_loss = find_best_lambda(X_train, Y_train, X_val, Y_val)
    # 执行梯度下降
    # gradient_descent(X_train, Y_train, X_test, Y_test,np.exp(-30))

    # 创建逻辑回归模型实例
    model = LogisticRegressionNewton(X_train, Y_train)
    # 训练模型
    W = model.fit()
    plot_data_boundary(X_test[:, 1:], Y_test, W)
    # 计算测试集的准确率
    predictions = model.predict(X_test)
    accuracy = np.mean(predictions == Y_test)
    print("Test Accuracy:", accuracy)

3. UCI数据集的应用

3.1 数据集介绍

UCI成年人收入数据集（Adult Income Dataset）是一个广泛用于机器学习和数据挖掘领域的数据集，特别是在分类和预测建模任务中。该数据集的目标是预测一个成年人（基于1994年的人口普查数据库）的年收入是否超过50,000美元。这是一个典型的二分类问题，其中收入超过50K的个体被标记为正类（1），而收入不超过50K的个体被标记为负类（0）。

以下是该数据集的一些关键特点：

数据来源：数据集来源于1994年的美国人口普查数据库。

特征：数据集包含14个特征，包括：
年龄（age）
工作类别（workclass）
权重（fnlwgt）
教育水平（education）
教育年数（education-num）
婚姻状况（marital-status）
职业（occupation）
与户主关系（relationship）
种族（race）
性别（sex）
资本收益（capital-gain）
资本损失（capital-loss）
每周工作小时数（hours-per-week）
出生地（native-country）

类别：目标变量是“收入”，分为两类：
收入超过50K美元（>50K）
收入不超过50K美元（≤50K）

数据规模：数据集包含约32,000个样本（个体）。

UCI成年人收入数据集是机器学习领域的一个标准基准数据集，它提供了一个相对简单但实际的问题，用于评估和比较不同的算法性能。

3.2 UCI运行代码

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# 定义sigmoid函数，添加clip防止溢出
def sigmoid(x):
    x = np.clip(x, -500, 500)  # 限制x的值，防止溢出
    return 1 / (1 + np.exp(-x))

# 定义计算损失的函数，添加epsilon避免对数计算问题
def compute_loss(X, Y, W, lambd=0, epsilon=1e-10):
    m = len(Y)
    predictions = sigmoid(np.dot(X, W))
    predictions = np.clip(predictions, epsilon, 1 - epsilon)  # 限制predictions的值，避免对数计算问题
    loss = -np.sum(Y * np.log(predictions) + (1 - Y) * np.log(1 - predictions)) / m
    loss += lambd * np.sum(W**2) / (2 * m)
    return loss

# 定义梯度下降函数
def gradient_descent(X_train, Y_train, learning_rate=0.01, iterations=10000, lambd=0):
    W = np.zeros(X_train.shape[1])
    m = len(Y_train)
    for i in range(iterations):
        predictions = sigmoid(np.dot(X_train, W))
        predictions = np.clip(predictions, 1e-10, 1 - 1e-10)  # 同上
        gradient = np.dot(X_train.T, (predictions - Y_train)) / m
        gradient += lambd * W / m
        W -= learning_rate * gradient
    return W

# 定义预测函数
def predict(X, W):
    return sigmoid(np.dot(X, W)) >= 0.5

# 定义计算准确率的函数
def accuracy(Y, predictions):
    return np.mean(predictions == Y)
    
# 加载数据集
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
column_names = [
    "age", "workclass", "fnlwgt", "education", "education-num", "marital-status",
    "occupation", "relationship", "race", "sex", "capital-gain", "capital-loss",
    "hours-per-week", "native-country", "income"
]
data = pd.read_csv(url, names=column_names, sep=',\s', na_values=["?"], engine='python')

# 数据预处理
# 将类别型数据转换为数值型数据
label_encoders = {}
for column in data.columns:
    le = LabelEncoder()
    data[column] = le.fit_transform(data[column])
    label_encoders[column] = le

# 处理缺失值
data = data.dropna()

# 定义特征和标签
X = data.drop('income', axis=1).values
Y = (data['income'] == ' >50K').astype(int).values

# 添加偏置项
X = np.hstack((np.ones((X.shape[0], 1)), X))

# 分割数据集为训练集和测试集
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# 执行梯度下降
W = gradient_descent(X_train, Y_train, learning_rate=0.01, iterations=10000, lambd=0.01)

# 预测测试集
predictions = predict(X_test, W)

# 计算准确率
accuracy = accuracy(Y_test, predictions)
print("Test Accuracy:", accuracy)

# 计算测试集的损失
loss = compute_loss(X_test, Y_test, W, lambd=0.01)
print("Test Loss:", loss)

运行得到的结果是：
Test Accuracy: 1.0
Test Loss: 0.0021162482132220067

ybx-tih
关注
机器学习(二)：线性回归之梯度下降法
阿极的博客
04-13 2548
梯度下降法是一种常见的优化方法，常用于求解损失函数最小化的问题。在线性回归模型中，我们可以使用梯度下降法来求解使得模型损失函数最小的模型参数。
机器学习实验（二）：梯度下降和牛顿法解逻辑回归
勿忘初心的博客
11-24 1689
一：梯度下降法 加载实验数据画出画出散点图，区分出能进入大学的学生和不能进入大学的学生。 回顾逻辑回归，其假设函数为            hθx=gθTx=11+e-θTx=p(y=1|x;θ) 在使用前先声明此函数，代码如下：                 g=inline(‘1.0./(1.0+exp(-z))) 当我们给定一个训练数据集时，x(i)i=1,2,…,m 我们定义似...
多元线性回归用梯度下降法来训练模型
qq_41342577的博客
09-24 2163
多元线性回归训练分为两种，一种是公式训练，一种是梯度下降法训练 公式训练 我已经记录了，具体可以看https://blog.csdn.net/qq_41342577/article/details/82320174 梯度训练法 原理 https://blog.csdn.net/qq_41342577/article/details/82718519 如何使用梯度下降法来求出所需参数 损...
机器学习 | 实验二：多变量线性回归
知识库搭建ing
03-12 587
实验二：多变量线性回归
机器学习与数据挖掘实验2-使用梯度下降法训练多远线性回归模型
软肋.的博客
11-10 169
最终的数据散点图与损失变化图的3D图像无法呈现的问题：本电脑上装的matplotlib 3.6.2不能够显示3D图像，而3.4.3版本的可以，因此可以选择将该包的版本更换。另一种解决方法是将代码Ax = Axes3D(fig) 改为 Ax = fig.add_axes(Axes3D(fig))，也可以解决这个问题。
机器学习与数据挖掘实验1-使用梯度下降法训练线性回归模型
软肋.的博客
11-10 88
记得自行导入数据文件data1.txt。
机器学习——逻辑回归（梯度下降法、牛顿法）
weixin_43973089的博客
04-30 4814
机器学习——逻辑回归一、实验题目二、实验目的三、实验平台四、基本原理1. 逻辑回归2. 损失函数五、实验步骤1. 数据可视化2. 将线性回归参数初始化为0，计算代价函数(cost function)的初始值3. 选择一种优化方法求解逻辑回归参数3.1. 梯度下降法3.2. 牛顿迭代法4. 某学生两次考试成绩分别为 42、85，预测其被录取的概率5. 画出分类边界六、程序清单 代码见https://pan.baidu.com/s/17OD94C71-J1u_lY3zN8lUQ （提取码：vp13），仅供参考
基于梯度下降法和牛顿法的逻辑回归.zip
08-25
梯度下降法是优化算法的一种，常用于求解机器学习模型中的参数。在逻辑回归中，我们通常最小化损失函数（如对数似然损失）来找到最佳参数。梯度下降通过沿着目标函数梯度的反方向更新参数，逐步接近局部或全局最小值...
逻辑回归(Logistic Regression)（梯度下降法，牛顿法）.zip
08-25
在本压缩包文件中，我们可能会看到与逻辑回归相关的代码资源，特别是关于梯度下降法和牛顿法两种优化算法的实现。 **1. 梯度下降法：** 梯度下降法是求解损失函数最小化的一种常用迭代方法，尤其适用于大型数据集。...
基于LR的优化方法：梯度下降法，随机梯度下降法，牛顿法，LBFGS，BFGS.zip
08-25
本资料包主要探讨了五种常见的优化方法，分别是梯度下降法、随机梯度下降法、牛顿法以及两种有限内存的拟牛顿法——LBFGS和BFGS。这些方法在逻辑回归（Logistic Regression, LR）和其他复杂模型如神经网络中广泛使用...
牛顿法、梯度下降法原理及Python编程应用
12-21
牛顿法和梯度下降法是两种常用的最优化方法，它们在解决数学、工程和机器学习中的优化问题中发挥着重要作用。这两种方法都是基于迭代的思想，寻找目标函数的极值点，即最小值或最大值。 牛顿法，源于牛顿-拉弗森...
python使用梯度下降和牛顿法寻找Rosenbrock函数最小值实例
09-17
在机器学习和优化问题中，梯度下降和牛顿法是两种常见的优化算法，用于寻找函数的局部或全局最小值。在这个Python实例中，我们关注的是Rosenbrock函数，这是一个常用的测试函数，因其复杂的鞍点结构而闻名，用于检验...
《机器学习与数据挖掘》实验一：梯度下降法训练线性回归模型
weixin_73598378的博客
09-14 433
### 实验环境（硬件和软件）Anaconda/Jupyternotebook/Pycharm。#### 实验目的：掌握线性回归的基本原理，以及梯度下降法和最小二乘法；（1）编码实现基于梯度下降的单变量线性回归算法，包括梯度的计算与验证；（4）基于训练得到的参数，输入新的样本数据，输出预测值；4.基于训练得到的参数，输入新的样本数据，输出预测值；#### 实验题目：使用梯度下降法训练线性回归模型。（2）画数据散点图，以及得到的直线；（3）画梯度下降过程中损失的变量图；2.步骤，求损失变化量。
机器学习中的聚类
m0_68676142的博客
09-29 881
聚类是无监督学习中的重要任务，旨在将数据集划分为若干个子集（簇），使得同一簇内的样本相似度高而不同簇间的样本相似度低。本周学习了聚类的性能度量指标，包括内部和外部指标，如Jaccard系数、Rand指数、DB指数等，并介绍了几种常见的距离计算方法。此外，深入学习了几种原型聚类算法：k均值、学习向量量化(LVQ)以及高斯混合模型(GMM)，并以K-means算法为例，通过鸢尾花数据集进行了实战演示。本周学习了机器学习中聚类任务的基础概念与主要方法，强调了在无监督场景下发现数据内在结构的重要性。
大数据分析案例-基于逻辑回归算法构建抑郁非抑郁推文识别模型
m0_64336780的博客
10-04 5511
本项目基于逻辑回归算法构建抑郁非抑郁推文识别模型具有重要的研究背景和应用价值。通过该模型的研究和应用，我们可以更好地理解和预测社交媒体中用户的心理健康状况，为抑郁症等心理疾病的防治提供有力的支持。在本次实验中，我们探索了使用不同的机器学习算法——逻辑回归、决策树和XGBoost——来构建抑郁非抑郁推文识别模型。经过严格的模型训练和验证过程，我们对比了三种模型的性能，并发现逻辑回归模型在准确率上达到了91%，超过了决策树和XGBoost模型。因此，我们最终选择了逻辑回归模型作为本次实验的最终模型。
机器学习课程学习周报十五
weixin_51454889的博客
10-06 1012
本周的学习涵盖了统计推断和贝叶斯推断的基本概念，深入探讨了高斯混合模型中的EM算法及其有效性证明。此外，还介绍了马尔可夫链蒙特卡罗方法中的蒙特卡罗法及其应用。最后，通过Diffusion模型中的马尔可夫链，理解了如何实现图像生成的降噪过程。本周完善了上周学习的EM算法，并且开始学习马尔可夫链蒙特卡罗法，马尔可夫链在Diffusion模型中有特别重要的应用。接来的一周将从理论继续学习马尔可夫链蒙特卡罗法，并结合着实际应用中的Diffusion模型进行参照。
机器学习系列篇章0 --- 人工智能&机器学习相关概念梳理
xhblair的博客
10-06 1346
本文作为机器学习专栏的第一篇文章，对 AI相关的概念以及机器学习的一些基础知识做了梳理和介绍
YOLO11改进|注意力机制篇|引入上下文锚注意力机制CAA
A1983Z的博客
10-06 1201
YOLO11中添加CAA注意力机制
支持向量机（SVM）基础教程
最新发布
m0_67484548的博客
10-06 936
支持向量机（SVM）基础教程
逻辑回归模型中梯度下降法与牛顿法的应用研究
资源摘要信息:"本压缩包资源提供了基于梯度下降法和牛顿法实现的逻辑回归算法的详细代码和相关解释。逻辑回归是一种广泛应用于分类问题的统计方法，尤其适用于二分类问题。在逻辑回归中，我们使用逻辑函数（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值