PyTorch框架+Python 3面向对象编程学习笔记

一、CNN情感分类中的面向对象部分

sparse.py

  super(Embedding, self).__init__()

表示需要父类初始化，即要运行父类的_init_()，如果没有这个，则要自定义初始化

 self.weight = Parameter(torch.Tensor(num_embeddings, embedding_dim))

Parameter跳转

 class Parameter(Variable):
     """A kind of Variable that is to be considered a module parameter.

     Parameters are :class:`~torch.autograd.Variable` subclasses, that have a
     very special property when used with :class:`Module` s - when they're
     assigned as Module attributes they are automatically added to the list of
     its parameters, and will appear e.g. in :meth:`~Module.parameters` iterator.
     Assigning a Variable doesn't have such effect. This is because one might
     want to cache some temporary state, like last hidden state of the RNN, in
     the model. If there was no such class as :class:`Parameter`, these
     temporaries would get registered too.

     Another difference is that parameters can't be volatile and that they
     require gradient by default.

     Arguments:
         data (Tensor): parameter tensor.
         requires_grad (bool, optional): if the parameter requires gradient. See
             :ref:`excluding-subgraphs` for more details.
     """
     def __new__(cls, data=None, requires_grad=True):
         return super(Parameter, cls).__new__(cls, data, requires_grad=requires_grad)

     def __repr__(self):
         return 'Parameter containing:' + self.data.__repr__()

Parameter类中，data不是self.data来的，所以是父类的。只有在_init_()中self.data的才能追加进去，若在其他函数中，跳转到父类中，则是父类的data
24，25行函数，是实现一个子类对父类包装的功能。

__init__ 、__new__、__call__区分：

 class O(object):
     def __init__(self, *args, **kwargs):
         print "init"
         super(O, self).__init__(*args, **kwargs)

     def __new__(cls, *args, **kwargs):
         print "new", cls
         return super(O, cls).__new__(cls, *args, **kwargs)

     def __call__(self,  *args, **kwargs):
         print "call"

     oo = O()
     print "________"
     oo()  

结果如下：

1 new
2 init
3 ________
4 call

conv.py

 class Conv2d(_ConvNd):
     r"""Applies a 2D convolution over an input signal composed of several input
     planes.
     """

     def __init__(self, in_channels, out_channels, kernel_size, stride=1,
                  padding=0, dilation=1, groups=1, bias=True):
         kernel_size = _pair(kernel_size)
         stride = _pair(stride)
         padding = _pair(padding)
         dilation = _pair(dilation)
         super(Conv2d, self).__init__(
             in_channels, out_channels, kernel_size, stride, padding, dilation,
             False, _pair(0), groups, bias)

     def forward(self, input):
         return F.conv2d(input, self.weight, self.bias, self.stride,
                         self.padding, self.dilation, self.groups)

_pair()跳转到utils.py

 def _ntuple(n):
     def parse(x):
         if isinstance(x, collections.Iterable):
             return x
         return tuple(repeat(x, n))
     return parse

 _single = _ntuple(1)
 _pair = _ntuple(2)
 _triple = _ntuple(3)
 _quadruple = _ntuple(4)

这是一个函数式编程的写法，涉及函数嵌套。举例如下：

 def two_dim(y):
     def one_dim(x):
         return x*x + y
     return one_dim

 one_dim_plus_one = two_dim(1)

 print(one_dim_plus_one)     # 对象地址 <function two_dim.<locals>.one_dim at 0x0000012F6DBFCB70>
 print(one_dim_plus_one(2))  #
 print(one_dim_plus_one(3))  # 

 # f = x*x+y
 # g1 = f(x,1)
 f = lambda x,y:x*x+y
 g1 = lambda x:f(x,1) # x*x+1

 print(g1)       # f(x,1)的地址?
 print(g1(3))    #

1. repeat(x, n)跳转之后只有_init_()  pass，这是pytorch框架中，是ide生成的临时文件，由C语言实现的标准库内置函数或是外部接口。

2. tuple([iterable])
什么是可迭代对象？列表、字符串。。。

 if isinstance(x, collections.Iterable):
       return x
 return tuple(repeat(x, n))

 x = 'hello'
 print(_quadruple(x))        # 'hello'是可迭代对象，输出'hello'

 x = 2                       # 2不是可迭代对象，输出(2,2,2,2)
 print(_quadruple(x))

3. isinstance()函数是内置函数（内置函数不用导入就可以使用！那len()呢？）

命令行help查看isinstance函数

 isinstance(obj, class_or_tuple, /)

内置函数表如下：

_xxx_()是标准库函数

各种函数注意区分。

 a = Notebook()
 isinstance(a, Notebook)       # True

 class Test(Notebook):pass
 issubclass(Test, Notebook)      # True

4.  F.conv2d

 def forward(self, input):
      return F.conv2d(input, self.weight, self.bias, self.stride,
                   self.padding, self.dilation, self.groups)

conv2d跳转到functional.py（from .. import functional as F）中conv2d

functional.py

 # Convolutions
 ConvNd = torch._C._functions.ConvNd

 def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1,
            groups=1):
     """Applies a 2D convolution over an input image composed of several input
     planes.

     See（参考） :class:`~torch.nn.Conv2d` for details and output shape.
     """
     f = ConvNd(_pair(stride), _pair(padding), _pair(dilation), False,
                _pair(0), groups, torch.backends.cudnn.benchmark, torch.backends.cudnn.enabled)
     return f(input, weight, bias)

Conv2d是对conv2d包装。

 # AttributeError: 'Child' object has no attribute 'data'
 class Parent:
     def __init__(self):
         self.data =12

 class Child(Parent):
     def __init__(self):
         pass
         super().__init__()

 a = Child()
 print(a.data)

 #
 class Parent:
     def __init__(self):
         self.data =12

 class Child(Parent):
     def __init__(self):

         super().__init__()

 a = Child()
 print(a.data)

 #
 class Parent:
     def __init__(self):
         self.data =12

 class Child(Parent):
     def __init__(self):
         self.data = 25
         super().__init__()       

 a = Child()
 print(a.data)

 #
 class Parent:
     def __init__(self):
         self.data =12

 class Child(Parent):
     def __init__(self):

         super().__init__()
         self.data = 25

 a = Child()
 print(a.data)

二、面向对象编程python3

1. 列表生成式

 def search(self, filter):
     return [note for note in self.notes if note.match(filter)]

等价于

 def search(self, filter):
     temp = []
     for note in self.notes:
         if note.match(filter):
             temp.append(note)
　　　　return temp

列表推导式目标是生成临时列表，举例如下：

 f = [x for if for if for for if]
 # 等价于
 temp_list = []
 for st:
     if st:
         ...
           if:
             temp_list.append(x)
 f = temp_list

 #
 f = []
 for st:
      if st:
          ...
           if:
             f.append(x)

 # x*y for x in range(1,10) for y in range(1,10)
 a = []
 for x in range(1,10):
     for y in range(1,10):
         a.append(x*y)

2. global

 var = 13

 def test():
     global var
     var = 12
     print(var)

 # print(var)
 var = 25
 test()

书上部分未完