最近一直在学习和讨论设计模式,同时也是在讨论如何学习,才能让加速度达到最大.对于如何学习,你肯定会说,我从小学就开始学习了,到大学毕业都学习了几十年了,难倒我还不会学习吗.其实想想,你真的会学习吗.读完大学,接受的一直都是应试教育,填鸭式的学习.老师给什么学什么,学不会还怪老师教的不好.
     那么如何学习呢,学习要从生活中来,在回归到生活中.整个学习的过程中,为什么要贯穿整个学习的过程,为什么有学习这个,学习这个的好处是什么,学习这个内容能解决什么问题.
     在这次讨论设计模式,我对代理模式情有独钟.其中代理模式分为静态代理和动态代理.

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.总结

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

	

近日，有部分空间计量爱好者提出让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.
Focuses on the setting and application of spatial econometric models, and commits to promote the development of Spatial Econometrics in China. 
	

软件构造知识点总结（一）静态检查与测试
文章目录
软件构造知识点总结（一）静态检查与测试
1.自动检查
1.1静态检查
1.2动态检查
2.静态类型、动态类型
3.测试
3.1为什么软件测试很困难？
3.2测试优先编程
3.3通过等价类划分的方法选择测试用例
3.4注意等价类之间的“边界”
4.黑盒测试与白盒测试
5.测试覆盖率
6.单元测试、回归测试、集成测试
6.1单元测试
6.2集成测试
6.3回归测试

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


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


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


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


很明显，静态检查好于动态检查好于不检查。
1.1静态检查
一般可以发现如下错误：


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


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


参数的个数不对


参数的类型不对


错误的返回类型


1.2动态检查

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

静态检查倾向于类型错误 ，即与特定的值无关的错误。正如上面提到过的，一个类型是一系列值的集合，而静态类型就是保证变量的值在这个集合中，但是在运行前我们可能不会知道这个值的结果到底是多少。所以如果一个错误必须要特定的值来“触发”（例如除零错误和越界访问），编译器是不会在编译的时候报错的。与此相对的，动态类型检查倾向于特定值才会触发的错误。
2.静态类型、动态类型
Java是一种静态类型的语言。所有变量的类型在编译的时候就已经知道了（程序还没有运行），所以编译器也可以推测出每一个表达式的类型。
在动态类型语言中（例如Python），这种类型检查是发生在程序运行的时候。
静态类型是静态检查的一种（检查发生在编译的时候）
3.测试
3.1为什么软件测试很困难？

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

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

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

规格说明描述了这个函数的输入输出行为。它确定了函数参数的类型和对它们的所有约束（例如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
数字类型的最大值和最小值，例如 int 和 double
空集，例如空的字符串，空的列表，空的数组
集合类型中的第一个元素或最后一个元素

所以，我们在划分完毕后后，测试用例不要忘了加上边界上的值。
4.黑盒测试与白盒测试
黑盒测试意味着只依据函数的规格说明来选择测试用例，而不关心函数是如何实现的。
白盒测试 的意思是在考虑函数的实际实现方法的前提下选择测试用例。比如说，如果函数的实现中，对不同的输入采用不同的算法，那么你应该根据这些不同的区域来分类。
在做白盒测试时。你必须注意：你的测试用例不需要尝试规格说明中没有明确要求的实现行为。例如，如果规格说明中说“如果输入没有格式化，那么将抛出异常”，那么你不应该特地的检查程序是否抛出NullPointerExpection异常，因为当前的代码实现决定了程序有可能抛出这个异常。在这种情况下，规格说明允许任何异常被抛出，所以你的测试用例同样应该“宽容”地保留实现者的自由。
5.测试覆盖率
一种判断测试的好坏的方法就是看该测试对软件的测试程度。这种测试程度也称为“覆盖率”。以下是常见的三种覆盖率：

声明覆盖率: 每一个声明都被测试到了吗？
分支覆盖率:对于每一个if 或 while 等等控制操作，它们的分支都被测试过吗？
路径覆盖率: 每一种分支的组合路径都被测试过吗？

其中，分支覆盖率要比声明覆盖率严格（需要更多的测试），路径覆盖率要比分支覆盖率严格。在工业界，100%的声明覆盖率一个普遍的要求，但是这有时也是不可能实现的，因为会存在一些“不可能到达的代码”（例如有一些断言）。100%的分支覆盖率是一种很高的要求，对于军工/安全关键的软件可能会有此要求。不幸的是，100%的路径覆盖率是不可能的，因为这会让测试用例空间以指数速度增长。
一个标准的方法就是不断地增加测试用例直到覆盖率达到了预定的要求。在实践中，声明覆盖通常用覆盖率工具进行计数。利用这样的工具，白盒测试会变得很容易，你只需要不断地调整覆盖的地方，直到所有重要的声明都被覆盖到。
6.单元测试、回归测试、集成测试
6.1单元测试
对孤立的模块进行测试。这使得debugging变得简单，当一个单元测试报错是，我们只需要在这个单元找bug，而不是在整个程序去找
6.2集成测试
与单元测试相对应的，集成测试是对于组合起来的模块进行测试，甚至是整个程序。如果集成测试报错，我们就只能在大的范围去找了。但是这种测试依然是必要的，因为程序经常由于模块之间的交互而产生bug。例如，一个模块的输入是另一个模块的输出，但是设计者在设计模块的时候将输入输出类型弄错了。另外，如果我们已经做好单元测试了，即我们可以确性各个单元独立的正确性，我们的搜索bug的范围也会小很多。
6.3回归测试
我们称修改代码带来新的bug的现象为“回归”，而在修改后重新运行所有的测试称为“回归测试”。
一个好的测试应该是能发现bug的，你应该不断的充实你的测试用例。所以无论什么时候修改了一个bug，记得将导致bug的输入添加到你的测试用例里，并在以后的回归测试中去使用它——毕竟这个bug已经出现了，说明它可能是一个很容易犯的错误。

目录

一、张量的操作

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