PyTorch模型性能评估:参数量Params与计算量Flops的实战指南

【参数量(Params)与计算量(FLOPs)的计算】 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、参数量的计算1.卷积层2.池化层3.全连接层二、计算量的计算1.卷积层2.池化层3.全连接层总结 前言 随着深度学习在工业领域的使用,也随着深度学习的进步,模型的复杂度对于衡量一个模型的好坏也至关重要,本文主要介绍一般情况下参数量(Params)与计算量(FLOPs)的计算。 一、参数量的计算 参数量主要用来形容模型的大小程度,类似于算法中的空间复杂度。 1.卷积层 计算公式如下: params = Co×(Ci×Kw. 阅读详情

1. 为什么我们需要关心模型的“体重”和“饭量”?

大家好,我是老张,在AI模型开发和部署这块摸爬滚打了十来年。今天想和大家聊聊一个特别基础,但又极其重要的话题:怎么评估你手头那个PyTorch模型的“身材”和“胃口”。

想象一下,你设计了一个超棒的图像识别模型,在实验室的顶级显卡上跑得飞快,准确率也高。但当你兴冲冲地想把它塞进一台嵌入式设备或者手机App里时,却发现它“卡”得不行,耗电还特别快。这时候你可能会懵:我的模型明明很优秀啊,问题出在哪?

问题的核心,往往在于你只关注了模型的“智商”(准确率),却忽略了它的“体重”(参数量)和“饭量”(计算量)。参数量(Params),简单说就是模型有多少个“可调节的旋钮”,它直接决定了模型文件有多大、需要多少内存来存放。一个参数量上亿的模型,光加载进内存就可能吃掉几百兆甚至上G的空间。计算量(Flops),则是指模型做一次推理(比如识别一张图片)需要完成多少次浮点运算(比如乘法和加法)。它决定了模型跑起来有多“费劲”,直接关系到推理速度、发热和耗电。

我见过太多团队在项目后期才来优化模型效率,那感觉就像给一栋已经盖好的大楼做瘦身,痛苦又低效。所以,我的经验是:在模型设计的早期,甚至在敲下第一行代码之前,就要把参数量和计算量作为核心的评估指标。 一个“好”的模型,不仅要在任务上表现出色,还得身材匀称、吃得少、跑得快。无论是做移动端部署、边缘计算,还是想降低云服务的成本,学会计算和分析这两个指标,都是你的必备技能。

接下来的内容,我会带你用几种最实用、最接地气的方法,亲手给你自己的模型“称体重”、“算饭量”。咱们不搞复杂的理论推导,直接上代码,看结果,说人话。

2. 手动计算:从原理出发,彻底搞懂每个数字怎么来的

在直接调用工具之前,我强烈建议你亲手算一次。这能帮你建立最直观的感觉,以后看任何模型的复杂度报告,心里都有底。

2.1 参数量Params:数一数模型有多少个“旋钮”

模型参数就是那些需要通过数据来学习的权重(Weight)和偏置(Bias)。计算参数量,其实就是把模型中所有带参数的层(比如卷积层、全连接层)的参数个数加起来。

全连接层(Linear Layer):这是最好算的。假设一个全连接层,输入有 in_features 个神经元,输出有 out_features 个神经元。那么,连接这俩层的权重矩阵形状就是 [out_features, in_features]。此外,通常还有一个偏置向量,形状是 [out_features]。所以,这一层的参数量就是: Params = out_features * in_features + out_features

卷积层(Conv2d Layer):稍微复杂点,但规律一样。假设卷积核大小是 (kernel_h, kernel_w),输入通道数是 in_channels,输出通道数是 out_channels。那么,卷积核的权重张量形状是 [out_channels, in_channels, kernel_h, kernel_w]。每个输出通道还有一个偏置(如果 bias=True)。所以参数量是: Params = out_channels * in_channels * kernel_h * kernel_w + out_channels

实战手动计算:我们来写个简单的PyTorch代码,遍历模型的所有参数,把每一层的形状和参数个数都打印出来。这个方法虽然笨,但能让你看清一切。

import torch
import torch.nn as nn

# 定义一个超级简单的模型
class TinyCNN(nn.Module):
    def __init__(self):
        super(TinyCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1) # 卷积层
        self.pool = nn.MaxPool2d(2) # 池化层,无参数
        self.fc = nn.Linear(16 * 16 * 16, 10) # 全连接层,假设输入图像是32x32

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = x.view(-1, 16 * 16 * 16)
        x = self.fc(x)
        return x

model = TinyCNN()
params = list(model.parameters())
total_params = 0

print("开始手动计算参数量:")
for i, param in enumerate(params):
    layer_shape = list(param.size())
    param_count = 1
    for dim in layer_shape:
        param_count *= dim
    print(f"第{i+1}层参数形状: {layer_shape}, 参数数量: {param_count}")
    total_params += param_count

print(f"\n模型总参数量: {total_params}")
print(f"换算成百万单位(M): {total_params / 1e6:.4f} M")

运行这段代码,你会清晰地看到卷积层权重是 [16, 3, 3, 3],全连接层权重是 [10, 4096] 等等。把它们加起来,就得到了总参数量。通过这种方式,你对“1M参数”到底意味着多少存储空间(比如,float32精度下约4MB)会有更实在的感受。

2.2 计算量FLOPs:估算模型干一次活要出多少力

计算量主要统计的是乘加操作(Multiply-Add Operations, MACs)。在深度学习里,一次乘加(先乘后加)通常被计为2次浮点运算(1次乘法 + 1次加法)。

全连接层的FLOPs:对于输入向量 (1, in_features) 和权重矩阵 [in_features, out_features] 的乘法,总共需要 in_features * out_features 次乘法和同样次数的加法。所以 FLOPs(以乘加次数计)是 2 * in_features * out_features。如果考虑批量处理 batch_size 个样本,那就再乘以 batch_size。

卷积层的FLOPs:这是计算量的大头。公式稍微复杂:对于单个输出特征图上的一个点,需要计算卷积核覆盖区域内所有输入通道的乘加。所以,一次卷积操作的FLOPs大约是: FLOPs ≈ 2 * kernel_h * kernel_w * in_channels * out_channels * output_h * output_w 这里的 output_h 和 output_w 是输出特征图的高和宽。2 代表一次乘加算两次操作。

为什么手动估算重要? 当你设计一个新颖的模块(比如一种新的注意力机制)时,可能还没有现成的工具支持。这时,你能根据公式快速估算出它的计算开销,判断这个设计在效率上是否可行。例如,你就能理解为什么Transformer的自注意力层计算量会随着序列长度呈平方级增长,因为那个 QK^T 的矩阵乘法形状是 [序列长, 序列长]。

当然,对于现有标准模型,我们不需要每次都手算。下面我就介绍几个能帮你自动完成这些计算的“神器”。

3. 神器一:thop库 —— 快速准确的“体检中心”

thop(PyTorch-OpCounter)是目前社区里最流行、支持算子最全的模型复杂度分析库之一。它的优点就是快、准、简单。

3.1 安装与基础使用

安装就是一行命令的事:

pip install thop

使用起来更是简单得惊人。下面我们用经典的ResNet-18模型来演示:

import torch
from torchvision.models import resnet18
from thop import profile

# 1. 实例化模型
model = resnet18()
# 2. 准备一个模拟输入(形状必须和模型真实输入一致)
input_tensor = torch.randn(1, 3, 224, 224) # [batch, channels, height, width]
# 3. 一键分析!
flops, params = profile(model, inputs=(input_tensor, ))

print(f"计算量 FLOPs: {flops}") # 原始数值,通常很大
print(f"计算量 FLOPs: {flops / 1e9:.2f} G") # 转换成十亿次(G)单位,更易读
print(f"参数量 Params: {params}") # 原始数值
print(f"参数量 Params: {params / 1e6:.2f} M") # 转换成百万(M)单位

运行一下,你会立刻得到ResNet-18的参数量大约是11.7M,计算量大约是1.8 GFLOPs(对于224x224的输入)。这个速度非常快,对于大多数模型都是秒级完成。

3.2 注意事项与避坑指南

在我多年的使用中,thop 虽然强大,但也有几个坑需要你特别注意:

第一,输入形状至关重要。 profile 函数需要你提供一个真实的输入张量来“运行”一遍模型,从而追踪所有计算路径。如果你的模型有条件分支(比如根据输入内容选择不同的子网络),务必提供一个能触发所有分支的输入,否则计算结果会不准确。对于动态结构的模型,这是个挑战。

第二,小心自定义算子。 如果你在模型里使用了非PyTorch标准的操作,或者自己用 torch.nn.functional 写的复杂函数,thop 可能无法识别其计算量。这时你需要使用 thop 的 register_hook 功能来为自定义算子“手动记账”。例如:

# 假设我们有一个自定义的、计算量很大的函数 my_heavy_op
def my_heavy_op(x):
    # 一些复杂计算...
    return x * x + x

# 告诉thop如何计算这个操作的FLOPs
def count_my_heavy_op(m, x, y):
    # m: 模块, x: 输入, y: 输出
    # 假设我们已知这个操作对每个元素做2次浮点运算
    total_ops = 2 * y.numel() # y.numel()是输出张量的总元素数
    m.total_ops += torch.DoubleTensor([int(total_ops)])

# 在使用profile前注册这个计数函数
from thop import clever_format
# 注意:实际注册需要在profile的上下文内,或对特定模块进行。这里给出概念。

第三,关于模型保存的一个大坑。 这是一个非常隐蔽但常见的问题!当你使用 thop.profile 分析模型后,thop 为了方便,会将 total_ops 和 total_params 作为属性临时注册到你的模型对象上。如果你随后直接使用 torch.save(model.state_dict(), 'model.pth') 保存模型,这些额外属性也会被保存进去。之后加载时,model.load_state_dict(torch.load('model.pth')) 就会报错,提示找不到 total_ops 等键。

解决方案很简单,在加载时设置 strict=False:

model.load_state_dict(torch.load('model.pth'), strict=False)

或者,更干净的做法是在保存模型前,分析完成后,删除这些额外属性:

flops, params = profile(model, inputs=(input_tensor,))
# ... 打印结果
del model.total_ops, model.total_params # 如果存在的话
# 然后再保存
torch.save(model.state_dict(), 'model_clean.pth')

4. 神器二:fvcore库 —— Facebook出品的“专业仪器”

如果说 thop 是便捷的体检中心,那Facebook AI Research开源的 fvcore 就更像一台精密的专业仪器。它同样是计算FLOPs和Params的利器,并且在设计上更模块化。

4.1 安装与基础使用

安装同样简单:

pip install fvcore

它的使用方式和 thop 略有不同,将FLOPs计算和参数量统计分成了两个独立的类,提供了更大的灵活性:

import torch
from torchvision.models import resnet50
from fvcore.nn import FlopCountAnalysis, parameter_count_table

model = resnet50()
input_tensor = torch.randn(1, 3, 224, 224)

# 1. 计算FLOPs
flop_counter = FlopCountAnalysis(model, input_tensor)
total_flops = flop_counter.total()
print(f"fvcore 计算的总FLOPs: {total_flops / 1e9:.2f} G")

# 你还可以打印每层的详细FLOPs
print("\n逐层FLOPs分析:")
print(flop_counter.by_module()) # 这会输出一个字典,显示每个子模块的计算量

# 2. 计算并打印漂亮的参数量表格
print("\n模型参数量详细表格:")
print(parameter_count_table(model))

parameter_count_table 这个函数我非常喜欢,它会生成一个清晰的Markdown格式表格,不仅显示总参数量,还按模块(如 conv1, layer1, fc 等)分解,让你一眼就能看出参数分布在模型的哪个部分,对于模型剪枝和优化特别有帮助。

4.2 fvcore vs. thop:我该怎么选?

这两个库都很优秀,但在不同场景下各有优劣。

  • 易用性:thop 的 profile 函数一键出结果,对新手更友好。fvcore 需要分别调用两个类,但换来的是更细致的分析能力。
  • 分析深度:fvcore 的 by_module() 和 parameter_count_table 提供了更细粒度的洞察。如果你想优化模型,需要知道是哪个瓶颈层吃了最多的计算资源,fvcore 的报告会更直观。
  • 自定义算子支持:两者都支持,但方式不同。fvcore 通过 FlopCountAnalysis.set_op_handle() 来注册自定义算子的计算函数,其API设计可能对复杂操作更灵活一些。
  • 社区与维护:两者都有活跃的维护。thop 在普通CNN模型上应用极广;fvcore 作为FAIR出品,在对Transformer等较新架构的支持上可能更新更及时。

我的个人建议是:日常快速评估用 thop。当你需要对一个复杂模型进行深度性能剖析,或者你的模型包含很多非标准组件时,可以优先尝试 fvcore。事实上,我自己的工具箱里两者都常备。

5. 神器三:torchinfo与torchsummary —— 模型结构的“X光机”

前面两个库重点在“量”,而 torchinfo 和 torchsummary 这类库的重点在“形”。它们能给你打印出模型每一层的输出形状、参数量,是理解模型数据流和调试结构的绝佳工具。虽然它们的主要目的不是计算FLOPs,但 torchinfo 的新版本已经集成了部分FLOPs计算功能。

5.1 torchsummary:经典简洁

torchsummary 是老牌的工具,输出非常简洁。

pip install torchsummary
from torchvision.models import resnet18
from torchsummary import summary

model = resnet18().cuda() # 注意:它通常需要模型在CUDA设备上
summary(model, input_size=(3, 224, 224)) # 指定输入尺寸

它会输出一个表格,包含每层的类型、输出形状、该层参数量。最后给出总参数量和总可训练参数量。对于快速检查模型层与层之间的形状是否匹配,防止因为view或reshape操作导致维度错误,它非常有用。

5.2 torchinfo:功能更强大的继任者

torchinfo 可以看作是 torchsummary 的增强版,我目前更推荐使用它。

pip install torchinfo
from torchvision.models import resnet18
from torchinfo import summary

model = resnet18()
# torchinfo的summary功能强大得多
result = summary(model, input_size=(1, 3, 224, 224), col_names=["input_size", "output_size", "num_params", "kernel_size", "mult_adds"], verbose=1)
print(result)

注意这里的 col_names 参数,你可以指定要显示的列。其中 mult_adds 这一列就是乘加操作的数量,它和FLOPs有直接关系(通常1次乘加 ≈ 2 FLOPs)。torchinfo 通过集成其他后端(比如 thop)来提供这个数据,使其成为一个既能看结构,又能初步评估计算量的综合工具。verbose 参数控制输出细节程度。

5.3 在复杂模型调试中的实战应用

让我分享一个真实案例。有一次,一个同事的模型在训练时总是爆显存(Out of Memory)。他怀疑是批量大小设大了,但减少批量大小后问题依旧。我用 torchinfo 快速扫描了他的模型,发现中间某个自定义模块的输出形状异常巨大,远远超过了设计预期。原来是他在一个本该用卷积的地方错误地使用了全连接层,导致中间激活值(Activation)的数量爆炸式增长。参数量可能变化不大,但中间计算产生的临时张量吃掉了所有显存。torchinfo 输出的每一层 output_size 就像一张路线图,能帮你迅速定位到这种“数据膨胀”的瓶颈点。

6. 进阶:当模型变得巨大——大语言模型(LLM)的复杂度分析

现在我们进入一个更有挑战性的领域:大语言模型。像LLaMA、GPT这样的模型,参数量动辄数十亿、上千亿,它们的复杂度分析有什么不同?我们又该如何估算?

6.1 LLM参数量估算:一个简单的公式

对于基于Transformer Decoder架构的大语言模型(如GPT、LLaMA),其参数量有一个非常漂亮的近似公式。假设模型有 N 层,隐藏层维度(即每个token向量的维度)为 H,那么:

总参数量 ≈ 12 * N * H²

这个公式是怎么来的?我们简单拆解一下:每一层Transformer Block主要包含一个多头注意力(MHA)模块和一个前馈网络(MLP)模块。MHA模块有4个大小为 [H, H] 的投影矩阵(Q, K, V, O),贡献约 4H² 参数。MLP模块通常包含两个线性层,第一个将 H 维映射到 4H 维,第二个映射回 H 维,贡献约 8H² 参数。两者相加是 12H²,再乘以层数 N,就得到了核心参数。此外还有词嵌入层等参数,但在 H 很大时,它们占比很小。

例如,LLaMA-7B模型,H=4096, N=32,代入公式:12 * 32 * 4096² ≈ 12 * 32 * 16.8M ≈ 6.4B,和公布的7B参数非常接近。有了这个公式,你看到模型配置就能快速心里有数。

6.2 LLM计算量估算:关注每个Token的成本

对于计算量,在LLM的推理中,我们尤其关心两个阶段:

  1. Prefill阶段:处理用户输入的整个提示词(Prompt)。其计算量与提示词长度 S、批量大小 B 成正比。近似公式为:FLOPs ≈ 24 * N * H² * B * S。
  2. Decode阶段:自回归地生成每一个新的token。关键结论:生成每个token所需的计算量近似为 24 * N * H²。注意,这个值和生成长度无关,只和模型本身大小有关。

这意味着什么?意味着对于一个7B的模型,生成100个token的计算开销,大约是处理一个长度为100的提示词的100倍(在Decode阶段)。这也解释了为什么LLM生成文本时,首字延迟(Time To First Token)之后,后续token的生成速度相对稳定。

6.3 KV Cache:推理加速的关键与显存杀手

为了不让Decode阶段重复计算之前所有token的Key和Value,所有LLM推理引擎都会使用 KV Cache。它把每个Transformer层计算好的K和V向量缓存下来,供生成下一个token时使用。这是一个典型的用空间换时间的策略。

但KV Cache是显存消耗的大户!它的显存占用公式大约是:KV Cache 显存 (字节) ≈ 4 * N * H * B * (S+O)。其中 S是输入长度,O是已生成输出长度,B是批量大小。

举个例子,用LLaMA-13B模型(N=40, H=5120),以批量大小 B=4 处理一个长对话(S+O=4096 tokens)。那么: 模型参数本身(fp16)约占 13B * 2字节 = 26 GB。 KV Cache 将占用 4 * 40 * 5120 * 4 * 4096 ≈ 13.4 GB。 两者相加已接近40GB,这还没算中间激活等开销。这就是为什么服务超长上下文、高并发的LLM应用需要海量显存,以及为什么优化KV Cache(如量化、分组查询注意力GQA)是当前的研究热点。

理解这些宏观估算,能帮助你在架构选型、硬件采购和性能预期上做出更明智的决策,而不是等到部署时才发现“算力不够,显存告急”。

7. 把这些数字用起来:指导模型选择与优化

算了半天参数量和FLOPs,这些数字到底怎么指导我们的实际工作?我结合几个场景来说说。

场景一:移动端App集成模型选型。 你的目标是图像风格迁移。候选有A模型(参数量5M, FLOPs 2G)和B模型(参数量10M, FLOPs 0.5G)。只看参数量你会选A,因为模型小。但结合计算量,B模型虽然参数多了一点,但推理时计算量只有A的四分之一。在移动端,计算量往往直接关联到推理速度和发热耗电。因此,B模型可能是更好的选择,因为它能在保证效果的同时,给用户带来更流畅的体验。

场景二:模型轻量化改造。 当你发现现有模型计算量太大时,可以从这几个方向入手:

  1. 架构搜索:用EfficientNet、MobileNet等天生高效的架构作为基础。
  2. 剪枝:根据 torchinfo 或 fvcore 的逐层分析,剪掉那些参数多但贡献小的神经元或通道。
  3. 量化:将模型权重和激活从32位浮点数转换为8位整数,这能直接减半甚至减少75%的模型存储和内存带宽压力,从而提升推理速度。很多硬件对整数量化有特殊加速。
  4. 知识蒸馏:用一个庞大的“教师模型”来指导一个轻量级“学生模型”训练,让学生模型用更少的参数和计算量,逼近教师模型的性能。

场景三:预估服务资源。 你要部署一个ResNet-50模型作为API服务。已知单次推理计算量约4 GFLOPs。你使用的云服务器GPU单卡峰值算力为100 TFLOPS(即每秒10^14次浮点运算)。那么,在理想情况下,这张卡一秒钟最多能处理 100e12 / 4e9 = 25000 次推理。当然,实际中会有数据搬运、调度等开销,但这个理论峰值能帮你估算需要多少张卡来支撑目标请求量(QPS)。

记住,参数量和计算量是强大的工具,但它们不是唯一的指标。最终还是要结合在真实数据上的精度(Accuracy)、推理延迟(Latency)、吞吐量(Throughput)以及功耗(Power Consumption)来综合评估。把这些指标放在一起看,你才能打造出真正适用于现实世界的AI模型。

Pytorch中统计模型的计算量(FLOPs)和参数量(Params) get_model_complexity_info 函数的参数 as_strings=True 表示返回的结果以字符串形式表示,print_per_layer_stat=True 表示打印每个层的统计信息。然后,我们定义了模型的输入尺寸,并使用 get_model_complexity_info 函数来计算模型的乘积累加操作(MACs,可以近似为 FLOPs)和参数量。最后,我们将结果打印出来。在深度学习中,FLOPs 用于衡量模型的总计算量,包括所有的乘法、加法和其他可能的操作(如激活函数的计算)。 阅读详情

相关推荐

FLOPs、FLOPS、Params的含义及PyTorch中的计算方法

FLOPs、FLOPS、Params的含义及PyTorch中的计算方法 含义解释 FLOPS:注意全大写,是floating point operations per second的缩写(S表second秒),表示每秒浮点运算次数,理解为计算速度。是一个衡量硬件性能的指标。 FLOPs:注意s小写,是floating point operations的缩写(s表复数),表示浮点运算数,理解为计算量。可以用来衡量算法/模型的复杂度。 Params:没有固定的名称,大小写均可,表示模型的参数量,也是用来衡量算法

weixin_44966641的博客 4万+

模型计算量(FLOPs)和参数量(Params)的理解 + 计算、打印可训练参数量、可训练的层

(1)换算 以alexnet为例: 参数量:6000万 设每个参数都是float,也就是一个参数是4字节, 总的字节数是24000万字节 24000万字节= 24000万/1024/1024=228mb (2)为什么模型之间差距这么大 这个关乎于模型的设计了,其中模型里面最费参数的就是全连接层,这个可以看alex和vgg, alex,vgg有很多fc(全连接层) resnet就一个fc inceptionv1(googlenet)也是就一个fc (3)计算量 densenet其实这个

Drug discovery 2万+

Python实战:用thop库快速计算模型参数量(Params)和计算量(FLOPs)的保姆级教程

本文提供了一份使用thop库计算深度学习模型参数量(Params)和计算量(FLOPs)的详细教程。文章从核心概念解析入手,逐步指导环境搭建、基础使用、进阶分析,并对比了不同视觉模型的复杂度。教程强调正确使用单位(如M和G)进行标准化报告,并指出需结合实际推理速度等指标进行综合评估,是模型效率分析与优化的实用指南。

yy01234的博客 1091

【深度学习】深度学习中模型计算量(FLOPs)和参数量(Params)等的理解以及四种在python应用的计算方法总结

计算量对应我们之前的时间复杂度,参数量对应于我们之前的空间复杂度,这么说就很明显了也就是计算量要看网络执行时间的长短,参数量要看占用显存的量注意全大写,是floating point operations per second的缩写,意指每秒浮点运算次数,理解为计算速度。是一个衡量硬件性能的指标。注意s小写,是floating point operations的缩写(s表复数),意指浮点运算数,理解为计算量。可以用来衡量算法/模型的复杂度。

点赞的都能无bug通过! 7462

PyTorch模型计算量(FLOPs)与参数量(Params)的保姆级统计指南

本文详细介绍了在PyTorch中统计模型计算量(FLOPs)和参数量(Params)的完整方法,包括基础概念解析、实战统计技巧和高级优化策略。通过thop库和手动计算两种方式,帮助开发者准确评估模型复杂度,为模型优化和部署提供关键依据。文章还涵盖了参数量优化技巧和FLOPs计算原理,是深度学习工程师的实用指南。

weixin_30300225的博客 486

别再傻傻分不清FLOPs和FLOPS了!手把手教你用thop库计算PyTorch模型的计算量与参数量

本文深入解析深度学习模型评估中的核心指标FLOPs、MACs和Params,帮助开发者准确区分这些概念并掌握其计算方法。通过thop库的实战演示,详细展示如何计算PyTorch模型的计算量与参数量,为模型优化和轻量化提供决策依据。

weixin_30399821的博客 446

模型三大评估指标

首先解释什么是AP(Average Precision,平均精度),AP就是P-R图中曲线下的面积,反应了单一类别中精确率和召回率的综合表现。简单记忆:图中有100个真正的目标,你预测出了80个为真的目标,那这80个就是你召回来的真孤魂野鬼,该安息了哈哈哈。是机器学习中用于评估分类模型性能的工具,它通过展示模型在测试数据上的预测结果与真实标签的对比情况,直观地反映模型的分类效果。而P-R图就和图中一样,画一个45°的斜线,和曲线相交的位置,就是最大满足查全率的同时也最大满足查准率的点。

jenny88889999的博客 5026

深度学习模型大小和计算量单位全解析:从Params到FLOPs的实战指南

本文深入解析了深度学习模型评估中的两个核心指标:参数量(Params)与浮点运算次数(FLOPs)。文章从概念定义、单位换算、计算工具使用到实战场景分析,提供了从理论到生产的完整指南,帮助工程师根据资源约束(如边缘设备或云端部署)科学评估和优化模型复杂度,实现性能与效率的最佳平衡。

weixin_29098117的博客 410

Python实战:用thop库快速计算模型参数量(Params)和FLOPs(附完整代码)

本文详细介绍了如何使用Python的thop库快速计算深度学习模型的参数量(Params)和浮点运算次数(FLOPs)。通过AlexNet、ResNet等实例代码,手把手教你获取并以M(百万)和G(十亿)为单位规范呈现这两个关键指标,解决模型评估与论文写作中的实际问题。

rose2的博客 986

深度学习模型效率评估:FLOPs与Params在PyTorch中的实战解析

本文深入解析了深度学习模型效率评估中的FLOPs与Params核心概念,并提供了在PyTorch中的实战计算方法。通过详细的公式拆解和代码示例,帮助开发者准确计算卷积层与全连接层的复杂度,并介绍使用thop库进行一键分析的技巧。文章还涵盖了模型优化策略、硬件选型指南以及效率与精度的平衡艺术,为AI模型部署提供实用参考。

weixin_29050513的博客 230

PyTorch模型优化必看:3种工具快速计算FLOPs和Params(附代码对比)

本文深入对比了PyTorch生态中三种主流的模型效率分析工具——thop、ptflops和pytorch_model_summary,用于快速计算模型的FLOPs和Params。文章通过代码实例详细解析了各工具的原理、使用场景与优缺点,并提供了针对复杂模型(如多输入、动态网络)的统计策略与选型指南,帮助开发者精准评估模型的计算量与参数量,为模型优化与部署提供关键依据。

motor的博客 524

PyTorch模型性能评估:参数量与计算量的高效计算方法与实践指南

本文详细介绍了PyTorch模型性能评估中参数量与计算量的高效计算方法与实践指南。通过解析核心概念、手动计算原理、使用thop和torchstat等工具,帮助开发者快速掌握模型复杂度评估技巧,优化AI模型在边缘设备上的部署效率。特别针对Flops计算和框架结构分析提供了实用解决方案。

lemon的博客 644

【技术指南】深度学习模型评估:如何正确理解和使用Params(M)与FLOPs(G)单位

本文深入解析了深度学习模型评估中的两个核心指标:Params(M)与FLOPs(G)。Params(参数量,单位M)衡量模型的存储开销与复杂度,而FLOPs(浮点运算次数,单位G)则反映模型的计算开销与推理速度。文章通过概念辨析、单位解读、代码实践及常见陷阱分析,指导读者如何正确理解并运用这两个指标进行模型选型与优化,避免实际应用中的误区。

soda5的博客 885

PyTorch模型性能评估:FLOPs与Params的实战解析与优化策略

本文深入解析PyTorch模型中FLOPs(计算量)与Params(参数量)的评估方法及优化策略,通过实战案例展示如何使用thop、ptflops等工具进行性能分析,并提供模型轻量化设计的实用技巧。文章特别强调在模型选型、部署预评估和优化过程中准确计算FLOPs的重要性,帮助开发者平衡模型精度与效率。

weixin_30752699的博客 429

# 执行 DISM 命令时出错 87 未在此上下文中识别出 restorehealth 选项。解决方法

# 执行 DISM 命令时出错 87 未在此上下文中识别出 restorehealth 选项。解决方法

段子手168的博客 1万+

YIUI框架深度解析:基于ET的数据驱动UI开发实践

在Unity游戏开发中,UI管理是构建复杂应用的核心挑战之一。传统命令式编程需要开发者手动操作每个UI组件,导致业务逻辑与视图层高度耦合,代码难以维护。数据驱动是一种先进的架构思想,它通过建立数据模型与UI组件之间的绑定关系,实现数据变化时UI的自动更新,从而将开发者的关注点从“如何操作UI”转移到“数据状态是什么”。这种模式显著提升了代码的可维护性和开发效率,尤其适用于状态频繁变化的游戏界面。YIUI框架正是这一思想在Unity UGUI上的工程化实践,它通过Model-View-Component的清晰

java天气 435

【AI-Infra】FLOPs、FLOPS和Params的含义、计算及其在PyTorch中的使用

在深度学习领域,模型的效率和复杂度是衡量算法性能的重要指标。FLOPs、FLOPS和Params是三个关键概念,它们分别代表了模型的计算量、计算速度和参数量。本文将详细解释这些概念,并展示如何在PyTorch中计算它们,以便更好地理解和优化我们的模型。

记录成长 1748

【编译原理】LL(1)分析方法 生成语法树(c++实现)

基本流程 输入文法->消除左递归->提取左公共因子->求FIRST集->求FOLLOW集->LL(1)分析表->表驱动的预测语法分析过程->输出语法分析结果和语法树

qq_43417265的博客 1万+

别再只盯着参数量了!用torchinfo和thop实战分析你的PyTorch模型FLOPs与Params(附代码避坑)

本文深入探讨了如何利用torchinfo和thop工具精准评估PyTorch模型的FLOPs与参数量,揭示参数量并非衡量模型效率的唯一标准。通过实战案例和代码示例,帮助开发者避开常见误区,优化模型在移动端和边缘计算场景的性能表现。

weixin_30732487的博客 586

Android CCodec (四) Output Buffer流程分析

Android 多媒体架构 Codec2 Output Buffer

给大佬递杯卡布奇诺的博客 3267

Valgrind 从入门到精通:内存调试和性能分析

Valgrind 提供了强大的 API,允许开发者编写自定义的检查工具。通过扩展 Valgrind,可以针对特定场景实现更精准的检测。

大模型大数据攻城狮的专栏 1219

PyTorch模型性能分析:参数量与计算量的高效评估方法

本文详细介绍了评估PyTorch模型参数量与计算量的三种核心工具:torchsummary、THOP和torchstat。文章通过实战对比,阐述了如何根据模型调试、选型和深度优化等不同场景选择合适工具,并强调了理解FLOPs和Params等理论指标对于模型部署与性能优化的重要性。

weixin_29054399的博客 255

2026年GESP3月认证C++五级真题解析

因为要合并成升序数组,所以当A[i]小于等于B[j]时,取A[i],否则取B[j]。当a[i]>a[j]时,左边数组中从i到m的所有元素都大于a[j],因此逆序对数量增加m-i+1。给定一个包含n个互不相同的正整数的数组A与一个包含m个互不相同的正整数的数组B,请你帮忙计算有多少个数在数组A与数组B中均出现。下面代码实现两个整数除法,其中被除数为一个“大整数”,用字符串表示,除数是一个小整数,用int表示,则横线处应该填写()。且a[i] > a[j],则a[i]和a[j]是一个逆序对。

lan_in的博客 121

如何使用torchstat快速计算PyTorch模型的参数量与FLOPs

torchstat是一款专为PyTorch模型设计的轻量级分析工具,能够帮助开发者快速获取模型的参数量、FLOPs(浮点运算次数)和内存占用等关键指标。对于模型优化、性能评估和资源配置而言,这些数据至关重要。本文将带你掌握使用torchstat的完整流程,从安装到高级应用,让你轻松成为模型分析专家。 ## 📦 超简单安装步骤 开始使用torchstat前,只需两步即可完成安装: 1. **

gitblog_00673的博客 859

9篇9章1节:认识 SHARE 数据库

SHARE数据库是欧洲最大的跨国老龄化追踪调查项目,覆盖28个欧洲国家和以色列的50岁及以上人群。自2004年启动以来,已完成14-16万受访者的50-60万次访谈,形成跨度20年的纵向数据。该数据库采用标准化的多阶段抽样方法,收集健康、经济和社会关系等领域的多维度信息,具有高度的跨国可比性。SHARE与美国HRS、英国ELSA等调查对接,构成全球老龄化研究网络。数据免费向科研人员开放,但需注册并承诺仅用于非商业性研究。该项目由欧盟委员会等多方资助,为老龄化研究和政策制定提供了重要实证依据。

MD Code 907

泰山派rk3566 audio音频基础介绍

本文介绍了嵌入式系统中音频处理的基础知识,重点围绕RK3566平台的音频子系统展开。文章首先解释了音频信号从模拟到数字的转换过程,包括采样率、位深和声道等核心概念。随后详细分析了嵌入式音频开发中的关键接口:I2C用于控制音频编解码器,I2S作为专用音频数据传输总线,以及PCM作为原始音频格式和ALSA设备抽象的双重含义。通过对这些基础概念和接口的解析,为在RK3566平台上进行音频驱动开发和应用调试提供了理论基础。

qq_37077309的博客 295
上一篇: Ditto进阶指南:解锁局域网共享剪贴板的高效开发协作
下一篇: Python实战:用NumPy手写最小距离分类器(附人脸识别案例)
Python
博客等级 码龄26年 1973粉丝 1567原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值