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

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

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'>)