从0实现logistic回归

要从零开始实现逻辑回归，你需要以下步骤：

1. 准备数据集：将数据集划分为特征矩阵 X 和目标变量向量 y。

2. 初始化参数：初始化权重向量 w 和偏置 b。

3. 定义sigmoid函数：sigmoid函数将实数映射到0和1之间的概率值。

4. 定义损失函数：使用对数似然损失函数来度量预测概率与实际标签之间的差异。

5. 计算梯度：通过计算损失函数对参数 w 和 b 的偏导数来得到梯度。

6. 更新参数：使用梯度下降法来更新参数，减小损失函数的值。

7. 训练模型：使用训练集进行多次迭代，不断更新参数以优化模型。

8. 预测：使用训练好的参数进行预测。

下面是一个简单的示例代码来实现逻辑回归：

import numpy as np

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

# 定义损失函数
def loss_function(y_pred, y_true):
    return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

# 初始化参数
def initialize_parameters(dim):
    w = np.zeros((dim, 1))
    b = 0
    return w, b

# 计算梯度
def compute_gradient(X, y, y_pred):
    m = X.shape[1]
    dw = np.dot(X, (y_pred - y).T) / m
    db = np.mean(y_pred - y)
    return dw, db

# 更新参数
def update_parameters(w, b, dw, db, learning_rate):
    w = w - learning_rate * dw
    b = b - learning_rate * db
    return w, b

# 训练模型
def train(X, y, num_iterations, learning_rate):
    w, b = initialize_parameters(X.shape[0])
    
    for i in range(num_iterations):
        # 前向传播
        y_pred = sigmoid(np.dot(w.T, X) + b)
        
        # 计算损失
        loss = loss_function(y_pred, y)
        
        # 计算梯度
        dw, db = compute_gradient(X, y, y_pred)
        
        # 更新参数
        w, b = update_parameters(w, b, dw, db, learning_rate)
        
        # 每100次迭代打印一次损失
        if i % 100 == 0:
            print(f"Loss after iteration {i}: {loss}")
    
    return w, b

# 预测
def predict(w, b, X):
    y_pred = sigmoid(np.dot(w.T, X) + b)
    y_pred = np.round(y_pred)
    return y_pred

# 示例数据
X = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[0, 1, 1]])

# 训练模型
w, b = train(X, y, num_iterations=1000, learning_rate=0.01)

# 预测
y_pred = predict(w, b, X)
print("Predictions:", y_pred)

请注意，这只是一个简单的实现，实际的逻辑回归模型可能会有更多的步骤和复杂性。