Hession-free 的共轭梯度法的高效计算版本的部分代码（pytorch实现，实现一阶求导的一次计算重复使用）

Hession-free 的共轭梯度法在求解 H*v 的时候是先求一阶导，即雅可比向量，然后雅可比向量与向量v乘积后再求二导数，这样可以避免Hession矩阵在内存中的完全展开，减少内存消耗，使大规模矩阵的计算实现可行；但是该种传统的计算过程中会出现大量重复的对相同计算图的一阶求导，而这部分求导是在整个共轭梯度算法中保持不变的，我们完全可以避免掉这部分计算的重复进行，因此在pytorch版本中对一阶计算图求导时使用create_graph=True参数，而在二阶求导时使用retain_graph=True参数，这样我们就可以对一阶计算图进行重复使用。

给出部分代码，H*v部分代码：

import torch

w=torch.tensor([1.],requires_grad=True) # w=1

x=torch.tensor([2.],requires_grad=True) # x=2

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y, [w, x], create_graph=True)

print(w_grad)       # 2w+x+1 = 5

print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z, [w, x], retain_graph=True)

print(w_grad2)       # 3

print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2, [w, x])

print(w_grad2)       # 3

print(x_grad2)       # 1

计算结果：

性能比较：一个简单例子

import torch

import numpy as np

import time

w=torch.tensor(torch.randn(10000), requires_grad=True) # w=1

x=torch.tensor(torch.randn(10000), requires_grad=True) # x=2

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

##########################################

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

a_t = time.time()

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

b_t = time.time()

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

b2_t = time.time()

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

c_t = time.time()

print(b_t - a_t)

print(c_t - b2_t)

运行结果：

可以看到，使用该种方法可以避免一次求导的重复进行，可以提速10%，虽然没有因为避免一阶求导的重复进行而省掉较大的计算时间，但是提速10%也算是不错的表现了，当然这个例子只是使用CPU进行的。

给出GPU版本：

点击查看代码 
import torch

import numpy as np

import time

w=torch.tensor(torch.randn(10000), requires_grad=True).to("cuda:0" if torch.cuda.is_available() else "cpu") # w=1

x=torch.tensor(torch.randn(10000), requires_grad=True).to("cuda:0" if torch.cuda.is_available() else "cpu") # x=2

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

##########################################

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

a_t = time.time()

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

b_t = time.time()

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

b2_t = time.time()

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

c_t = time.time()

print(b_t - a_t)

print(c_t - b2_t)

运行结果：

可以看到，性能提升了15%左右。

更正：

上面的测评标准不是很正确，下面给出更正后的测评代码和性能表现：

import torch

import numpy as np

import time

w=torch.tensor(torch.randn(10000000), requires_grad=True).to("cuda:0" if torch.cuda.is_available() else "cpu") # w=1

x=torch.tensor(torch.randn(10000000), requires_grad=True).to("cuda:0" if torch.cuda.is_available() else "cpu") # x=2

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

z = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

# print(w_grad2)       # 3

# print(x_grad2)       # 1

z2 = w_grad + x_grad

w_grad2, x_grad2 = torch.autograd.grad(z2.mean(), [w, x])

# print(w_grad2)       # 3

# print(x_grad2)       # 1

##########################################

##########################################

a_t = time.time()

def f():

    a=torch.add(w,x)    # a = w+x

    b=torch.add(w,1)    # b = w+1

    y=torch.mul(a,b)    # y = w**2+w*x+w+x

    # w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

    w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

    # print(w_grad)       # 2w+x+1 = 5

    # print(x_grad)       # w+1 = 2 

    z = w_grad + x_grad

    w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x])

    # print(w_grad2)       # 3

    # print(x_grad2)       # 1

for i in range(5):

    f()

###################################

###################################

b_t = time.time()

a=torch.add(w,x)    # a = w+x

b=torch.add(w,1)    # b = w+1

y=torch.mul(a,b)    # y = w**2+w*x+w+x

# w_grad, x_grad = torch.autograd.grad(y, [w, x], retain_graph=True, create_graph=True)

w_grad, x_grad = torch.autograd.grad(y.mean(), [w, x], create_graph=True)

# print(w_grad)       # 2w+x+1 = 5

# print(x_grad)       # w+1 = 2 

def f2():

    z = w_grad + x_grad

    w_grad2, x_grad2 = torch.autograd.grad(z.mean(), [w, x], retain_graph=True)

    # print(w_grad2)       # 3

    # print(x_grad2)       # 1

for i in range(5):

    f2()

c_t = time.time()

print(b_t - a_t)

print(c_t - b_t)

性能表现：

可以看到，用时为之前的32%，可以说提速了70%左右，可以看到在更正后的测评中本文提出的Hession-free的共轭梯度加速计算方法可以有不错的性能表现。

Hession-free 的共轭梯度法的高效计算版本的部分代码（pytorch实现，实现一阶求导的一次计算重复使用）的更多相关文章

  1. 【Java】一个小程序，计算它包含的代码所需的耗时

    写一个小程序,用来计算它包含的代码所需的耗时.虽然简单,测试代码是否耗时还是有点用的,不用重新写嘛~ import java.util.Date; import java.util.concurren ...

  2. js学习笔记-编写高效、规范的js代码-Tom

    编写高效.规范的js代码: 1.变量命名空间问题,尽量使用局部变量,防止命名冲突(污染作用域中的全局变量):全局空间命名的变量可以在对应的文档域任意位置中使用window调用. 2.尽量使用单var定 ...

  3. 基于jquery判断浏览器版本过低代码

    基于jquery判断浏览器版本过低代码.这是一款对不支持HTML5跟CSS3代码的浏览器提示用户更换特效代码.效果图如下: 在线预览   源码下载 实现的代码. html代码: <div sty ...

  4. 编写一个ComputerAverage抽象类，类中有一个抽象方法求平均分average，可以有参数。定义 Gymnastics 类和 School 类，它们都是 ComputerAverage 的子类。Gymnastics 类中计算选手的平均成绩的方法是去掉一个最低分，去掉一个最高分，然后求平均分；School 中计算平均分的方法是所有科目的分数之和除以总科目数。 要求：定义ComputerAv

    题目: 编写一个ComputerAverage抽象类,类中有一个抽象方法求平均分average,可以有参数. 定义 Gymnastics 类和 School 类,它们都是 ComputerAverag ...

  5. 构建一个学生Student，根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

    定义一个表示学生信息的类Student,要求如下: (1)类Student的成员变量: sNO 表示学号: sName表示姓名: sSex表示性别: sAge表示年龄: sJava:表示Java课程成 ...

  6. Git创建、diff代码、回退版本、撤回代码，学废了吗

    .eye-care { background-color: rgba(199, 237, 204, 1); padding: 10px } .head-box { display: flex } .t ...

  7. Linux网络通信（线程池和线程池版本的服务器代码）

    线程池 介绍 线程池: 一种线程使用模式.线程过多会带来调度开销,进而影响缓存局部性和整体性能.而线程池维护着多个线程,等待着监督管理者分配可并发执行的任务.这避免了在处理短时间任务时创建与销毁线程的 ...

  8. 一个快速、高效的Levenshtein算法实现——代码实现

    在网上看到一篇博客讲解Levenshtein的计算,大部分内容都挺好的,只是在一些细节上不够好,看了很长时间才明白.我对其中的算法描述做了一个简单的修改.原文的链接是:一个快速.高效的Levensht ...

  9. KubeEdge v0.2发布，全球首个K8S原生的边缘计算平台开放云端代码

    KubeEdge开源背景 KubeEdge在18年11月24日的上海KubeCon上宣布开源,技术圈曾掀起一阵讨论边缘计算的风潮,从此翻开了边缘计算和云计算联动的新篇章. KubeEdge即Kube+ ...

  10. IE浏览器版本判断 HTML代码

    <!--[if IE 6.0]> <div id="noie6" style="z-index: 20002;border: 1px solid #F7 ...

随机推荐

  1. Vue第三方库与插件实战手册

    title: Vue第三方库与插件实战手册 date: 2024/6/8 updated: 2024/6/8 excerpt: 这篇文章介绍了如何在Vue框架中实现数据的高效验证与处理,以及如何集成E ...

  2. # android studio启动虚拟机长时间无响应，无法启动

    问题 虚拟设备长时间不响应,无法启动设备 方案 根据 android studio启动虚拟器失败 尝试删除锁文件 失败,.android 目录下不存在锁文件 电脑内存或计算配置不足 查看了模拟器需要的 ...

  3. H5弹窗底层滑动

    H5弹窗底层滑动 背景 产品提出H5 弹出窗滑动时,底层页面也会跟随滑动,需要调整禁止底层滑动,增加用户体验. 问题产生原因 ios 滑动时有回弹效果 顶层元素滑动默认行为 解决办法 阻止元素的默认( ...

  4. MATLAB神经网络工具箱使用介绍

      本文介绍MATLAB软件中神经网络拟合(Neural Net Fitting)工具箱的具体使用方法.   在MATLAB人工神经网络ANN代码这篇文章中,我们介绍了MATLAB软件中神经网络(AN ...

  5. apisix~14在自定义插件中调用proxy_rewrite

    在 Apache APISIX 中,通过 proxy-rewrite 插件来修改上游配置时,需要确保插件的执行顺序和上下文环境正确.你提到在自己的插件中调用 proxy_rewrite.rewrite ...

  6. TRL(Transformer Reinforcement Learning) PPO Trainer 学习笔记

    (1)  PPO Trainer TRL支持PPO Trainer通过RL训练语言模型上的任何奖励信号.奖励信号可以来自手工制作的规则.指标或使用奖励模型的偏好数据.要获得完整的示例,请查看examp ...

  7. .NET周刊【6月第4期 2024-06-23】

    国内文章 C#.Net筑基-集合知识全解 https://www.cnblogs.com/anding/p/18229596 .Net中提供了数组.列表.字典等多种集合类型,分为泛型和非泛型集合.泛型 ...

  8. ubuntu16 安装 python-networkmanager 失败

    前言 ubuntu16 安装 python-networkmanager 失败 解决方案 sudo apt-get install libdbus-1-dev sudo apt-get install ...

  9. SpringCloud学习篇

    什么是SpringCloud Spring cloud 流应用程序启动器是基于 Spring Boot 的 Spring 集成应用程序,提供与外部系统的集成.Spring cloud Task,一个生 ...

  10. 什么是JS执行上下文?

    我们都知道,JS代码的执行顺序总是与代码先后顺序有所差异,当先抛开异步问题你会发现就算是同步代码,它的执行也与你的预期不一致,比如: function f1() { console.log('听风是风 ...