目录

• 引言
• 线性回归：预测连续值的利器
  • 原理：简单而强大的数学模型
  • 损失函数：衡量模型表现的标准
  • 梯度下降：寻找最佳参数的旅程
  • 正则化：防止过拟合的盾牌
  • 模型评估：衡量性能的标准
  • 实际案例：房价预测
• 逻辑回归：分类问题的基石
  • 原理：从线性到概率的转变
  • Sigmoid函数：概率转换的桥梁
  • 交叉熵损失：分类问题的理想损失函数
  • 逻辑回归的实现
  • 多分类问题：一对多策略
  • 模型评估：分类性能指标
• 总结与展望

---

引言

在人工智能和机器学习的浩瀚星空中，监督学习算法犹如指引方向的北极星，照亮我们前进的道路。作为一名在AI领域深耕15年的老兵，我深刻理解，基石往往决定着高楼的高度。线性回归与逻辑回归，正是机器学习中最基础和重要的算法之一。它们不仅是预测房价、洞察市场趋势、评估疾病风险的利器，更是我们理解更复杂模型的基石。

本文，我将以深入浅出的方式，剥茧抽丝般地解析线性回归与逻辑回归的奥秘。从理论的高度，到实践的深度，再到应用的广度，带你领略这两种算法的精髓。我会用平实的语言、生动的案例、以及可直接运行的Python代码，将那些看似高深莫测的概念，转化为你触手可及的技能。准备好了吗？让我们一起踏上这段 AI 高手进阶之路！

线性回归：预测连续值的利器

原理：简单而强大的数学模型

线性回归，顾名思义，其核心在于“线性”二字。它假设输入特征与输出值之间存在着一条直线（或超平面）的关系。这种关系用数学公式表达出来，简洁而优雅。

对于最简单的单变量线性回归，我们用以下公式来描述：

$$y=wx+b$$

在这个公式中，y 是我们渴望预测的数值，比如房价、销售额等；x 是输入特征，例如房屋面积、广告投入；w 是权重，代表特征 x 对 y 的影响程度；b 是偏置，可以理解为当 x 为 0 时 y 的基准值。

当特征不止一个时，线性回归就升级为多变量线性回归。公式也随之扩展为：

$$y=w_1{x}_1+w_2{x}_2+...+w_n{x}_n+b$$

为了让公式更简洁，我们可以使用矩阵的形式来表示：y = Wx + b。其中，W 是权重向量，x 是特征向量。

线性回归模型的系统架构可以用下图表示：

损失函数：衡量模型表现的标准

模型的好坏，不能只凭感觉，需要一个客观的评价标准。在线性回归中，均方误差 (Mean Squared Error, MSE) 就是最常用的损失函数。它的公式如下：

$$MSE=(1/n)\Sigma (y_{t}rue-y_{p}red{)}^2$$

这个公式的含义是：对于所有样本，计算模型预测值 y_pred 与真实值 y_true 之间差的平方，然后求平均值。MSE 的值越小，说明模型的预测结果与真实值越接近，模型也就越优秀。我们的目标就是找到一组最优的参数 w 和 b，使得 MSE 尽可能地小。

梯度下降：寻找最佳参数的旅程

有了损失函数，就像有了目标。接下来，我们需要找到一种方法，朝着目标前进。梯度下降 (Gradient Descent) 算法就是这个指路明灯。它是一种迭代优化算法，通过不断调整参数，逐步逼近损失函数的最小值。

梯度，简单来说，就是函数在某一点变化最快的方向。负梯度方向，就是函数值下降最快的方向。梯度下降法的核心思想就是：沿着损失函数的负梯度方向，一步一步地调整参数。

参数更新的公式如下：

$$w=w-\alpha \ast \partial MSE/\partial w$$
$$b=b-\alpha \ast \partial MSE/\partial b$$

其中，α 是学习率 (learning rate)，它控制着每次参数更新的步长。学习率太小，收敛速度会很慢；学习率太大，可能会错过最优解，甚至导致不收敛。

为了更直观地理解梯度下降，可以参考下面的流程图：

现在，让我们用 Python 代码来实现一个简单的梯度下降线性回归模型。我们会使用 numpy 来进行数值计算，matplotlib 来可视化结果，sklearn 来生成模拟数据和划分数据集。

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

# 生成模拟数据，特征数量为 1，加入噪声
X, y = make_regression(n_samples=100, n_features=1, noise=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 实现梯度下降法的线性回归
class LinearRegressionGD:
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.learning_rate = learning_rate  # 学习率，控制梯度下降步长
        self.n_iterations = n_iterations    # 迭代次数
        self.weights = None                 # 权重，模型参数
        self.bias = None                    # 偏置，模型参数
        self.loss_history = []              # 记录每次迭代的损失值，用于可视化

    def fit(self, X, y):
        # 初始化参数
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features) # 初始化权重为 0
        self.bias = 0                       # 初始化偏置为 0

        # 梯度下降迭代
        for _ in range(self.n_iterations):
            # 1. 计算预测值
            y_pred = np.dot(X, self.weights) + self.bias

            # 2. 计算梯度
            dw = (1/n_samples) * np.dot(X.T, (y_pred - y)) # 权重梯度
            db = (1/n_samples) * np.sum(y_pred - y)       # 偏置梯度

            # 3. 更新参数
            self.weights -= self.learning_rate * dw         # 沿负梯度方向更新权重
            self.bias -= self.learning_rate * db            # 沿负梯度方向更新偏置

            # 4. 记录损失值 (均方误差 MSE)
            loss = np.mean((y_pred - y)**2)
            self.loss_history.append(loss)

    def predict(self, X):
        # 预测函数
        return np.dot(X, self.weights) + self.bias

# 创建模型实例
model = LinearRegressionGD(learning_rate=0.01, n_iterations=1000)
# 训练模型
model.fit(X_train, y_train)

# 可视化结果
plt.figure(figsize=(12, 5))

# 绘制损失曲线
plt.subplot(1, 2, 1)
plt.plot(model.loss_history)
plt.title('Loss vs. Iterations (损失值 vs. 迭代次数)')
plt.xlabel('Iterations (迭代次数)')
plt.ylabel('Loss (损失值)')

# 绘制数据散点图和拟合直线
plt.subplot(1, 2, 2)
plt.scatter(X_train, y_train, color='blue', label='Training data (训练数据)') # 训练集散点
plt.scatter(X_test, y_test, color='green', label='Test data (测试数据)')    # 测试集散点

# 生成用于绘制直线的 x 坐标
X_range = np.linspace(X.min(), X.max(), 100).reshape(-1, 1)
# 预测 y 值
y_range_pred = model.predict(X_range)
# 绘制预测直线
plt.plot(X_range, y_range_pred, color='red', label='Prediction (预测直线)')

plt.title('Linear Regression (线性回归)')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.tight_layout()
plt.show()

这段代码首先生成了一些模拟的线性回归数据，然后定义了一个 LinearRegressionGD 类，实现了梯度下降算法。在 fit 方法中，我们进行了迭代优化，不断更新权重和偏置，使得损失函数 MSE 逐渐减小。最后，我们可视化了损失曲线和拟合结果。可以看到，随着迭代次数的增加，损失值逐渐降低，预测直线也较好地拟合了数据。

正则化：防止过拟合的盾牌

当模型过于复杂，或者训练数据量不足时，容易出现过拟合 (overfitting) 现象。过拟合的模型在训练集上表现优异，但在新的、未见过的数据上表现却很糟糕。为了解决过拟合问题，正则化 (regularization) 技术应运而生。

正则化的核心思想是在损失函数中加入惩罚项，限制模型参数的自由度，使其不要过度追求拟合训练数据，从而提高模型的泛化能力。

常见的正则化方法有两种：

1. L1 正则化 (Lasso 回归)：在损失函数中加入权重 绝对值之和 的惩罚项。

   $$Loss=MSE+\lambda \ast \Sigma |w|$$

   L1 正则化倾向于使一部分权重变为 0，从而实现特征选择的效果。

2. L2 正则化 (Ridge 回归)：在损失函数中加入权重 平方和 的惩罚项。

   $$Loss=MSE+\lambda \ast \Sigma w^2$$

   L2 正则化倾向于使所有权重都趋向于 0，但不会变为 0，从而使模型更加平滑。

其中，λ 是正则化强度，也称为超参数，需要手动调整。λ 越大，正则化效果越强，模型越简单，但可能欠拟合；λ 越小，正则化效果越弱，模型越复杂，容易过拟合。

下面是使用 scikit-learn 库实现 Ridge 回归和 Lasso 回归的示例代码：

# Ridge 回归示例
from sklearn.linear_model import Ridge

ridge_model = Ridge(alpha=1.0)  # alpha 参数即为正则化强度 λ
ridge_model.fit(X_train, y_train)
y_pred_ridge = ridge_model.predict(X_test)

# Lasso 回归示例
from sklearn.linear_model import Lasso

lasso_model = Lasso(alpha=1.0)
lasso_model.fit(X_train, y_train)
y_pred_lasso = lasso_model.predict(X_test)

模型评估：衡量性能的标准

模型训练完成后，我们需要评估其性能，判断模型是否达到了我们的预期。对于线性回归模型，常用的评估指标有以下几种：

1. 均方误差 (MSE)：$$MSE=(1/n)\ast \Sigma (y_{t}rue-y_{p}red{)}^2$$

   • MSE 越小，模型性能越好。

2. 均方根误差 (RMSE)：$$RMSE=\surd MSE$$

   • RMSE 与 MSE 的趋势一致，但 RMSE 的量纲与原始数据一致，更易于解释。

3. 平均绝对误差 (MAE)：$$MAE=(1/n)\ast \Sigma |y_{t}rue-y_{p}red|$$

   • MAE 对异常值 (outlier) 不敏感，更鲁棒。

4. **决定系数 (R²) **：$$R^2=1-(\Sigma (y_{t}rue-y_{p}red{)}^2/\Sigma (y_{t}rue-y_{m}ean{)}^2)$$

   • R² 的取值范围为 [0, 1]，越接近 1，说明模型解释了数据中更多的方差，模型拟合效果越好。

下面代码展示了如何计算这些评估指标：

from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

# 使用测试集进行预测
y_pred = model.predict(X_test)

# 计算各种评估指标
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"MSE: {mse:.4f}")   # 均方误差
print(f"RMSE: {rmse:.4f}")  # 均方根误差
print(f"MAE: {mae:.4f}")   # 平均绝对误差
print(f"R²: {r2:.4f}")    # 决定系数

实际案例：房价预测

理论学习了这么多，是时候来个实战演练了。我们选择经典的波士顿房价数据集，用线性回归模型来预测房价。

from sklearn.datasets import fetch_california_housing # 注意这里数据集换成了加州房价
from sklearn.preprocessing import StandardScaler
from sklearn.model_model import train_test_split # 这里更正为 sklearn.model_selection
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# 加载加州房价数据集 (更贴近原文案例描述)
housing = fetch_california_housing()
X, y = housing.data, housing.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 特征标准化 (非常重要！线性回归对特征尺度敏感)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train) # 训练集拟合和转换
X_test_scaled = scaler.transform(X_test)       # 测试集直接转换，使用训练集学到的参数

# 使用 scikit-learn 的线性回归模型
lr_model = LinearRegression()
lr_model.fit(X_train_scaled, y_train) # 使用标准化后的训练数据

# 预测
y_pred = lr_model.predict(X_test_scaled) # 使用标准化后的测试数据

# 评估模型
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"均方误差 (MSE): {mse:.4f}")
print(f"决定系数 (R²): {r2:.4f}")

# 查看各个特征的权重 (系数)
for feature, weight in zip(housing.feature_names, lr_model.coef_):
    print(f"{feature}: {weight:.4f}")

在这个案例中，我们使用了 scikit-learn 提供的 LinearRegression 模型，省去了手动实现梯度下降的步骤。需要注意的是，特征标准化 在线性回归中非常重要，它可以消除特征量纲不一致带来的影响，加快模型收敛速度，提高模型性能。最后，我们输出了模型的评估指标和各个特征的权重，可以帮助我们理解哪些因素对房价影响更大。

逻辑回归：分类问题的基石

原理：从线性到概率的转变

逻辑回归 (Logistic Regression)，虽然名字里带着“回归”，但它实际上是一种分类算法，主要用于解决二分类问题。逻辑回归的核心思想是在线性回归的基础上，通过 Sigmoid 函数，将线性回归的输出值转换为 [0, 1] 区间内的概率值。

公式如下：

$$p(y=1|x)=\sigma (wx+b)$$

其中，σ 就是 Sigmoid 函数，z = wx + b 是线性回归的输出。p(y=1|x) 表示在给定特征 x 的条件下，样本属于类别 1 的概率。当概率 p 大于 0.5 时，我们预测样本属于类别 1，否则属于类别 0。

逻辑回归模型的系统架构可以表示为：

Sigmoid 函数：概率转换的桥梁

Sigmoid 函数 是逻辑回归的关键，它将任意实数映射到 (0, 1) 区间，使其具有概率的意义。Sigmoid 函数的公式如下：

$$\sigma (z)=1/(1+e^{(}-z))$$

我们可以用 Python 代码可视化 Sigmoid 函数的形状：

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    # Sigmoid 函数实现
    return 1 / (1 + np.exp(-z))

# 生成 z 值，从 -10 到 10
z = np.linspace(-10, 10, 100)
# 计算 Sigmoid 值
sig = sigmoid(z)

# 可视化 Sigmoid 函数
plt.figure(figsize=(8, 5))
plt.plot(z, sig) # 绘制 z vs sigmoid(z) 曲线
plt.title('Sigmoid Function (Sigmoid 函数)')
plt.xlabel('z')
plt.ylabel('σ(z)')
plt.grid(True) # 显示网格线
plt.axhline(y=0.5, color='r', linestyle='--') # 绘制 y=0.5 水平虚线
plt.axvline(x=0, color='r', linestyle='--') # 绘制 x=0 垂直虚线
plt.show()

运行这段代码，可以看到 Sigmoid 函数的 S 形曲线。当 z 趋近于正无穷时，σ(z) 趋近于 1；当 z 趋近于负无穷时，σ(z) 趋近于 0；当 z 等于 0 时，σ(z) 等于 0.5。这使得 Sigmoid 函数非常适合用于概率预测。

交叉熵损失：分类问题的理想损失函数

对于逻辑回归，我们不再使用均方误差 MSE 作为损失函数，而是使用 交叉熵损失 (Cross-Entropy Loss)，也称为 对数损失 (Log Loss)。交叉熵损失更适合衡量分类模型的性能，尤其是在概率输出的情况下。

对于二分类问题，交叉熵损失函数的公式如下：

$$Loss=-[y\ast log(p)+(1-y)\ast log(1-p)]$$

其中，y 是真实标签 (0 或 1)，p 是模型预测的样本属于类别 1 的概率。

交叉熵损失的含义是：

• 如果样本属于类别 1 (y=1)，那么损失值 -log(p)。此时，如果预测概率 p 越接近 1，损失值越小；反之，p 越接近 0，损失值越大。
• 如果样本属于类别 0 (y=0)，那么损失值 -log(1-p)。此时，如果预测概率 p 越接近 0，损失值越小；反之，p 越接近 1，损失值越大。

总而言之，交叉熵损失能够很好地衡量模型预测概率与真实标签之间的差距。我们的目标仍然是找到一组最优的参数 w 和 b，使得交叉熵损失尽可能地小。优化方法仍然可以使用梯度下降算法。

逻辑回归的实现

下面是用 Python 代码实现逻辑回归模型的示例。我们仍然使用梯度下降算法进行优化。

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

# 生成二分类模拟数据
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0,
                           n_informative=2, random_state=42, n_clusters_per_class=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

class LogisticRegression:
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.learning_rate = learning_rate    # 学习率
        self.n_iterations = n_iterations      # 迭代次数
        self.weights = None                   # 权重
        self.bias = None                      # 偏置
        self.loss_history = []                # 损失值历史

    def sigmoid(self, z):
        # Sigmoid 函数
        return 1 / (1 + np.exp(-z))

    def fit(self, X, y):
        # 初始化参数
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features) # 初始化权重为 0
        self.bias = 0                       # 初始化偏置为 0

        # 梯度下降迭代
        for _ in range(self.n_iterations):
            # 1. 计算线性模型输出
            linear_model = np.dot(X, self.weights) + self.bias
            # 2. 计算预测概率 (经过 Sigmoid 函数)
            y_pred = self.sigmoid(linear_model)

            # 3. 计算梯度 (交叉熵损失函数的梯度)
            dw = (1/n_samples) * np.dot(X.T, (y_pred - y)) # 权重梯度
            db = (1/n_samples) * np.sum(y_pred - y)       # 偏置梯度

            # 4. 更新参数
            self.weights -= self.learning_rate * dw         # 更新权重
            self.bias -= self.learning_rate * db            # 更新偏置

            # 5. 计算并记录损失值 (交叉熵损失)
            # 添加一个极小值 1e-15 防止 log(0) 错误
            loss = -np.mean(y * np.log(y_pred + 1e-15) + (1-y) * np.log(1 - y_pred + 1e-15))
            self.loss_history.append(loss)

    def predict_proba(self, X):
        # 预测概率
        linear_model = np.dot(X, self.weights) + self.bias
        return self.sigmoid(linear_model)

    def predict(self, X, threshold=0.5):
        # 预测类别 (基于概率阈值)
        probabilities = self.predict_proba(X)
        return (probabilities >= threshold).astype(int) # 概率大于等于阈值预测为 1，否则为 0

# 创建逻辑回归模型实例
log_reg = LogisticRegression(learning_rate=0.1, n_iterations=1000)
# 训练模型
log_reg.fit(X_train, y_train)

# 评估模型
y_pred = log_reg.predict(X_test)
accuracy = np.mean(y_pred == y_test) # 计算准确率
print(f"准确率: {accuracy:.4f}")

# 可视化结果
plt.figure(figsize=(12, 5))

# 绘制损失曲线
plt.subplot(1, 2, 1)
plt.plot(log_reg.loss_history)
plt.title('Loss vs. Iterations (损失值 vs. 迭代次数)')
plt.xlabel('Iterations (迭代次数)')
plt.ylabel('Loss (损失值)')

# 绘制决策边界
plt.subplot(1, 2, 2)
plt.scatter(X[:, 0][y == 0], X[:, 1][y == 0], color='blue', label='Class 0 (类别 0)') # 类别 0 散点
plt.scatter(X[:, 0][y == 1], X[:, 1][y == 1], color='red', label='Class 1 (类别 1)')  # 类别 1 散点

# 创建网格用于绘制决策边界
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.arange(x1_min, x1_max, 0.01),
                       np.arange(x2_min, x2_max, 0.01))

# 在网格上进行预测
Z = log_reg.predict(np.c_[xx1.ravel(), xx2.ravel()])
Z = Z.reshape(xx1.shape)

# 绘制决策边界等高线
plt.contourf(xx1, xx2, Z, alpha=0.3) # 填充颜色
plt.title('Decision Boundary (决策边界)')
plt.xlabel('Feature 1 (特征 1)')
plt.ylabel('Feature 2 (特征 2)')
plt.legend()
plt.tight_layout()
plt.show()

这段代码实现了一个简单的二分类逻辑回归模型，并可视化了损失曲线和决策边界。可以看到，逻辑回归模型能够较好地将两类数据分开。

多分类问题：一对多策略

逻辑回归本身是用于解决二分类问题的。要将其应用于多分类问题，一种常用的策略是 一对多 (One-vs-Rest, OvR)。

OvR 的思想很简单：对于 K 个类别，我们训练 K 个二元分类器。对于第 i 个分类器，我们将类别 i 的样本标记为正例，其他所有类别的样本标记为负例。这样，我们就将一个多分类问题转化为了 K 个二分类问题。

在预测时，对于新的样本，我们使用 K 个分类器分别进行预测，得到 K 个概率值。选择概率值最高的那个分类器对应的类别作为最终的预测结果。

下面是使用 scikit-learn 实现多分类逻辑回归的示例代码，使用了鸢尾花数据集。

from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

# 加载鸢尾花数据集 (经典多分类数据集)
iris = load_iris()
X, y = iris.data, iris.target # 3 个类别

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 特征标准化 (同样重要)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 训练多分类逻辑回归模型 (使用 OvR 策略，solver 选择 'lbfgs' 优化器)
multi_log_reg = LogisticRegression(multi_class='ovr', solver='lbfgs', max_iter=1000)
multi_log_reg.fit(X_train_scaled, y_train)

# 预测
y_pred = multi_log_reg.predict(X_test_scaled)      # 预测类别
y_prob = multi_log_reg.predict_proba(X_test_scaled) # 预测概率

# 评估模型
accuracy = accuracy_score(y_test, y_pred) # 计算准确率
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names)) # 输出更详细的分类报告

在 LogisticRegression 中，设置 multi_class='ovr' 即可使用 OvR 策略进行多分类。solver='lbfgs' 是选择优化算法，对于多分类问题，lbfgs 是一个不错的选择。代码最后输出了准确率和分类报告，分类报告包含了精确率、召回率、F1 值等更详细的分类指标。

模型评估：分类性能指标

对于分类模型，常用的评估指标与回归模型有所不同。主要关注以下几个方面：

1. 准确率 (Accuracy)：$$Accuracy=(TP+TN)/(TP+TN+FP+FN)$$

   • 准确率是最常用的分类指标，表示模型预测正确的样本比例。

2. 精确率 (Precision)：$$Precision=TP/(TP+FP)$$

   • 精确率关注的是在所有预测为正例的样本中，真正例的比例。

3. 召回率 (Recall)：$$Recall=TP/(TP+FN)$$

   • 召回率关注的是在所有真实正例样本中，被模型预测为正例的比例。

4. F1 值 (F1-score)：$$F1=2\ast (Precision\ast Recall)/(Precision+Recall)$$

   • F1 值是精确率和召回率的调和平均值，综合考虑了两者的性能。

5. 混淆矩阵 (Confusion Matrix)：

   • 混淆矩阵是更详细的分类结果展示，可以清晰地看到模型在各个类别上的预测情况，包括真正例 (TP)、真反例 (TN)、假正例 (FP)、假反例 (FN) 的数量。

6. 分类报告 (Classification Report)：

   • scikit-learn 提供的 classification_report 函数可以生成包含精确率、召回率、F1 值、支持度 (support) 等指标的详细报告，方便模型评估。

在实际应用中，需要根据具体的业务场景和问题类型选择合适的评估指标。例如，在医疗诊断领域，召回率可能比精确率更重要，因为我们更希望尽可能地找出所有患病的人，即使误诊一些健康人也在所不惜。

总结与展望

恭喜你！一路走到这里，相信你已经对线性回归和逻辑回归有了更深入的理解。从原理到实现，从代码到应用，我们一起探索了这两种经典算法的方方面面。

线性回归以其简洁明了的数学形式和强大的预测能力，在连续值预测领域占据着重要的地位。逻辑回归则巧妙地将线性模型与 Sigmoid 函数结合，成为了解决分类问题的有力武器。它们不仅是机器学习的入门算法，更是构建更复杂模型的基石。

当然，机器学习的世界远不止于此。在掌握了线性回归和逻辑回归之后，你可以继续探索更高级的算法，例如支持向量机 (SVM)、决策树、随机森林、神经网络等等。但请记住，万丈高楼平地起，扎实的基础永远是最重要的。

希望这篇文章能帮助你在 AI 高手之路上更进一步。Keep learning, keep exploring!