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))  # 5
print(one_dim_plus_one(3))  # 10

# 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))    # 10

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)


# 12
class Parent:
    def __init__(self):
        self.data =12
        
class Child(Parent):
    def __init__(self):
        
        super().__init__()
               
a = Child()
print(a.data)


# 12
class Parent:
    def __init__(self):
        self.data =12
        
class Child(Parent):
    def __init__(self):
        self.data = 25
        super().__init__()       
        
a = Child()
print(a.data)


# 25
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()

书上部分未完