gaze360代码运行结果分析

最新推荐文章于 2024-06-07 09:50:57 发布
最新推荐文章于 2024-06-07 09:50:57 发布
阅读量595 收藏 1
点赞数 1
文章标签： 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w12345815856_/article/details/127447509
版权

 GazeLSTM模型FLOPs计算可视化

import torchvision
from ptflops import get_model_complexity_info

model = GazeLSTM()
macs, params = get_model_complexity_info(model, (7, 3, 224, 224), as_strings=True, print_per_layer_stat=True)
print('macs: ', macs, 'params: ', params)

通过在model中添加这几行代码，可以得到计算量和参数量。

输出结果由下图所示：

GazeLSTM(
  14.58 M, 100.000% Params, 12.78 GMac, 100.000% MACs, 
  (base_model): ResNet(
    11.95 M, 81.950% Params, 12.76 GMac, 99.855% MACs, 
    (conv1): Conv2d(9.41 k, 0.065% Params, 826.1 MMac, 6.466% MACs, 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(128, 0.001% Params, 11.24 MMac, 0.088% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(0, 0.000% Params, 5.62 MMac, 0.044% MACs, inplace=True)
    (maxpool): MaxPool2d(0, 0.000% Params, 5.62 MMac, 0.044% MACs, kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): Sequential(
      147.97 k, 1.015% Params, 3.25 GMac, 25.469% MACs, 
      (0): BasicBlock(
        73.98 k, 0.508% Params, 1.63 GMac, 12.735% MACs, 
        (conv1): Conv2d(36.86 k, 0.253% Params, 809.24 MMac, 6.334% MACs, 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, 0.001% Params, 2.81 MMac, 0.022% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 2.81 MMac, 0.022% MACs, inplace=True)
        (conv2): Conv2d(36.86 k, 0.253% Params, 809.24 MMac, 6.334% MACs, 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, 0.001% Params, 2.81 MMac, 0.022% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): BasicBlock(
        73.98 k, 0.508% Params, 1.63 GMac, 12.735% MACs, 
        (conv1): Conv2d(36.86 k, 0.253% Params, 809.24 MMac, 6.334% MACs, 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, 0.001% Params, 2.81 MMac, 0.022% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 2.81 MMac, 0.022% MACs, inplace=True)
        (conv2): Conv2d(36.86 k, 0.253% Params, 809.24 MMac, 6.334% MACs, 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, 0.001% Params, 2.81 MMac, 0.022% MACs, 64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (layer2): Sequential(
      525.57 k, 3.605% Params, 2.89 GMac, 22.599% MACs, 
      (0): BasicBlock(
        230.14 k, 1.579% Params, 1.26 GMac, 9.897% MACs, 
        (conv1): Conv2d(73.73 k, 0.506% Params, 404.62 MMac, 3.167% MACs, 64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, 0.002% Params, 1.4 MMac, 0.011% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 1.4 MMac, 0.011% MACs, inplace=True)
        (conv2): Conv2d(147.46 k, 1.012% Params, 809.24 MMac, 6.334% MACs, 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, 0.002% Params, 1.4 MMac, 0.011% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (downsample): Sequential(
          8.45 k, 0.058% Params, 46.36 MMac, 0.363% MACs, 
          (0): Conv2d(8.19 k, 0.056% Params, 44.96 MMac, 0.352% MACs, 64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(256, 0.002% Params, 1.4 MMac, 0.011% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): BasicBlock(
        295.42 k, 2.027% Params, 1.62 GMac, 12.702% MACs, 
        (conv1): Conv2d(147.46 k, 1.012% Params, 809.24 MMac, 6.334% MACs, 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, 0.002% Params, 1.4 MMac, 0.011% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 1.4 MMac, 0.011% MACs, inplace=True)
        (conv2): Conv2d(147.46 k, 1.012% Params, 809.24 MMac, 6.334% MACs, 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, 0.002% Params, 1.4 MMac, 0.011% MACs, 128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (layer3): Sequential(
      2.1 M, 14.404% Params, 2.88 GMac, 22.560% MACs, 
      (0): BasicBlock(
        919.04 k, 6.305% Params, 1.26 GMac, 9.875% MACs, 
        (conv1): Conv2d(294.91 k, 2.023% Params, 404.62 MMac, 3.167% MACs, 128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, 0.004% Params, 702.46 KMac, 0.005% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 702.46 KMac, 0.005% MACs, inplace=True)
        (conv2): Conv2d(589.82 k, 4.046% Params, 809.24 MMac, 6.334% MACs, 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, 0.004% Params, 702.46 KMac, 0.005% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (downsample): Sequential(
          33.28 k, 0.228% Params, 45.66 MMac, 0.357% MACs, 
          (0): Conv2d(32.77 k, 0.225% Params, 44.96 MMac, 0.352% MACs, 128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(512, 0.004% Params, 702.46 KMac, 0.005% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): BasicBlock(
        1.18 M, 8.100% Params, 1.62 GMac, 12.685% MACs, 
        (conv1): Conv2d(589.82 k, 4.046% Params, 809.24 MMac, 6.334% MACs, 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, 0.004% Params, 702.46 KMac, 0.005% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 702.46 KMac, 0.005% MACs, inplace=True)
        (conv2): Conv2d(589.82 k, 4.046% Params, 809.24 MMac, 6.334% MACs, 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, 0.004% Params, 702.46 KMac, 0.005% MACs, 256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (layer4): Sequential(
      8.39 M, 57.582% Params, 2.88 GMac, 22.541% MACs, 
      (0): BasicBlock(
        3.67 M, 25.198% Params, 1.26 GMac, 9.864% MACs, 
        (conv1): Conv2d(1.18 M, 8.093% Params, 404.62 MMac, 3.167% MACs, 256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1.02 k, 0.007% Params, 351.23 KMac, 0.003% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 351.23 KMac, 0.003% MACs, inplace=True)
        (conv2): Conv2d(2.36 M, 16.185% Params, 809.24 MMac, 6.334% MACs, 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1.02 k, 0.007% Params, 351.23 KMac, 0.003% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (downsample): Sequential(
          132.1 k, 0.906% Params, 45.31 MMac, 0.355% MACs, 
          (0): Conv2d(131.07 k, 0.899% Params, 44.96 MMac, 0.352% MACs, 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(1.02 k, 0.007% Params, 351.23 KMac, 0.003% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): BasicBlock(
        4.72 M, 32.384% Params, 1.62 GMac, 12.677% MACs, 
        (conv1): Conv2d(2.36 M, 16.185% Params, 809.24 MMac, 6.334% MACs, 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1.02 k, 0.007% Params, 351.23 KMac, 0.003% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(0, 0.000% Params, 351.23 KMac, 0.003% MACs, inplace=True)
        (conv2): Conv2d(2.36 M, 16.185% Params, 809.24 MMac, 6.334% MACs, 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1.02 k, 0.007% Params, 351.23 KMac, 0.003% MACs, 512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (avgpool): AdaptiveAvgPool2d(0, 0.000% Params, 175.62 KMac, 0.001% MACs, output_size=(1, 1))
    (fc1): Linear(513.0 k, 3.519% Params, 3.58 MMac, 0.028% MACs, in_features=512, out_features=1000, bias=True)
    (fc2): Linear(256.26 k, 1.758% Params, 1.79 MMac, 0.014% MACs, in_features=1000, out_features=256, bias=True)
  )
  (lstm): LSTM(2.63 M, 18.040% Params, 18.48 MMac, 0.145% MACs, 256, 256, num_layers=2, batch_first=True, bidirectional=True)
  (last_layer): Linear(1.54 k, 0.011% Params, 1.54 KMac, 0.000% MACs, in_features=512, out_features=3, bias=True)
)
macs:  12.78 GMac params:  14.58 M

 通过上图我们可以清晰地看到每一层的参数量params和macs，其中FLOPs=2*macs，所以最终我们可以得到总FLOPs=25.56GMac，参数量params=14.58M。

 基于Gaze360数据集训练结果

 观察最后一轮训练结果平均angular loss为13左右，这与论文中作者得到的结果基本一致。

 

skpl_w
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码分析方法
Json_Nie的专栏
01-12 1144
一 收集信息 包括：用户文档，设计文档，FAQ，SDK，测试源代码 （网站上能收集到的有用信息）这些信息可以从项目的主页、Wiki、Google、邮件列表、论坛，以及相关的论文和书籍中获得，并且将收集的相关信息统一管理起来。 二 制定分析策略 由于开源软件的代码量往往是惊人的，很多时候又缺少相关的设计文档和资料，并且对于个人来说精力也是有限的。因此，在代码分析之前制定一套分析策略是比较重要的
cs231n assigment1 KNN部分代码运行结果及分析
qq_41118491的博客
12-09 1449
这是cs231n的课程作业，通过在网上寻找的各个代码解析以及自己运行代码后，对于KNN特征提取有了更加深刻的了解，也对python语言有了初步的认识。 在之前的课程也对KNN算法简单介绍过，KNN算法比较简单：在最近的K个样本中选择概率最大的作为测试的值（需要进行距离判断，可以用欧氏距离、曼哈顿距离等距离度量方法）。更具体的可参考http://blog.csdn.net/zhyh14355896
Gaze360代码解读
w12345815856_的博客
10-14 1212
Gaze360代码阅读
c代码-3-2运行结果分析
07-16
c代码-3-2运行结果分析
推荐开源项目：Gaze360 - 实时无约束的户外眼神跟踪系统
最新发布
gitblog_00010的博客
06-07 435
推荐开源项目：Gaze360 - 实时无约束的户外眼神跟踪系统 项目地址:https://gitcode.com/erkil1452/gaze360 项目介绍 Gaze360 是一个先进的计算机视觉项目，旨在实现物理上不受限制的眼神估计技术，特别是在复杂和自然的环境中。该项目不仅提供了一个大规模的眼球追踪数据集，还包含了用于处理这些数据的高效模型代码。通过Gaze360，研究人员与开发者可以构建出...
如下关于对象与引用的代码，运行结果分析
我们已不在年轻
08-18 103
查看复制到剪切板打印 public class MyClass{        static void aMethod(StringBuffer sf1,StringBuffer sf2{            sf1.append(sf2);            sf2 = sf1;        }        public static void ...
运行结果分析
qq_39632912的博客
01-17 1126
41不是和42 43在一行，原因是：Resuming thread.没有赶在41输出前输出。。。分析...................... package bao; class MyThread implements Runnable {     Thread thrd;     boolean suspended;     boolean stoppe
ksvdMATLAB代码-SC_based_gaze_prediction:SC_based_gaze_prediction
05-28
MATLAB代码SC_based_gaze_prediction 该存储库包含以下论文的代码。 Li Yujie Li，Atsunori Kanemura，Asoh Hideki，Taiki Miyanishi和Motoaki Kawanabe，“用于以自我为中心的视频中凝视预测的稀疏编码框架”， ...
【视线估计】ARE-gaze estimation网络结构Pytorch代码
04-26
Appearance-Based Gaze Estimation via Evaluation-Guided Asymmetric Regression论文中pytorch代码
Gaze-Following-master.zip
03-31
"Gaze-Following-master.zip" 文件包含了实现这一技术的相关代码和资源，为我们提供了深入研究和应用视线跟随的平台。 视线跟随的核心是精确地计算出人眼的中心坐标和视线方向向量。人眼的中心坐标是眼球在二维图像...
CalibrationTest.zip_CUU_gaze tracking
07-15
基于C++语言在windows下对眼动追踪的校准测试
C++程序分析及运行结果
10-29
本课程主要掌握C++语言的基本语法，以及面向对象程序设计与分析，重点掌握面向对象中类与对象的定义及调用，运算符函数重载，继承性与多态性的运用，理解掌握C++中输入输出流类和模板的使用。最终达到能够简单的、综合的面向对象程序设计能力。
amarjeet.zip_eye gaze_gaze_gaze estimation_head
07-15
Visual Gaze Estimation by Joint Head and Eye Information
四则运算2的设计思想+源程序代码+运行结果截图+编程总结分析
aiduo3346的博客
12-06 392
（一）程序设计思想： 　　在第一个页面中输入要出的题数，然后接收这个数据去往数据库中写入相应数量的四则运算题目。在第二个jsp页面中遍历输出数据库中的题目，并且加入一个文本框去让客户输入这个数据，当所有题都答完是下面有一个提交按钮，点击提交按钮，将用户输入的结果与数据库中结果进行比对，然后跳转到页面3去输出题目，用户结果，和判断结果，页面3有两个按钮分别是继续答题和推出，如果选择继续答...
说说以下代码的运行结果，并解释下原因?
紫乾2014的博客
07-07 269
package zxj.com.cn; public class Demo { public static void main(String[] args) { String strA = "abc"; String strB = new String("abc"); System.out.println("strA == strB ? " + (strA == strB ? true : false)); ...
第五章总结和代码运行结果
qq_50124041的博客
12-18 456
for语句： for 语句的执行过程如下： ①首先计算表达式 1。 ②判断表达式 2.若其值为真(非 0),则执行循环体语句,然后 执行第③步;若值为假(0),结束循环,转到第⑤步执行。 ③计算表达式 3. ④返回第②步继续执行。 ⑤循环结束,继续执行 for 语句的下一条语句。 大部分情况下,循环体语句为一复合语句。 注意,表达式 1 只是在进入循环之前计算一次。表达式 2、循 本语句和表达式 3 将重复执行。 根据 for 语句格式的特点,其实际应用可以有多种形式。 在 for 循环中,每次读入一.
分析以下代码执行结果是什么，为什么？
weixin_60359155的博客
11-21 607
目录 一、问题代码 二、结果是什么 三、分析代码 一、问题代码 #include <stdio.h> int main() { int i = 0; int arr[10] = { 1,2,3,4,5,6,7,8,9,0 }; for (i = 0; i <= 12; i++) { arr[i] = 0; printf("hehe\n"); } return 0; } ...
一小段C++代码分析,看看你能写出输出结果吗,很简单的!
lookthesea的专栏
11-05 1102
1．分析下列C＃代码的输出结果：using System;namespace Test{       class Class1    {        [STAThread]        static void Main(string[] args)        {            Console.WriteLine(new Class1()); 
第五章总结及代码
weixin_61961365的博客
12-10 540
1. 代码 #include<stdio.h> #include<math.h> int main() { int n = 13, year; double number, rate = 0.02; for (year = 1; year <= 10; year++) { number = n * pow((1 + rate), year); printf("%2d年后，人数为:%.2f亿\n", year, ...
gaze360数据集预处理
05-17
Gaze360数据集是一个用于人眼注视方向估计的数据集，包含了大量的头部姿势和眼睛注视方向的标注信息。对于预处理，你可以按照以下步骤进行： 1. 下载数据集：Gaze360数据集可以从官方网站...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值