精华内容
下载资源
问答
  • 动态代理与静态代理之略见

    热门讨论 2014-08-13 14:44:13
    最近一直在学习和讨论设计模式,同时也是在讨论一套学习的模式.对于如何学习,你肯定回想,...那么如何学习呢,学习要从生活中来,在回归到生活中.整个学习的过程中,为什么要贯穿整个学习的过程,为什么有学习这个,学习这个的

         最近一直在学习和讨论设计模式,同时也是在讨论如何学习,才能让加速度达到最大.对于如何学习,你肯定会说,我从小学就开始学习了,到大学毕业都学习了几十年了,难倒我还不会学习吗.其实想想,你真的会学习吗.读完大学,接受的一直都是应试教育,填鸭式的学习.老师给什么学什么,学不会还怪老师教的不好.

         那么如何学习呢,学习要从生活中来,在回归到生活中.整个学习的过程中,为什么要贯穿整个学习的过程,为什么有学习这个,学习这个的好处是什么,学习这个内容能解决什么问题.

         在这次讨论设计模式,我对代理模式情有独钟.其中代理模式分为静态代理和动态代理.

    1.静态代理

    1.1概念

    所谓的静态代理就是指程序员创建好代理类,编译时直接生产代理类的字节码文件.

    1.2类

    1.3 birdTimeProxy类代码

    public class BirdTimeProxy implements  Flyeable{
    	
    	 public BirdTimeProxy(Flyeable f) {
    	        super();
    	        this.f = f;
    	    }
    	 Flyeable f;
    	
    	@Override
    	public void fly() {
    		f.fly();
    		
    	}
    	
    }
    

    1.4客户端代码

    public static void main(String[] args) throws Exception  {
    	Bird f=new Bird();
    	BirdTimeProxy fyb=new BirdTimeProxy(f);
    	
    	Flyeable fly=fyb;
    	fly.fly();
    }
    

    2.动态代理

    2.1概念

         所谓的动态代理就是在程序运行时,通过反射机制动态生产代理类.动态代理可以提供对另一个对象的访问,同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象,但是延迟实现实际对象的部分功能,实际对象实现系统的实际功能,代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。

     

    2.2为什么使用

         可以对请求进行任何处理

     

    2.3 类图

    2.4dynamicproxy代理类:

    /**
     * 实现在方法调用前后控制台输出
     * @author wanwan
     *
     */
    public class dynamicProxy implements InvocationHandler {
    	//要代理的原始对象
    	private Object obj;
    	
    	public dynamicProxy(Object obj){
    		super();
    		this.obj=obj;
    	}
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		Object result=null;
    		//调用之前
    		doBefore();
    		//调用原始对象的方法
    		result=method.invoke(obj, args);
    		//调用之后
    		doAfter();
    		return result;
    	}
    	private void doAfter() {
    		System.out.print("after method invoke");
    		
    	}
    	private void doBefore() {
    		System.out.print("before method invoke");
    		
    	}
    
    }
    

    2.4 客户端代码

    public static void main(String[] args) {
    		Flyeable fly=new Bird();
    		InvocationHandler  handler=new dynamicProxy(fly);
    		
    		//创建动态代理对象
    		Flyeable proxy=(Flyeable) Proxy.newProxyInstance(
    				fly.getClass().getClassLoader(), fly.getClass().getInterfaces(), handler);
    		proxy.fly();
    		
    	}
    

    3.多个对象需要代理时....

         代理一个对象的时候,而代理的对象不变的话,使用静态代理或者使用动态代理,都没有多大的区别,那么如果需要代理的对象经常性的发生变化或者需要代理多个对象的时候.静态代理会出现什么情况呢.先用静态代理处理看看:

    第一步:写一个接口和接口的实现.最后一步不管是在动态代理还是在静态代理中,这个类就是必须存在的.在这里,我们增加一个Moveanble接口和Tank实现类.

    第二步:写一个代理TankTimeProxy.代码如下:

    public class TankTimeProxy implements Moveable {
        public TankTimeProxy(Moveable t) {
            super();
            this.t = t;
        }
        Moveable t;
    @Override
    public void move(){
            t.move();
    	}
    }
    

    第三步:修改客户端代码,具体修改代码如下:

    Tank t=new Tank();
    TankTimeProxy ttp=new TankTimeProxy(t);
    Moveable moveable=ttp;
    moveable.move();
    
    代理两个对象的UML图如下所示:

    从图中我们可以看出,每增加一个真实对象,都会相对应的增加一个代理类.


         若使用动态代理,就不用这么麻烦了.代理类不用进行修改,只需要在添加接口和接口实现类后,直接修改客户端代码就可以了.客户端修改后的代码如下:

    Moveable mv=new Tank();
    InvocationHandler  handler1=new dynamicProxy(mv);
    		
    //创建动态代理对象
    Moveable proxy1=(Moveable) Proxy.newProxyInstance(
    				mv.getClass().getClassLoader(), mv.getClass().getInterfaces(), handler1);
    proxy1.move();
    


    对应的UML图如下:

    4.总结

         从整体的代码来看,似乎静态代理要简单很多,一旦代理对象发生了改变或增加,就要从新添加代理类.若对象变化比较大的话,添加的代理类会增多,会造成代理类泛滥,难以管理.如果使用动态代理,只需要以一个代理就可以解决了,动态代理中的代理类把静态代理中的真实对象和代理类之间的耦合给解开了.降低了耦合度.所以,在真实对象容易发生改变或者是真是对象比较多的时候,往往会考虑使用动态代理了.




    展开全文
  • 近日,有部分空间计量爱好者...与静态空间杜宾模型的回归程序相比,动态空间杜宾模型的程序仅仅多了一个dlag(n)。如果n为1,则表示被解释变量(y)滞后一期;如果为2,则表示被解释变量(y)滞后二期。以此类推。动态空...

    近日,有部分空间计量爱好者提出让ASE推送动态空间面板数据模型的Stata回归程序的建议。针对上述建议,并结合以往ASE推送文章缺乏此方面内容的实际,ASE决定推送动态空间杜宾模型的Stata回归程序。

    与静态空间杜宾模型的回归程序相比,动态空间杜宾模型的程序仅仅多了一个dlag(n)。如果n为1,则表示被解释变量(y)滞后一期;如果为2,则表示被解释变量(y)滞后二期。以此类推。动态空间杜宾模型的Stata回归程序如下:

    xsmle y x1 x2 x3 x4 x5 x6 x7, fe wmat(idisswm) dlag model(sdm)  nolog

    其中 ,y代表被解释变量,x1代表核心解释变量,x2至x7代表控制变量;fe表示使用的是固定效应模型,wmat()代表空间权重矩阵的类型,dlag表示被解释变量(y)在时间上滞后一期,nolog代表不显示迭代过程。

    参考文献:

    孙攀,吴玉鸣,鲍曙明,仲颖佳.经济增长与雾霾污染治理:空间环境库兹涅茨曲线检验[J].南方经济,2019(12):100-117.

    8a05f57aa3d4e30057de269bb8694fdd.pngFocuses on the setting and application of spatial econometric models, and commits to promote the development of Spatial Econometrics in China.

    展开全文
  • -基于DEA模型Tobit回归的证据 ,蔡自豪,尹居良,为探究影响经济增长效率的因素,本文利用2000-2013年环渤海地区及长三角地区的宏观经济数据,采用DEA模型,从静态动态角度对异质性
  • 软件构造知识点总结(一)静态检查测试 文章目录软件构造知识点总结(一)静态检查测试1.自动检查1.1静态检查1.2动态检查2.静态类型、动态类型3.测试3.1为什么软件测试很困难?3.2测试优先编程3.3通过等价类划分...

    软件构造知识点总结(一)静态检查与测试

    1.自动检查

    编程语言通常能提供以下三种自动检查的方法:

    • 静态检查: bug在程序运行前发现

    • 动态检查: bug在程序运行中发现

    • 无检查: 编程语言本身不帮助你发现错误,你必须通过特定的条件(例如输出的结果)检查代码的正确性。

    很明显,静态检查好于动态检查好于不检查。

    1.1静态检查

    一般可以发现如下错误:

    • 语法错误,例如多余的标点符号或者错误的关键词。(动态类型的语言例如Python中也会做这种检查:如果你有一个多余的缩进,在运行之前就能发现它)。

    • 错误的名字,例如函数名称、类名等拼写错误。

    • 参数的个数不对

    • 参数的类型不对

    • 错误的返回类型

    1.2动态检查

    • 非法的变量值,例如位于分母变量为0。
    • 无法表示的返回值。例如最后得到的返回值无法用声明的类型来表示。
    • 越界访问。例如在一个字符串中使用一个负数索引。
    • 引用一个null对象

    静态检查倾向于类型错误 ,即与特定的值无关的错误。正如上面提到过的,一个类型是一系列值的集合,而静态类型就是保证变量的值在这个集合中,但是在运行前我们可能不会知道这个值的结果到底是多少。所以如果一个错误必须要特定的值来“触发”(例如除零错误和越界访问),编译器是不会在编译的时候报错的。与此相对的,动态类型检查倾向于特定值才会触发的错误。

    2.静态类型、动态类型

    Java是一种静态类型的语言。所有变量的类型在编译的时候就已经知道了(程序还没有运行),所以编译器也可以推测出每一个表达式的类型。

    动态类型语言中(例如Python),这种类型检查是发生在程序运行的时候

    静态类型是静态检查的一种(检查发生在编译的时候)

    3.测试

    3.1为什么软件测试很困难?

    • 全部测试(尝试所有的可能):这通常是不可行的,因为大多数情况下输入空间会非常大
    • 随机测试 : 这通常难以发现bug,除非这个程序到处都是bug以至于随便一个输入都能崩溃。即使我们修复了测试出来的bug,随机的输入也不能使我们对程序的正确性很确定。
    • 基于统计方法的测试:遗憾的是,这种方法对软件不那么奏效。在物理系统里,工程师可以通过特定的方法加速实验的进程,例如在一天的时间里打开关闭一个冰箱门一千次,以此来模拟几年的正常使用,最终得到产品的”失败率“。以后的测试结果也将会集中分布在这个比率左右,工程师们就对这个比率进行进一步的研究。但是软件的行为通常是离散且不可预测的。程序可能在上一秒还完全正常的工作,突然就崩溃了,也可能对于大多数输入都没问题,对于一个值就崩溃了。

    3.2测试优先编程

    在测试优先编程中,测试程序先于代码完成。编写一个函数应该按如下步骤进行:

    1. 为函数写一个规格说明。
    2. 为上一步的规格说明写一些测试用例。
    3. 编写实际代码。一旦你的代码通过了所有你写的测试用例,这个函数就算完成了。

    规格说明描述了这个函数的输入输出行为。它确定了函数参数的类型和对它们的所有约束(例如sqrt函数的参数必须是非负的)。它还定义了函数的返回值类型以及返回值和输入之间的关系。

    先完成测试用例的编写能够让你更好地理解规格说明。规格说明也可能存在问题:不正确、不完整、模棱两可、缺失边界情况。先尝试编写测试用例,可以在你浪费时间实现一个有问题的规格说明之前发现这些问题。

    3.3通过等价类划分的方法选择测试用例

    选择合适的测试用例是一个具有挑战性但是有缺的问题。我们即希望测试空间足够小,以便能够快速完成测试,又希望测试用例能够验证尽可能多的情况。

    为了达到这个目的,我们可以依据等价关系先将输入空间划分为几个等价类 ,每一个等价类 都是一类相似的数据。我们在每个子域中选取一些数据,它们合并起来就是我们需要的输入用例。

    举个简单的例子:

    public int mutiply(int a,int b)
    {
        return a*b;
    }
    

    对于这个函数,输入的参数有两个,一般可以考虑如下划分:

    • a和b都是正整数
    • a和b都是负整数
    • a是正整数,b是负整数
    • b是正整数,a是负整数

    这里也有一些特殊的情况要单独分出来:0 1 -1

    • a或b是1,0,-1
    • a或b较小
    • a或b的绝对值大于Long.MAX_VALUE

    所以我们一共可以得到 7 × 7 = 49 个分区,它们完全覆盖了a和b组成的所有输入空间:

    在这里插入图片描述

    依据划分的等价类,一般测试用例的选取有两种方案:

    • 完全笛卡尔乘积
      即对每一个存在组合都进行测试。例如上例,我们可以选取 7 × 7 = 49 个测试用例,每一个组合都用上了。
    • 每一个分区被覆盖即可
      因为一些测试用例可能覆盖了好几类等价类,所以该方法只要求每一个分区至少被覆盖一次

    3.4注意等价类之间的“边界”

    bug经常会在各个等价类的边界处发生,例如:

    • 在正整数和负整数之间的0
    • 数字类型的最大值和最小值,例如 intdouble
    • 空集,例如空的字符串,空的列表,空的数组
    • 集合类型中的第一个元素或最后一个元素

    所以,我们在划分完毕后后,测试用例不要忘了加上边界上的值。

    4.黑盒测试与白盒测试

    黑盒测试意味着只依据函数的规格说明来选择测试用例,而不关心函数是如何实现的。

    白盒测试 的意思是在考虑函数的实际实现方法的前提下选择测试用例。比如说,如果函数的实现中,对不同的输入采用不同的算法,那么你应该根据这些不同的区域来分类。

    在做白盒测试时。你必须注意:你的测试用例不需要尝试规格说明中没有明确要求的实现行为。例如,如果规格说明中说“如果输入没有格式化,那么将抛出异常”,那么你不应该特地的检查程序是否抛出NullPointerExpection异常,因为当前的代码实现决定了程序有可能抛出这个异常。在这种情况下,规格说明允许任何异常被抛出,所以你的测试用例同样应该“宽容”地保留实现者的自由。

    5.测试覆盖率

    一种判断测试的好坏的方法就是看该测试对软件的测试程度。这种测试程度也称为“覆盖率”。以下是常见的三种覆盖率:

    • 声明覆盖率: 每一个声明都被测试到了吗?
    • 分支覆盖率:对于每一个ifwhile 等等控制操作,它们的分支都被测试过吗?
    • 路径覆盖率: 每一种分支的组合路径都被测试过吗?

    其中,分支覆盖率要比声明覆盖率严格(需要更多的测试),路径覆盖率要比分支覆盖率严格。在工业界,100%的声明覆盖率一个普遍的要求,但是这有时也是不可能实现的,因为会存在一些“不可能到达的代码”(例如有一些断言)。100%的分支覆盖率是一种很高的要求,对于军工/安全关键的软件可能会有此要求。不幸的是,100%的路径覆盖率是不可能的,因为这会让测试用例空间以指数速度增长。

    一个标准的方法就是不断地增加测试用例直到覆盖率达到了预定的要求。在实践中,声明覆盖通常用覆盖率工具进行计数。利用这样的工具,白盒测试会变得很容易,你只需要不断地调整覆盖的地方,直到所有重要的声明都被覆盖到。

    6.单元测试、回归测试、集成测试

    6.1单元测试

    对孤立的模块进行测试。这使得debugging变得简单,当一个单元测试报错是,我们只需要在这个单元找bug,而不是在整个程序去找

    6.2集成测试

    与单元测试相对应的,集成测试是对于组合起来的模块进行测试,甚至是整个程序。如果集成测试报错,我们就只能在大的范围去找了。但是这种测试依然是必要的,因为程序经常由于模块之间的交互而产生bug。例如,一个模块的输入是另一个模块的输出,但是设计者在设计模块的时候将输入输出类型弄错了。另外,如果我们已经做好单元测试了,即我们可以确性各个单元独立的正确性,我们的搜索bug的范围也会小很多。

    6.3回归测试

    我们称修改代码带来新的bug的现象为“回归”,而在修改后重新运行所有的测试称为“回归测试”。

    一个好的测试应该是能发现bug的,你应该不断的充实你的测试用例。所以无论什么时候修改了一个bug,记得将导致bug的输入添加到你的测试用例里,并在以后的回归测试中去使用它——毕竟这个bug已经出现了,说明它可能是一个很容易犯的错误。

    展开全文
  • 本节第二部分介绍pytorch最大的特性——动态图机制,动态图机制是pytorch与tensorflow最大的区别,该部分首先介绍计算图的概念,并通过演示动态与静态图的搭建过程来理解动态与静态图的差异。 1. 张量的操作:...

    目录

    一、张量的操作

    1. 拼接、切分

    1.1 torch.cat()

    1.2 torch.stack()

    1.3 torch.chunk()

    1.4 torch.split()

    2. 索引

    2.1 torch.index_select()

    2.2 torch.make_select()

    3. 变换

    3.1 torch.reshape()

    3.2 torch.transpose()和torch.t()

    3.3 torch.squeeze()和torch.unsqueeze()

    二、张量数学运算

    1. 加法运算torch.add()

    三、线性回归


    任务简介

    学习张量的基本操作与线性回归模型的实现。

    详细说明

    本节介绍张量的基本操作,如张量拼接切分、索引和变换,同时学习张量的数学运算,并基于所学习的知识,实现线性回归模型的训练,以加深知识点的认识。

    一、张量的操作

    1. 拼接、切分

    1.1 torch.cat()

     测试代码

    # ======================================= example 1 =======================================
    # torch.cat
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.ones((2, 3))
    
        t_0 = torch.cat([t, t], dim=0)
        t_1 = torch.cat([t, t, t], dim=1)
    
        print("t_0:{} shape:{}\nt_1:{} shape:{}".format(t_0, t_0.shape, t_1, t_1.shape))
    

    输出

    t_0:tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]]) shape:torch.Size([4, 3])
    t_1:tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
            [1., 1., 1., 1., 1., 1., 1., 1., 1.]]) shape:torch.Size([2, 9])
    

    1.2 torch.stack()

    测试代码

    # ======================================= example 2 =======================================
    # torch.stack
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.ones((2, 3))
    
        t_stack = torch.stack([t, t, t], dim=0) # 如果第0维有数据则原来第0、1...维的向后顺延一位
    
        print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))
    
    

    输出

    t_stack:tensor([[[1., 1., 1.],
             [1., 1., 1.]],
    
            [[1., 1., 1.],
             [1., 1., 1.]],
    
            [[1., 1., 1.],
             [1., 1., 1.]]]) shape:torch.Size([3, 2, 3])
    

    1.3 torch.chunk()

    测试代码 

    # ======================================= example 3 =======================================
    # torch.chunk
    
    flag = True
    #flag = False
    
    if flag:
        a = torch.ones((2, 7))  # 7
        list_of_tensors = torch.chunk(a, dim=1, chunks=3)   # 3
    
        for idx, t in enumerate(list_of_tensors):
            print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
    

     输出

    第1个张量:tensor([[1., 1., 1.],
            [1., 1., 1.]]), shape is torch.Size([2, 3])
    第2个张量:tensor([[1., 1., 1.],
            [1., 1., 1.]]), shape is torch.Size([2, 3])
    第3个张量:tensor([[1.],
            [1.]]), shape is torch.Size([2, 1])
    

    1.4 torch.split()

    list元素的和必须等于指定维度上张量的长度。 

    测试代码 

    # ======================================= example 4 =======================================
    # torch.split
    
    # flag = True
    flag = True
    
    if flag:
        t = torch.ones((2, 5))
        t1 = torch.ones((2, 5))
        list_of_tensors = torch.split(t, 2, dim=1)  # [2 , 1, 2]
        for idx, t in enumerate(list_of_tensors):
            print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
    
        list_of_tensors = torch.split(t1, [2, 1, 2], dim=1)
        for idx, t in enumerate(list_of_tensors):
            print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
    

    输出

    第1个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    第2个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    第3个张量:tensor([[1.],
            [1.]]), shape is torch.Size([2, 1])
    
    
    第1个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    第2个张量:tensor([[1.],
            [1.]]), shape is torch.Size([2, 1])
    第3个张量:tensor([[1., 1.],
            [1., 1.]]), shape is torch.Size([2, 2])
    

    2. 索引

    2.1 torch.index_select()

    测试代码 

    # ======================================= example 5 =======================================
    # torch.index_select
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.randint(0, 9, size=(3, 3))
        idx = torch.tensor([0, 2], dtype=torch.long)    # float
        t_select = torch.index_select(t, dim=0, index=idx)
        print("t:\n{}\nt_select:\n{}".format(t, t_select))
    

    输出

    t:
    tensor([[4, 5, 0],
            [5, 7, 1],
            [2, 5, 8]])
    t_select:
    tensor([[4, 5, 0],
            [2, 5, 8]])
    

    2.2 torch.make_select()

    测试代码

    # ======================================= example 6 =======================================
    # torch.masked_select
    
    flag = True
    #flag = False
    
    if flag:
    
        t = torch.randint(0, 9, size=(3, 3))
        mask = t.le(5)  # ge is mean greater than or equal/   gt: greater than  le  lt
        t_select = torch.masked_select(t, mask)
        print("t:\n{}\nmask:\n{}\nt_select:\n{} ".format(t, mask, t_select))
    

     输出

    t:
    tensor([[4, 5, 0],
            [5, 7, 1],
            [2, 5, 8]])
    mask:
    tensor([[ True,  True,  True],
            [ True, False,  True],
            [ True,  True, False]])
    t_select:
    tensor([4, 5, 0, 5, 1, 2, 5]) 
    

    3. 变换

    3.1 torch.reshape()

     测试代码

    # ======================================= example 7 =======================================
    # torch.reshape
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.randperm(8)
        t_reshape = torch.reshape(t, (-1, 2, 2))    # -1代表第0维度数值为8/2/2=2
        print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
    
        t[0] = 1024
        print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
        print("t.data 内存地址:{}".format(id(t.data)))
        print("t_reshape.data 内存地址:{}".format(id(t_reshape.data)))
    

    输出

    t:tensor([5, 4, 2, 6, 7, 3, 1, 0])
    t_reshape:
    tensor([[[5, 4],
             [2, 6]],
    
            [[7, 3],
             [1, 0]]])
    t:tensor([1024,    4,    2,    6,    7,    3,    1,    0])
    t_reshape:
    tensor([[[1024,    4],
             [   2,    6]],
    
            [[   7,    3],
             [   1,    0]]])
    t.data 内存地址:1169043563128
    t_reshape.data 内存地址:1169043563128
    

    3.2 torch.transpose()和torch.t()

    测试代码

    # ======================================= example 8 =======================================
    # torch.transpose
    
    flag = True
    #flag = False
    
    if flag:
        # torch.transpose
        t = torch.rand((2, 3, 4))
        t_transpose = torch.transpose(t, dim0=1, dim1=2)    # c*h*w     h*w*c
        print("t shape:{}\nt_transpose shape: {}".format(t.shape, t_transpose.shape))
    

    输出

    t shape:torch.Size([2, 3, 4])
    t_transpose shape: torch.Size([2, 4, 3])
    

    3.3 torch.squeeze()和torch.unsqueeze()

    测试代码

    # ======================================= example 9 =======================================
    # torch.squeeze
    
    flag = True
    #flag = False
    
    if flag:
        t = torch.rand((1, 2, 3, 1))
        t_sq = torch.squeeze(t)
        t_0 = torch.squeeze(t, dim=0)
        t_1 = torch.squeeze(t, dim=1)
        print(t.shape)
        print(t_sq.shape)
        print(t_0.shape)
        print(t_1.shape)
    

     输出

    torch.Size([1, 2, 3, 1])
    torch.Size([2, 3])
    torch.Size([2, 3, 1])
    torch.Size([1, 2, 3, 1])
    

    二、张量数学运算

    1. 加法运算torch.add()

    测试代码

    # ======================================= example 8 =======================================
    # torch.add
    
    flag = True
    #flag = False
    
    if flag:
        t_0 = torch.randn((3, 3))
        t_1 = torch.ones_like(t_0)
        t_add = torch.add(t_0, 10, t_1)
    
        print("t_0:\n{}\nt_1:\n{}\nt_add_10:\n{}".format(t_0, t_1, t_add))
    

     输出

    t_0:
    tensor([[ 0.6614,  0.2669,  0.0617],
            [ 0.6213, -0.4519, -0.1661],
            [-1.5228,  0.3817, -1.0276]])
    t_1:
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])
    t_add_10:
    tensor([[10.6614, 10.2669, 10.0617],
            [10.6213,  9.5481,  9.8339],
            [ 8.4772, 10.3817,  8.9724]])
    

    三、线性回归

    测试代码

    import torch
    import matplotlib.pyplot as plt
    torch.manual_seed(10)
    
    lr = 0.05  # 学习率    20191015修改
    
    # 创建训练数据
    x = torch.rand(20, 1) * 10  # x data (tensor), shape=(20, 1)
    y = 2*x + (5 + torch.randn(20, 1))  # y data (tensor), shape=(20, 1)
    
    # 构建线性回归参数
    w = torch.randn((1), requires_grad=True)
    b = torch.zeros((1), requires_grad=True)
    
    for iteration in range(1000):
    
        # 前向传播
        wx = torch.mul(w, x)
        y_pred = torch.add(wx, b)
    
        # 计算 MSE loss
        loss = (0.5 * (y - y_pred) ** 2).mean()
    
        # 反向传播
        loss.backward()
    
        # 更新参数
        b.data.sub_(lr * b.grad)
        w.data.sub_(lr * w.grad)
    
        # 清零张量的梯度  
        w.grad.zero_()
        b.grad.zero_()
    
        # 绘图
        if iteration % 20 == 0:
    
            plt.scatter(x.data.numpy(), y.data.numpy())
            plt.plot(x.data.numpy(), y_pred.data.numpy(), 'r-', lw=5)
            plt.text(2, 20, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
            plt.xlim(1.5, 10)
            plt.ylim(8, 28)
            plt.title("Iteration: {}\nw: {} b: {}".format(iteration, w.data.numpy(), b.data.numpy()))
            plt.pause(0.5)
    
            if loss.data.numpy() < 1:
                break
    

     输出

    当迭代100次时,损失值小于1

    展开全文
  • 本节第二部分介绍pytorch最大的特性——动态图机制,动态图机制是pytorch与tensorflow最大的区别,该部分首先介绍计算图的概念,并通过演示动态与静态图的搭建过程来理解动态与静态图的差异。 ...
  • 这次主要是来分析一下动态代理的作用实现原理。既然都已经分析了原理,最后自然也要动手仿照Retrofit来简单实现一个Demo。 通过最后的Demo实现,相信动态代理你也基本没什么问题了。 静态代理 既然说到动态代理,...
  • 来源:本文授权转载自数量经济学转载请联系本文包括静态与动态面板数据处理方法,包含hausman检验,固定效应检验,随机效应检验,异方差检验、相关检验,面板logit面板probit模型、面板泊松模型、面板负二项模型等...
  • 利率市场化进程中我国货币政策传导的实际利率渠道--1998~2006阶段的协整与动态检验,岳意定,程安亭,本文运用基于向量自回归(VAR)的静态协整和动态检验方法,采用中国1998年1月至2006年6月的月度数据,实证检验...
  • 本文从WebKing页面的静态分析出发,讨论了利用WebKing对支持Ajax的动态页面进行测试的方法,并且本文从单元测试和功能测试的角度介绍了使用WebKing测试Accessibilily的技巧,包括如何创建一个支持Ajax的测试项目,...
  • 通过实时动态构建的自回归滑动平均(ARMA)模型,利用过去瓦斯浓度变化趋势预测未来一段时间的矿井瓦斯浓度值,得到时间序列预测结果;为提高瓦斯浓度预测精度,将ARMA模型的预测结果矿井环境参数输入到训练好的BP神经...
  • WebKing 简介 WebKing 是 Parasoft 公司推出的一款 Web 自动化测试软件,可以使用... Webking 支持本地文件的检查测试和创建项目检查测试网站内容,包括静态动态和 Ajax 测试。尤其对于动态的 Web 应用
  • 误差理论数据处理

    2017-09-14 14:59:36
    本书论述了科学实验和工程实践中常用的静态测量和动态测量的误差理论和数据处理,并重点结合几何量、机械量和相关物理量测量进行介绍,内容包括:绪论、误差的基本性质处理、误差的合成分配、测量不确定度、线性...
  • 本书论述了科学实验和工程实践中常用的静态测量和动态测量的误差理论和数据处理,并重点结合几何量、机械量和相关物理量测量进行介绍,内容包括:绪论、误差的基本性质处理、误差的合成分配、测量不确定度、线性...
  • 第13章 软件测试方法过程本章目标 掌握等价类划分法熟悉黑盒测试的其他方法掌握逻辑覆盖法熟悉白盒测试的其他方法掌握软件测试的一般步骤以及每个阶段性测试的关注点了解回归测试和面向对象测试熟悉软件调试掌握...
  • 工业集聚企业环境技术创新:来自中国城市级数据的经验证据,谢里,陈辉,采用2003-2015年中国内地270个城市的面板数据,运用随机效应模型对全国的样本做了基础回归,然后分别从静态动态的角度,采用两阶段
  • 它可以用于测试静态动态资源例如静态文件、Java 小服务程序、CGI 脚本、Java 对象、数据库、FTP 服务器等等。JMeter可以用于对服务器、网络或对象模拟巨大的负载,来在不同压力类别下测试它们的强度和分析整体性能...
  • 课件 关于单元测试 单元测试多采用白盒测试技术 静态审查代码 动态单元测试 课件 单元测试的意义 好的单元测试将会在产品开发的阶段发现大部分的缺陷并且修改它们的成本也很低 在软件开发的后期阶段缺陷的发现并修改...
  • 菜鸟学Java——如何更好的进行单元测试——JUnit

    万次阅读 多人点赞 2014-06-18 21:23:32
    软件测试有很多分类,从测试的方法上可分为:黑盒测试、白盒测试、静态测试、动态测试等;从软件开发的过程分为:单元测试、集成测试、确认测试、验收、回归等。   在众多的分类中,开发人员关系最紧密的莫过于...
  • 自我中心网或整体网这三个层面的静态特征对关键研发者创造力的作用机制,缺乏对类似于网络切割点这样同时包含三个层面网络特征的动态性考察.鉴于此,本文基于国内46家企业1995-2010年的专利数据,利用负二项回归模型...
  • 请简述什么上提到的这些软件测试法如什么是回归测试 静态测试是不运程序本身寻找程序代码中可能存在的错误或评估程序代码的 过程 动态测试是实际运被测程序输相应的测试实例检查运结果预期结果 的差异判定执结果...
  • §3.2 完全信息静态博弈纳什均衡…………………………………………………63 §3.3 完全信息动态博弈子博弈精炼纳什均衡……………………………………66 §3.4 不完全信息静态博弈贝叶斯纳什均衡…………...
  • 软件测试复习大纲

    千次阅读 多人点赞 2018-12-26 21:59:37
    文章目录概述计算机系统的软件可靠性问题软件质量软件可靠性度量软件故障定义错误...与动态测试静态测试动态测试回归测试$\alpha$测试$\beta$测试测试调试测试生命周期测试工具测试评估软件质量评估软件过程成熟...
  • 任务简介: pytorch提供了大量的transforms预处理...本节第二部分介绍pytorch最大的特性——动态图机制,动态图机制是pytorch与tensorflow最大的区别,该部分首先介绍计算图的概念,并通过演示动态与静态图的搭建
  • 任务简介: pytorch提供了大量的transforms预处理...本节第二部分介绍pytorch最大的特性——动态图机制,动态图机制是pytorch与tensorflow最大的区别,该部分首先介绍计算图的概念,并通过演示动态与静态图的搭建
  • 二软件测试的分类 4按测试执行方式分 静态测试 不执行程序而是利用人工手段及静态测试工具完成对程序的静态测试目的是检查软件的表示描述是否一致没有冲突和歧义 动态测试 实际运行测试用例以发现软件中的错误全部...
  • 测试的分类

    2018-10-15 20:47:32
    -静态测试、动态测试 -功能测试、性能测试 -回归测试、冒泡测试、随机测试 -单元测试、集成测试、系统测试、验收测试 白盒黑盒测试 黑盒测试又叫功能测试、数据驱动测试或给予需求规格说明 ...
  • 测试基本流程总结

    2019-10-14 08:39:33
    1、多个测试的基本概念:黑盒测试,白盒测试,冒烟测试,回归测试,静态测试,动态测试等 黑盒测试:又称功能测试,以数据为驱动,注重测试软件的功能 白盒测试:又称结构测试、以逻辑为驱动,基于程序本身的测试 ...
  • 教件测试分类 e黑盒和白盒测试 静态测试和...n静态测试 动态测试 基于测试的不同阶段 单元测试 集成测试 系统测试 验收测试 软件测试的内容 e回归测试 功能测试 负载测试 e压力测试 性能测试 易用性测试 安装反安装测
  • 二软件测试的分类 4按测试执行方式分 静态测试 不执行程序而是利用人工手段及静态测试工具完成对程序的静态测试目的是检查软件的表示描述是否一致没有冲突和歧义 动态测试 实际运行测试用例以发现软件中的错误全部...

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

动态回归与静态回归