2.9日学习记录

1.训练过程的四个内容

从上面可以看到一个典型的训练过程：处理数据+前向模型+后向传播优化+打印结果

2. .item()作用

import torch
a=torch.tensor([0])
print(a.item())

输出：
0

只针对单个的数

import torch
a=torch.tensor([0,1])
print(a.item())

输出：
Traceback (most recent call last):
    print(a.item())
ValueError: only one element tensors can be converted to Python scalars

3.对model.state_dict()做理解

https://pytorch.org/tutorials/beginner/saving_loading_models.html

//发现自己对保存模型还不太理解，就谷歌了一下，直接找到了官方教程，比百度好太多了，搜索一定要用谷歌啊！！能发现很多宝藏。

4.model.eval()

在进行推测之前一定要调用model.eval()，为什么呢？为什么我看的这些基础教程都没有这个，没有model.train()和model.eval()。这个还是等我再深入学习了解吧。

5.optimizer.state_dict()

'optimizer_state_dict': optimizer.state_dict(),#contains buffers and parameters that are updated as the model trains.

它的状态参数包含缓冲区和模型训练的参数。

6.super(ConvNet, self).init()

pytorch的网络函数中都会调用这个，作用是什么？

https://blog.csdn.net/shiheyingzhe/article/details/83051471

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

其中的super类的作用是继承的时候，调用含super的各个的基类__init__函数，如果不使用super，就不会调用这些类的__init__函数，除非显式声明。而且使用super可以避免基类被重复调用。
使用 print(Model.__mro__)打印搜索顺序或者祖先树，被官方称为MRO即Method Resolution Order，

用法：

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

使用super子类调用基类的函数，可以实现不访问基类的类名，这样在改变继承关系的时候更加的简洁方便，不用修改子类函数体内容。

上面是对类中普通函数的例子。

7.super()继承作用

class A():
    def __init__(self):
        print('Call class A')
        super(A, self).__init__()
        print('Leave class A')
class B(A):
    def __init__(self):
        print('Call class B')
        super(B,self).__init__()
        print('Leave class B')
class C(A):
    def __init__(self):
        print('Call class C')
        super(C,self).__init__()
        print('Leave class C')
class D(A):
    def __init__(self):
        print('Call class D')
        super(D, self).__init__()
        print('Leave class D')
class E(B,C,D):
    def __init__(self):
        print('Call class E')
        super(E, self).__init__()
        print('Leave class E')
sample=E()
print(E.__mro__)

#输出：
Call class E
Call class B
Call class C
Call class D
Call class A
Leave class A
Leave class D
Leave class C
Leave class B
Leave class E
(<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>
, <class '__main__.A'>, <class 'object'>)

这个我能够理解输出结果，但是它的上一个例子我就不能理解，为什么是这个样子：

class A():
    def __init__(self):
        print('Call class A')
        print('Leave class A')
class B(A):
    def __init__(self):
        print('Call class B')
        print('Leave class B')
class C(A):
    def __init__(self):
        print('Call class C')
        super(C,self).__init__()
        print('Leave class C')
class D(A):
    def __init__(self):
        print('Call class D')
        super(D, self).__init__()
        print('Leave class D')
class E(B,C,D):
    def __init__(self):
        print('Call class E')
        B.__init__()
        C.__init__()
        D.__init__()
        print('Leave class E')
sample=E()
print(E.__mro__)

#输出
Call class E
Call class B
Leave class B
Call class C
Call class D
Call class A
Leave class A
Leave class D
Leave class C
Call class D
Call class A
Leave class A
Leave class D
Leave class E
(<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, 
<class '__main__.A'>, <class 'object'>)

为什么这里D会被调用呢？C和D是兄弟关系。这里还是不明白，保留疑问。。

反正super就是可以用来调用基函数，保证不重复调用之类的（在多重继承时体现）。

https://zhuanlan.zhihu.com/p/29763421

明白了一点，下面是nn.Model的初始化方法，继承它的子类通过super运行这个函数，去给这些属性在父类中统一定义，而不用在子类中再写了。

8.Normalization layers：对特征归一化

https://pytorch.org/docs/stable/nn.html

参数是特征数。

其中γ默认为1，β默认为0，并且x是特征，不是样本。。从下面的例子中可以看出：

import torch.nn as  nn
import torch
m = nn.BatchNorm1d(3)
input = torch.randn(2, 3)
output = m(input)

#输出
>>> output
tensor([[-0.9762,  0.3067, -0.5193],
        [ 0.9762, -0.3067,  0.5193]], grad_fn=<NativeBatchNormBackward>)