__init__和__forward__；torch.backward()；随机种子_torch forward backward embedding

https://blog.csdn.net/u012436149/article/details/69230136
1.__init__和__forward__函数的作用
通过一个例子讲解：

这是建立一个Embedding的函数，首先在__int__的函数进行初始化这个分类器，__init__就是起到初始化的作用的。
__forward__是这个初始化的embedding在有输入的时候到底是怎么操作的（也就是前向计算），你会发现所有的输入都是在forward这里输入的，init里面没有输入。
2.__call__函数的作用
https://www.cnblogs.com/xinglejun/p/10129823.html
　Python中有一个有趣的语法，只要定义类型的时候，实现__call__函数，这个类型就成为可调用的。换句话说，我们可以把这个类型的对象当作函数来使用，相当于 重载了括号运算符。

class Person(object):
　　　　def __init__(self, name, gender):
　　　　　　self.name = name
　　　　　　self.gender = gender

　　　　def __call__(self, friend):
　　　　　　print 'My name is %s...' % self.name
　　　　　　print 'My friend is %s...' % friend
1
2
3
4
5
6
7
8

现在可以对 Person 实例直接调用：

	p = Person('Bob', 'male')
	p('Tim')这里就像一个函数一样可以输入一个参数
1
2

My name is Bob…
　　My friend is Tim…

3.hook机制
https://blog.csdn.net/u012436149/article/details/69230136

4.torch.backward()
问题来源：
这里的v没有计算公式，传入的tensor是干什么的？

import torch

v=torch.tensor([0,0,0],requires_grad=True,dtype=torch.float32)
h = v.register_hook(lambda grad:grad*2)
v.backward(torch.tensor([1,1,1],dtype=torch.float32))
print(v.grad.data)
h.remove()
1
2
3
4
5
6
7

1. 如果是标量对向量求导(scalar对tensor求导)，那么就可以保证上面的计算图的根节点只有一个，此时不用引入grad_tensors参数，直接调用backward函数即可
2. 如果是(向量)矩阵对(向量)矩阵求导(tensor对tensor求导)，实际上是先求出Jacobian矩阵中每一个元素的梯度值(每一个元素的梯度值的求解过程对应上面的计算图的求解方法)，然后将这个Jacobian矩阵与grad_tensors参数对应的矩阵进行对应的点乘，得到最终的结果。

5.随机种子的概念：

torch.manual_seed(7) # cpu
torch.cuda.manual_seed(7) #gpu
np.random.seed(7) #numpy
random.seed(7) #random and transforms
1
2
3
4

种子的作用域：
一个种子下面多个函数，他会给这些个函数分别固定一个不同的初始值。
它会给直接跟着它的函数固定确定的初始值。
举个例子：如果你在for循环外面设置随机种子往往是无效的：它类似第一种情况，分别固定了不同的初始值，所以无法达到每次都一样的效果。
总而言之：
随机种子可以固定下面函数产生的随机数，但是如果要每次都一样，就需要重复使用同样的随机种子

torch.manual_seed(2)
x = Variable(torch.randn(3), requires_grad=True)
y = Variable(torch.randn(3), requires_grad=True)
z = Variable(torch.randn(3), requires_grad=True)
print(x)
print(y)
print(z)
import numpy as np
np.random.seed(0)
m = np.random.randint(10)
print(m)	# 5
m = np.random.randint(10)
print(m)	# 0
m = np.random.randint(10)
print(m)	# 3
tensor([ 0.3923, -0.2236, -0.3195], requires_grad=True)
tensor([-1.2050,  1.0445, -0.6332], requires_grad=True)
tensor([ 0.5731,  0.5409, -0.3919], requires_grad=True)
5
0
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import torch
from torch.autograd import Variable
torch.manual_seed(2)
x = Variable(torch.randn(3), requires_grad=True)
torch.manual_seed(2)
y = Variable(torch.randn(3), requires_grad=True)
torch.manual_seed(2)
z = Variable(torch.randn(3), requires_grad=True)
print(x)
print(y)
print(z)
import numpy as np
np.random.seed(0)
m = np.random.randint(10)
print(m)	# 5
np.random.seed(0)
m = np.random.randint(10)
print(m)	# 5
np.random.seed(0)
m = np.random.randint(10)
print(m)	# 5
tensor([ 0.3923, -0.2236, -0.3195], requires_grad=True)
tensor([ 0.3923, -0.2236, -0.3195], requires_grad=True)
tensor([ 0.3923, -0.2236, -0.3195], requires_grad=True)
5
5
5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27