Pytorch升级之旅——基础概念

目录

一、人工智能简史

三次浪潮

DL,ML,AI三者之间的关系

二、模型评价指标

混淆矩阵

[Overall Accuracy](#Overall Accuracy)

​编辑

[Average accuracy](#Average accuracy)

Kappa系数

Recall

Precision

F1

PR曲线

置信度

IOU

AP

mAP

三、常用包Numpy、pandas、matplotlib

Numpy

pandas

matplotlib

[四、Jupyter notebook/Lab 简述](#四、Jupyter notebook/Lab 简述)

安装

---

学习链接：深入浅出PyTorch --- 深入浅出PyTorch (datawhalechina.github.io)

一、人工智能简史

三次浪潮

①1956-1966 人工智能元年 达特茅斯会议

②20世纪80年代 统计学思想引入 提出BP神经网络

③1993年以后 2006年深度学习 2016年AIphaGO围棋

DL,ML,AI三者之间的关系

深度学习（DL）、机器学习（ML）和人工智能（AI）之间的关系可以用层级结构来理解：

1. 人工智能（AI）：AI是一个广泛的领域，旨在开发能够模拟人类智能的计算机系统。它包括许多子领域，如机器学习、计算机视觉、自然语言处理等。AI的目标是让计算机能够执行通常需要人类智能的任务，例如理解语言、识别图像、做决策等。

2. 机器学习（ML）：ML是AI的一个子领域，专注于开发算法和统计模型，使计算机能够从数据中学习和做出预测或决策，而不需要明确的编程指令。换句话说，机器学习通过数据驱动的方法来提高AI系统的性能。

3. 深度学习（DL）：DL是机器学习的一个子领域，主要使用人工神经网络，特别是多层神经网络（深度神经网络），来处理复杂的数据表示和模式识别任务。深度学习在图像识别、语音识别、自然语言处理等方面表现出了极高的效能，是近年来推动AI快速发展的核心技术之一。

总结来说，深度学习是机器学习的一个子集，而机器学习又是人工智能的一个子集。

二、模型评价指标

混淆矩阵

混淆矩阵是评估分类模型性能的重要工具，特别是在二分类和多分类问题中。它以矩阵的形式展示了模型的预测结果与实际标签之间的对比。

混淆矩阵的结构

对于二分类问题，混淆矩阵通常是一个2x2的矩阵，包含以下四个部分：

• True Positive (TP): 真正例。模型正确预测为正类的样本数。
• True Negative (TN): 真负例。模型正确预测为负类的样本数。
• False Positive (FP): 假正例。模型错误地将负类预测为正类的样本数（也称为"类型I错误"）。
• False Negative (FN): 假负例。模型错误地将正类预测为负类的样本数（也称为"类型II错误"）。

实际正类 (Positive) 实际负类 (Negative)

预测正类 (Positive) TP FP

预测负类 (Negative) FN TN

Overall Accuracy

Overall Accuracy（总体准确率）是衡量分类模型性能的一项指标，表示模型正确分类的样本数量占总样本数量的比例。它是混淆矩阵中所有正确分类结果（包括所有类别的正确预测）的总和除以总样本数的结果。

对于二分类或多分类问题，Overall Accuracy 的计算公式是：Overall Accuracy=所有类别的正确预测数​/总样本数

如果使用混淆矩阵的表示法，对于二分类问题：Overall Accuracy=(TP+TN)/(TP+TN+FP+FN)

def compute_oa(matrix):
    """
    计算总体准确率,OA=(TP+TN)/(TP+TN+FP+FN)
    :param matrix:
    :return:
    """
    return np.trace(matrix) / np.sum(matrix)

Overall Accuracy 是评估模型性能的一个直观指标，但在类别不平衡的数据集上，它可能会掩盖模型在少数类别上的差距。因此，在分析模型性能时，还应考虑其他指标如精确率、召回率和F1分数等。

Average accuracy

Average Accuracy（平均准确率）通常用于多分类问题中，表示每个类别的分类准确率的平均值。这种方法对每个类别的表现给予相同的权重，适合在类别不平衡的数据集上评估模型性能，因为它能够更好地反映模型在所有类别上的表现。

对于 nnn 个类别，首先计算每个类别的分类准确率，然后取这些准确率的平均值。具体公式为：

def compute_aa(matrix):
    """
    计算每一类的准确率,AA=(TP/(TP+FN)+TN/(FP+TN))/2
    :param matrix:
    :return:
    """
    return np.mean(np.diag(matrix) / np.sum(matrix, axis=1))

与 Overall Accuracy 的对比

• Overall Accuracy 计算的是所有样本中预测正确的比例，因此在类别不平衡的情况下，少数类别的影响可能会被多数类别掩盖。
• Average Accuracy 则通过计算每个类别的准确率，并取其平均值，使得每个类别对最终结果都有相同的影响，能够更公平地评估模型在不同类别上的表现。

Kappa系数

Kappa系数（Cohen's Kappa）是一种统计指标，用于衡量分类模型的预测结果与实际类别之间的一致性。与简单的准确率不同，Kappa系数考虑了分类中的偶然因素（即，随机猜测所带来的准确性），因此可以提供比准确率更可靠的一致性评估。

Cohen's Kappa 系数的计算公式为：

具体步骤

Kappa 系数的解读

• κ=1 表示完全一致，即模型的预测结果与实际类别完全一致。
• κ=0\kappa = 0κ=0 表示模型的预测结果与随机猜测的结果没有区别。
• κ<0\kappa < 0κ<0 表示一致性低于随机水平，模型的表现比随机猜测还要差。

Kappa 系数的具体值通常按以下标准解读：

• 0.81-1.00：几乎完美的一致性
• 0.61-0.80：显著一致性
• 0.41-0.60：中等一致性
• 0.21-0.40：公平一致性
• 0.01-0.20：轻微一致性
• 0.00 或更低：无一致性

import numpy as np

def compute_oa(matrix):
    """
    计算总体准确率 (Overall Accuracy)
    :param matrix: 混淆矩阵
    :return: 总体准确率
    """
    return np.trace(matrix) / np.sum(matrix)

def compute_kappa(matrix):
    """
    计算Kappa系数
    :param matrix: 混淆矩阵
    :return: Kappa系数
    """
    # 计算总体准确率 (Overall Accuracy)
    oa = compute_oa(matrix)
    
    # 计算期望准确率 (Expected Accuracy)
    pe = 0
    for i in range(len(matrix)):
        pe += np.sum(matrix[i]) * np.sum(matrix[:, i])
    pe = pe / np.sum(matrix) ** 2
    
    # 计算Kappa系数
    kappa = (oa - pe) / (1 - pe)
    return kappa

• 计算总体准确率 (Overall Accuracy, OA):

  • np.trace(matrix)：计算混淆矩阵的对角线元素之和，即正确分类的总数。
  • np.sum(matrix)：计算混淆矩阵的所有元素之和，即总样本数。
  • oa = np.trace(matrix) / np.sum(matrix)：计算总体准确率。

• 计算期望准确率 (Expected Accuracy, PE):

  • np.sum(matrix[i]) * np.sum(matrix[:, i])：对于每个类别，计算该类别的行和列的乘积（即分别为实际和预测中的总数）。
  • pe = pe / np.sum(matrix) ** 2：将上述乘积的累加结果除以总样本数的平方，得到期望准确率。

• 计算 Kappa 系数:

  • kappa = (oa - pe) / (1 - pe)：使用总体准确率和期望准确率计算Kappa系数。Kappa系数的范围在[-1, 1]之间，1表示完全一致，0表示与随机一致性相同，负值表示比随机一致性还差。

Recall

Recall（召回率）是分类模型性能评估的重要指标之一，尤其在关注模型能否正确识别正类样本时非常有用。它表示在所有实际为正类的样本中，模型正确预测为正类的比例。

对于二分类问题，Recall的计算公式是：Recall=TP​/TP+FN

• TP (True Positive): 真正例，模型正确预测为正类的样本数。
• FN (False Negative): 假负例，模型错误地将正类预测为负类的样本数。

召回率的意义

• 高召回率意味着模型能够识别大部分的正类样本，但可能会增加假阳性（误将负类预测为正类）的数量。
• 召回率通常与精确率（Precision）一起使用。二者之间存在权衡：提高召回率可能会降低精确率，反之亦然。

多分类问题中的 Recall

在多分类问题中，召回率通常是针对每个类别分别计算的，然后可以选择计算每个类别的平均召回率（如微平均、宏平均等）。

• 宏平均（Macro-Averaging）: 计算每个类别的召回率，然后取平均值。
• 微平均（Micro-Averaging）: 将所有类别的 TP 和 FN 总和，然后计算召回率。

召回率在实际中的应用

• 在医疗诊断中，高召回率意味着较少的漏诊，特别适用于一些不容错过的疾病检测。
• 在信息检索中，高召回率意味着能检索到更多的相关信息。

Recall 是评价模型在实际应用中捕获正类样本能力的重要指标，特别是在对假阴性结果敏感的场景中具有重要意义。

Precision

Precision也称精准率，代表的是在全部预测为正的结果中，被预测正确的正样本所占的比例，用于衡量模型在正类预测中的准确性。

用数学公式表示为：Precision=True Positives (TP)​/True Positives (TP)+False Positives (FP)

• 其中：

  • True Positives (TP) 是模型正确预测为正类的样本数。
  • False Positives (FP) 是模型错误预测为正类的样本数。

精确度高意味着模型在预测正类时较少出现错误的预测（即假阳性）。在处理不平衡数据集时，精确度尤其重要，因为它可以帮助我们评估模型在正类样本上的预测质量。

import torch

def calculate_precision(preds, labels):
    """
    计算精确度（Precision）。

    参数:
    preds (torch.Tensor): 模型的预测结果，0 或 1。
    labels (torch.Tensor): 真实标签，0 或 1。

    返回:
    float: 精确度。
    """
    # 计算 True Positives 和 False Positives
    true_positives = torch.sum((preds == 1) & (labels == 1)).item()
    false_positives = torch.sum((preds == 1) & (labels == 0)).item()

    # 计算精确度
    precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0.0
    return precision

# 示例
preds = torch.tensor([1, 0, 1, 1, 0])
labels = torch.tensor([1, 0, 0, 1, 1])

precision = calculate_precision(preds, labels)
print(f"Precision: {precision:.2f}")

F1

F1 分数 是精确度（Precision）和召回率（Recall）的调和平均值，用于综合评估模型的性能。F1 分数在分类任务中尤为重要，特别是在处理不平衡数据集时，它可以提供对模型性能的更全面的评估。

F1 分数的定义：

其中：

• 精确度（Precision）：真正正类样本数与所有被预测为正类样本数的比例。
• 召回率（Recall）：真正正类样本数与所有真实正类样本数的比例。

import torch

def calculate_f1(preds, labels):
    """
    计算 F1 分数。

    参数:
    preds (torch.Tensor): 模型的预测结果，0 或 1。
    labels (torch.Tensor): 真实标签，0 或 1。

    返回:
    float: F1 分数。
    """
    # 计算 True Positives, False Positives 和 False Negatives
    true_positives = torch.sum((preds == 1) & (labels == 1)).item()
    false_positives = torch.sum((preds == 1) & (labels == 0)).item()
    false_negatives = torch.sum((preds == 0) & (labels == 1)).item()

    # 计算精确度（Precision）和召回率（Recall）
    precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0.0
    recall = true_positives / (true_positives + false_negatives) if (true_positives + false_negatives) > 0 else 0.0

    # 计算 F1 分数
    f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0
    return f1_score

# 示例
preds = torch.tensor([1, 0, 1, 1, 0])
labels = torch.tensor([1, 0, 0, 1, 1])

f1 = calculate_f1(preds, labels)
print(f"F1 Score: {f1:.2f}")

F1 分数的扩展形式，通常称为 Fβ 分数 ，其中 β 用于控制精确度（Precision）和召回率（Recall）的权重。Fβ 分数的定义式如下：

• 当 β > 1：Fβ 分数更侧重于召回率（Recall）。
• 当 β < 1：Fβ 分数更侧重于精确度（Precision）。
• 当 β = 1：Fβ 分数与 F1 分数相同，平衡了精确度和召回率。

计算全局性能 时，通常有两种方法：macro 和 micro。

1. Macro 方法：

   • 对每个类别分别计算精确度、召回率和 Fβ 分数。
   • 对所有类别的 Fβ 分数取平均值。

2. Micro 方法：

   • 首先将所有类别的 TP、FP 和 FN 合并，计算总体的精确度、召回率和 Fβ 分数。

from sklearn.metrics import precision_recall_fscore_support

def calculate_macro_f1(preds, labels):
    """
    计算宏观 F1 分数（Macro F1）。

    参数:
    preds (torch.Tensor): 模型的预测结果，0 或 1。
    labels (torch.Tensor): 真实标签，0 或 1。

    返回:
    float: 宏观 F1 分数。
    """
    precision, recall, f1, _ = precision_recall_fscore_support(labels.numpy(), preds.numpy(), average='macro')
    return f1

# 示例
import torch
preds = torch.tensor([1, 0, 1, 1, 0])
labels = torch.tensor([1, 0, 0, 1, 1])

macro_f1 = calculate_macro_f1(preds, labels)
print(f"Macro F1 Score: {macro_f1:.2f}")

precision_recall_fscore_support 是 scikit-learn 提供的函数，它可以计算精确度、召回率和 F1 分数，并通过 average 参数来选择宏观或微观计算方式。

PR曲线

PR 曲线（Precision-Recall Curve）是一种评估分类模型性能的图形工具，特别适用于处理不平衡数据集。PR 曲线描绘了模型在不同决策阈值下的精确度（Precision）和召回率（Recall）的关系。

PR 曲线的定义

• 精确度（Precision）：真正正类样本数与所有被预测为正类样本数的比例。
• 召回率（Recall）：真正正类样本数与所有真实正类样本数的比例。

PR 曲线通常是通过在不同的阈值下计算精确度和召回率来绘制的，横轴表示召回率（Recall），纵轴表示精确度（Precision）。

在 Python 中，可以使用 scikit-learn 库绘制 PR 曲线。

import matplotlib.pyplot as plt
from sklearn.metrics import precision_recall_curve
from sklearn.metrics import average_precision_score

def plot_pr_curve(y_true, y_scores):
    """
    绘制 PR 曲线（Precision-Recall Curve）。

    参数:
    y_true (list or numpy array): 真实标签，0 或 1。
    y_scores (list or numpy array): 模型的预测分数或概率。
    """
    precision, recall, _ = precision_recall_curve(y_true, y_scores)
    average_precision = average_precision_score(y_true, y_scores)
    
    plt.figure(figsize=(8, 6))
    plt.plot(recall, precision, marker='.')
    plt.title(f'PR Curve (Average Precision: {average_precision:.2f})')
    plt.xlabel('Recall')
    plt.ylabel('Precision')
    plt.grid()
    plt.show()

# 示例数据
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

# 生成示例数据
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 训练模型
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model = LogisticRegression()
model.fit(X_train_scaled, y_train)

# 获取模型预测概率
y_scores = model.predict_proba(X_test_scaled)[:, 1]

# 绘制 PR 曲线
plot_pr_curve(y_test, y_scores)

• precision_recall_curve：计算不同阈值下的精确度和召回率。
• average_precision_score：计算平均精确度，用于量化整个 PR 曲线的性能。

PR 曲线和平均精确度（Average Precision, AP）提供了模型在所有可能的阈值下的综合性能指标，尤其在处理正负样本不平衡时非常有用。

• 初始化混淆矩阵计数 ：在 get_confusion_matrix 函数中，初始化 TP、FP、TN 和 FN 时不应设置为固定值，而是应从零开始计算。

• 改进 get_pr_pairs 函数：在每个阈值下计算精确度（Precision）和召回率（Recall），需要确保所有阈值都被处理，并避免冗余计算。

• 绘制 PR 曲线：在绘制时应确保曲线显示正确，且包含合理的标签和标题。

from typing import List, Tuple
import matplotlib.pyplot as plt

def get_confusion_matrix(
    y_pred: List[int], 
    y_true: List[int]
    ) -> Tuple[int, int, int, int]:
    tp, fp, tn, fn = 0, 0, 0, 0
    for i in range(len(y_pred)):
        if y_pred[i] == 1 and y_true[i] == 1:
            tp += 1
        elif y_pred[i] == 1 and y_true[i] == 0:
            fp += 1
        elif y_pred[i] == 0 and y_true[i] == 1:
            fn += 1
        elif y_pred[i] == 0 and y_true[i] == 0:
            tn += 1
    return (tp, fp, tn, fn)

def calc_p(tp: int, fp: int) -> float:
    return tp / (tp + fp) if (tp + fp) > 0 else 0

def calc_r(tp: int, fn: int) -> float:
    return tp / (tp + fn) if (tp + fn) > 0 else 0

def get_pr_pairs(
    y_pred_prob: List[float], 
    y_true: List[int]
    ) -> Tuple[List[float], List[float]]:
    thresholds = sorted(set(y_pred_prob), reverse=True)
    ps = []
    rs = []
    for threshold in thresholds:
        y_pred_i = [1 if prob >= threshold else 0 for prob in y_pred_prob]
        tp, fp, tn, fn = get_confusion_matrix(y_pred_i, y_true)
        p = calc_p(tp, fp)
        r = calc_r(tp, fn)
        ps.append(p)
        rs.append(r)
    ps.append(0)
    rs.append(1)
    return rs, ps

# 示例数据
y_pred_prob = [0.9, 0.8, 0.7, 0.6, 0.55, 0.54, 0.53, 0.52, 0.51, 0.505,
               0.4, 0.39, 0.38, 0.37, 0.36, 0.35, 0.34, 0.33, 0.3, 0.1]
y_true = [1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0]

# 计算 PR 曲线
rs, ps = get_pr_pairs(y_pred_prob, y_true)

# 绘制 PR 曲线
fig, ax = plt.subplots(figsize=(12, 5))
ax.plot(rs, ps, marker='.')
ax.set_xlabel('Recall')
ax.set_ylabel('Precision')
ax.set_title('Precision-Recall Curve')
ax.grid(True)
plt.show()

• get_confusion_matrix 函数：初始化 TP、FP、TN 和 FN 为 0，并在循环中计算真实的 TP、FP、TN 和 FN。

• get_pr_pairs 函数 ：先按概率排序，并遍历每个阈值来计算精确度和召回率。使用 set 和 sorted 去除重复的阈值。

• 绘图：为 PR 曲线添加了标签和标题，使图形更具可读性。

置信度

置信度（Confidence）在机器学习和统计中通常指的是模型对其预测结果的确定程度。对于分类模型而言，置信度通常表示模型预测为某个类别的概率。这种概率表示了模型对某一预测的信心水平。

置信度的定义和应用

1. 分类任务中的置信度：

   • 在分类问题中，模型通常会输出每个类别的预测概率。例如，对于一个二分类问题，模型可能会输出一个概率值，例如 0.85，表示模型认为该样本属于正类的置信度为 85%。
   • 置信度可以用来选择分类阈值，决定是否将样本分配给某个特定的类别。

2. 置信度区间：

   • 在统计学中，置信度也用来表示估计值的可靠性。一个 95% 的置信度区间意味着如果重复实验很多次，有 95% 的概率区间会包含真实的参数值。

置信度的计算和使用

在机器学习中，置信度通常由模型的输出概率计算得出。以一个简单的示例为例，假设我们有一个分类模型，它给出每个样本的预测概率。可以使用这些概率作为置信度来绘制 ROC 或 PR 曲线，或用于阈值选择。

import torch
import torch.nn.functional as F

def calculate_confidence(logits: torch.Tensor) -> torch.Tensor:
    """
    计算预测的置信度。

    参数:
    logits (torch.Tensor): 模型的输出，未经归一化的 logits。

    返回:
    torch.Tensor: 预测的置信度。
    """
    probabilities = F.softmax(logits, dim=1)
    confidence, _ = torch.max(probabilities, dim=1)
    return confidence

# 示例数据
logits = torch.tensor([[2.0, 1.0], [0.5, 1.5], [1.0, 1.0]])
confidence = calculate_confidence(logits)
print(f"Confidence: {confidence.tolist()}")

IOU

**IOU（Intersection over Union），**雅卡尔指数( Jaccard index)，交并比，是一种常用的评估指标，用于衡量两个区域（如预测框和真实框）之间的重叠程度。IOU 在目标检测和分割任务中尤为重要，用于评估模型的预测框或分割区域的准确性。

IOU 的定义

IOU 是预测框与真实框的交集面积与它们的并集面积的比值。公式如下：

其中：

• Intersection（交集）：预测框和真实框重叠的区域面积。
• Union（并集）：预测框和真实框合并的区域面积。

计算 IOU 的步骤

1. 计算交集面积：预测框和真实框重叠区域的面积。
2. 计算并集面积：预测框和真实框的总面积减去交集面积。
3. 计算 IOU：用交集面积除以并集面积。

import torch

def calculate_iou(box1, box2):
    """
    计算两个矩形框的 IOU。

    参数:
    box1 (torch.Tensor): 第一个框的坐标 (x1, y1, x2, y2)。
    box2 (torch.Tensor): 第二个框的坐标 (x1, y1, x2, y2)。

    返回:
    float: 两个框的 IOU。
    """
    # 计算交集区域的坐标
    x1_inter = max(box1[0], box2[0])
    y1_inter = max(box1[1], box2[1])
    x2_inter = min(box1[2], box2[2])
    y2_inter = min(box1[3], box2[3])

    # 计算交集的面积
    inter_area = max(0, x2_inter - x1_inter) * max(0, y2_inter - y1_inter)

    # 计算两个框的面积
    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])

    # 计算并集的面积
    union_area = box1_area + box2_area - inter_area

    # 计算 IOU
    iou = inter_area / union_area if union_area > 0 else 0.0
    return iou

# 示例
box1 = torch.tensor([1, 1, 4, 4], dtype=torch.float32)  # (x1, y1, x2, y2)
box2 = torch.tensor([2, 2, 5, 5], dtype=torch.float32)  # (x1, y1, x2, y2)

iou = calculate_iou(box1, box2)
print(f"IOU: {iou:.2f}")

• 交集区域：使用最大和最小坐标计算两个框的重叠部分。
• 并集区域：计算两个框的总面积减去交集面积。
• IOU：用交集面积除以并集面积。

IOU 在目标检测中通常用于筛选预测框或评估模型的预测效果。常见的做法是设定一个 IOU 阈值，例如 0.5，用于确定一个预测框是否与真实框匹配。

一般情况下在目标检测任务中，人们将IOU ≥0.7时判定为正样本，其余情况判定为负样本。

AP

AP（Average Precision） 是用于评估目标检测和信息检索任务中模型性能的重要指标。AP 综合了精确度（Precision）和召回率（Recall），特别是在不同的置信度阈值下进行评估。

AP 的定义

AP 是精确度和召回率之间的关系的综合度量，通常通过绘制 PR 曲线（Precision-Recall Curve） 并计算其下面积来获得。

计算 AP 的步骤

1. 计算 PR 曲线：

   • 在不同的置信度阈值下计算模型的精确度和召回率。

2. 计算 AP：

   • 通过对 PR 曲线下的面积进行积分，得到 AP。对于每一个召回率值，计算对应的精确度，然后对这些精确度取平均值，得到 AP。

常用的 AP 计算方法

1. 11 点插值（11-point interpolation）：

   • 在 0 到 1 的召回率范围内，以 0.0、0.1、0.2、...、1.0 为步长计算精确度，然后对这些精确度进行平均。

2. 平滑 AP：

   • 使用更多的召回率点（例如 101 个点）进行计算，得到更平滑的 AP 曲线。

import torch
from sklearn.metrics import precision_recall_curve, average_precision_score
import numpy as np

def calculate_ap(pred_probs, true_labels):
    """
    计算平均精确度（AP）。

    参数:
    pred_probs (torch.Tensor): 模型的预测概率（通常是 softmax 的输出）。
    true_labels (torch.Tensor): 真实标签（0 或 1）。

    返回:
    float: 平均精确度（AP）。
    """
    # 将 PyTorch 张量转换为 numpy 数组
    pred_probs_np = pred_probs.numpy()
    true_labels_np = true_labels.numpy()

    # 计算精确度和召回率
    precision, recall, _ = precision_recall_curve(true_labels_np, pred_probs_np)

    # 计算平均精确度（AP）
    ap = average_precision_score(true_labels_np, pred_probs_np)
    return ap

# 示例
pred_probs = torch.tensor([0.9, 0.2, 0.8, 0.6, 0.4], dtype=torch.float32)
true_labels = torch.tensor([1, 0, 1, 1, 0], dtype=torch.float32)

ap = calculate_ap(pred_probs, true_labels)
print(f"Average Precision (AP): {ap:.2f}")

• precision_recall_curve：计算不同置信度下的精确度和召回率。
• average_precision_score：计算 PR 曲线下的面积，即 AP。

AP 是评估目标检测模型性能的关键指标，特别是当数据集具有类不平衡或多类别问题时，它可以提供对模型综合性能的深入了解。在 COCO 和 PASCAL VOC 等挑战中，AP 是常用的评价标准。

mAP

mAP（mean Average Precision） 是一种常用于评估目标检测和信息检索任务中模型性能的综合指标。它是对所有类别的平均精确度（AP）的平均值，用于总结模型在不同类别上的表现。

mAP 的计算步骤：

1. 计算每个类别的 AP：

   • 对于每个类别，计算其精确度-召回率（PR）曲线，并求出该曲线下的面积，即 Average Precision（AP）。

2. 计算 mAP：

   • 对所有类别的 AP 取平均值，得到 mean Average Precision（mAP）。

import numpy as np
from sklearn.metrics import average_precision_score

def calculate_ap(pred_probs, true_labels):
    """
    计算平均精确度（AP）。

    参数:
    pred_probs (numpy.ndarray): 模型的预测概率。
    true_labels (numpy.ndarray): 真实标签。

    返回:
    float: 平均精确度（AP）。
    """
    return average_precision_score(true_labels, pred_probs)

def calculate_map(pred_probs_list, true_labels_list):
    """
    计算平均平均精确度（mAP）。

    参数:
    pred_probs_list (list of numpy.ndarray): 每个类别的预测概率。
    true_labels_list (list of numpy.ndarray): 每个类别的真实标签。

    返回:
    float: 平均平均精确度（mAP）。
    """
    ap_list = []
    for pred_probs, true_labels in zip(pred_probs_list, true_labels_list):
        ap = calculate_ap(pred_probs, true_labels)
        ap_list.append(ap)
    
    map_score = np.mean(ap_list)
    return map_score

# 示例数据（假设有三个类别）
pred_probs_list = [
    np.array([0.9, 0.8, 0.7]),  # 类别 1 的预测概率
    np.array([0.4, 0.6, 0.5]),  # 类别 2 的预测概率
    np.array([0.7, 0.2, 0.9])   # 类别 3 的预测概率
]

true_labels_list = [
    np.array([1, 1, 0]),  # 类别 1 的真实标签
    np.array([0, 1, 0]),  # 类别 2 的真实标签
    np.array([1, 0, 1])   # 类别 3 的真实标签
]

map_score = calculate_map(pred_probs_list, true_labels_list)
print(f"Mean Average Precision (mAP): {map_score:.2f}")

三、常用包Numpy、pandas、matplotlib

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# NumPy 示例
array = np.array([1, 2, 3, 4, 5])
mean_value = np.mean(array)

# pandas 示例
df = pd.DataFrame({
    'X': [1, 2, 3, 4, 5],
    'Y': [1, 4, 9, 16, 25]
})
df['Z'] = df['X'] + df['Y']

# matplotlib 示例
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.plot(df['X'], df['Y'], marker='o')
plt.title('Line Plot')
plt.xlabel('X')
plt.ylabel('Y')

plt.subplot(1, 2, 2)
plt.scatter(df['X'], df['Z'])
plt.title('Scatter Plot')
plt.xlabel('X')
plt.ylabel('Z')

plt.tight_layout()
plt.show()

Numpy

参考官方文档：NumPy 快速入门 --- NumPy v2.0 手册 - NumPy 中文

NumPy 是一个 Python 库，提供了对多维数组对象和多种数值计算功能的支持，是数据科学和机器学习中常用的基础包。它提供了高效的数组操作、数学函数、线性代数运算、统计分析等功能。

NumPy 的主要对象是同构多维数组。它是一个元素表（通常是数字），所有元素类型相同，由非负整数元组索引。在 NumPy 中，维度称为轴。

常用功能和函数

创建数组：

• np.array(): 从列表或元组创建数组。
• np.zeros(): 创建全零数组。
• np.ones(): 创建全一数组。
• np.arange(): 创建具有指定范围的数组。
• np.linspace(): 创建具有指定范围和步长的数组。
• np.empty(): 创建未初始化的数组。

import numpy as np

# 创建数组
array = np.array([1, 2, 3, 4, 5])
print("Original Array:", array)

# 数组操作
print("Shape:", array.shape)
print("Reshaped Array:", array.reshape((1, 5)))

# 数学运算
print("Array + 10:", array + 10)
print("Array * 2:", array * 2)
print("Mean:", np.mean(array))

# 随机数生成
random_array = np.random.rand(2, 2)
print("Random Array:\n", random_array)

# 矩阵运算
matrix = np.array([[1, 2], [3, 4]])
print("Matrix:\n", matrix)
print("Matrix Product:\n", np.dot(matrix, matrix))

# 保存和加载
np.save('matrix.npy', matrix)
loaded_matrix = np.load('matrix.npy')
print("Loaded Matrix:\n", loaded_matrix)

pandas

pandas 是一个用于数据操作和分析的库，提供了高效的数据结构，如 DataFrame 和 Series。

创建 DataFrame 和 Series：

import pandas as pd

# 创建 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

# 创建 Series
series = pd.Series([1, 2, 3, 4])

数据操作：

# 数据筛选
filtered_df = df[df['A'] > 1]

# 数据排序
sorted_df = df.sort_values(by='A')

# 缺失值处理
df_filled = df.fillna(0)

数据读写：

# 读取 CSV 文件
df = pd.read_csv('data.csv')

# 保存为 CSV 文件
df.to_csv('output.csv', index=False)

数据聚合：

# 分组操作
grouped_df = df.groupby('A').sum()

matplotlib

matplotlib 是一个绘图库，用于创建静态、动态和交互式的图形。

绘制基本图形：

import matplotlib.pyplot as plt

# 绘制线图
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]
plt.plot(x, y)
plt.title('Line Plot')
plt.xlabel('X Axis')
plt.ylabel('Y Axis')
plt.show()

# 绘制散点图
plt.scatter(x, y)
plt.title('Scatter Plot')
plt.xlabel('X Axis')
plt.ylabel('Y Axis')
plt.show()

绘制直方图：

data = [1, 2, 2, 3, 4, 4, 4, 5, 6]
plt.hist(data, bins=5)
plt.title('Histogram')
plt.xlabel('Bins')
plt.ylabel('Frequency')
plt.show()

绘制子图：

plt.subplot(1, 2, 1)
plt.plot(x, y)
plt.title('Line Plot')

plt.subplot(1, 2, 2)
plt.scatter(x, y)
plt.title('Scatter Plot')

plt.show()

四、Jupyter notebook/Lab 简述

安装

conda create -n pytorch python=3.8 ipykernel

conda activate pytorch

conda install jupyter notebook

conda install -c conda-forge jupyterlab

jupyter notebook  # 打开Jupyter Notebook

jupyter lab