机器学习校招面经二

news2025/3/5 7:10:51

快手机器学习算法

一、AUC（Area Under the ROC Curve）怎么计算？AUC接近1可能的原因是什么？

见【搜广推校招面经四】
AUC 是评估分类模型性能的重要指标，用于衡量模型在不同阈值下区分正负样本的能力。它是 ROC 曲线（Receiver Operating Characteristic Curve）下的面积。

1.1. ROC 曲线的坐标

ROC 曲线以 真正例率（True Positive Rate, TPR） 为纵轴，假正例率（False Positive Rate, FPR） 为横轴。

1.1.1. 真正例率(TPR) = 召回率(Recall) = 灵敏度(Sensitivity)

$\frac{TP}{TP + FN} = \frac{TP}{P}$
其中：

$T P$ ：真正例（True Positives），即模型正确预测的正样本数。
$F N$ ：假反例（False Negatives），即模型错误预测的负样本数。

2.2 假正例率（FPR）

$\frac{FP}{FP + TN} = \frac{FP}{N}$
其中：

$F P$ ：假正例（False Positives），即模型错误预测的正样本数。
$T N$ ：真反例（True Negatives），即模型正确预测的负样本数。

1.2. AUC 的计算公式

AUC 是 ROC 曲线下的面积，可以通过以下方法计算：

1.2.1. 积分法

$\int_{0}^{1} TPR(FPR) \, dFPR$
即对 ROC 曲线下的面积进行积分。

1.2.2. 排序法（更常用）

AUC 可以通过对样本的预测概率进行排序计算：
$\frac{\sum_{i=1}^{N_+} \sum_{j=1}^{N_-} \mathbb{I}(p_i > p_j)}{N_+ \times N_-}$
其中：

( N_+ )：正样本的数量。
( N_- )：负样本的数量。
( p_i )：第 ( i ) 个正样本的预测概率。
( p_j )：第 ( j ) 个负样本的预测概率。
$\mathbb{I}(p_i > p_j)$ ：指示函数，当 $p_i > p_j$ 时为 1，否则为 0。

1.3. 手撕AUC

def cal_auc_1(label, pred):
    numerator = 0    # 分子
    denominator = 0  # 分母
    for i in range(len(label) - 1):
        for j in range(i, len(label)):
            if label[i] != label[j]:
                denominator += 1
                # 统计所有正负样本对中，模型把相对位置排序正确的数量
                r = (label[i] - label[j]) * (pred[i] - pred[j])
                if r > 0:
                    numerator += 1
                elif r == 0:
                    numerator += 0.5
    return numerator / denominator

二、LR逻辑回归的损失函数，使用熟悉的语言，写出交叉熵的伪代码

首先明确，逻辑回归的损失函数是交叉熵损失函数，也被称为对数损失函数（log loss）。
手撕：见【搜广推校招面经二十三】

import numpy as np

class LogisticRegression:
    def __init__(self, learning_rate=0.01, num_iterations=1000):
        self.learning_rate = learning_rate  # 学习率
        self.num_iterations = num_iterations  # 迭代次数
        self.theta = None  # 模型参数
    
    def sigmoid(self, z):
        """计算 Sigmoid 函数"""
        return 1 / (1 + np.exp(-z))
    
    def compute_cost(self, X, y):
        """计算交叉熵损失函数"""
        m = len(y)
        h = self.sigmoid(np.dot(X, self.theta))
        cost = - (1/m) * np.sum(y * np.log(h) + (1 - y) * np.log(1 - h))
        return cost
    
    def gradient_descent(self, X, y):
        """梯度下降优化"""
        m = len(y)
        for i in range(self.num_iterations):
            h = self.sigmoid(np.dot(X, self.theta))  # 计算预测值
            gradient = (1/m) * np.dot(X.T, (h - y))  # 计算梯度
            self.theta -= self.learning_rate * gradient  # 更新参数
            if i % 100 == 0:  # 每100次输出一次损失值
                cost = self.compute_cost(X, y)
                print(f"Iteration {i}, Cost: {cost}")
    
    def fit(self, X, y):
        """训练模型"""
        m, n = X.shape
        self.theta = np.zeros(n)  # 初始化参数
        self.gradient_descent(X, y)
    
    def predict(self, X):
        """预测新样本的类别"""
        probabilities = self.sigmoid(np.dot(X, self.theta))
        return probabilities >= 0.5  # 预测类别：如果大于等于 0.5，分类为 1，否则为 0