Pytorch与Tensorflow2相互转换，函数记录（持续更新中......）_tensorflow和pytorch模型之间转换

记录Pytorch与Tensorflow2的函数转换（持续更新中…）

tensorflow2官方文档

pytorch官方文档

• 将所有元素的值限制到[min,max]这个范围。

# Tensorflow语法：
out = tf.clip_by_value(input, minvalue, maxvalue)
# Pytorch语法：
out = torch.clamp(input, min, max, out=None)
1
2
3
4

• 计算输出相对于输入的梯度之和

# Tensorflow语法：
grad = tf.gradients(ys, xs)[0]
# Pytorch语法：
grad = torch.autograd.grad(ys, xs)[0]
1
2
3
4

• 禁用梯度计算的上下文管理器

# Tensorflow语法：暂时停止在此磁带上记录操作。在此上下文管理器处于活动状态时执行的操作将不会记录在磁带上。这对于减少跟踪所有计算所使用的内存非常有用。
x = tf.constant(4.0)
with tf.GradientTape() as tape:
  with tape.stop_recording():
    y = x ** 2
dy_dx = tape.gradient(y, x)
print(dy_dx)
None

# Pytorch语法：
>>> x = torch.tensor([1.], requires_grad=True)
>>> with torch.no_grad():
...   y = x * 2
>>> y.requires_grad
False
>>> @torch.no_grad()
... def doubler(x):
...     return x * 2
>>> z = doubler(x)
>>> z.requires_grad
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 返回输入张量中所有元素的最大值

# Tensorflow语法：
max_ = tf.reduce_max(input, axis=1)
# Pytorch语法：
max_ = torch.max(input, dim=1) 
1
2
3
4

• 返回给定张量的矩阵范数或向量范数

# Tensorflow语法：
out = tf.norm(input, ord=1, axis=1)
# Pytorch语法：
out = torch.norm(input, p=1, dim=1)
1
2
3
4

• 在给定维度中连接给定的张量

# Tensorflow语法：
out = tf.concat(values, axis=0)
# Pytorch语法：
out = torch.cat(values, dim=0)
1
2
3
4

• 模型保存

# Tensorflow语法：
tf.saved_model.save(obj, export_dir)
# Pytorch语法：
torch.save(obj, f)
1
2
3
4

• 创建一个所有元素都为零的张量

# Tensorflow语法：
tf.zeros_like(input, dtype=None)
# Pytorch语法：
torch.zeros_like(input, dtype=None）
1
2
3
4

• 从均匀分布中输出随机值

# Tensorflow语法：
tf.random.uniform(shape=[])
# Pytorch语法：
torch.rand(shape=[])
1
2
3
4

• 计算均方误差

# Tensorflow语法：
tf.losses.mean_squared_error(x, y)
# Pytorch语法：
MSELoss = torch.nn.MSELoss()
MSELoss(x, y)

1
2
3
4
5
6

• 使输入变平。不影响批大小。

# Tensorflow语法：
Flatten = tf.keras.layers.Flatten()
Flatten(input)

# Pytorch语法：
Flatten = nn.Flatten()
Flatten(input)

>>> input = torch.randn(32, 1, 5, 5)
>>> # With default parameters
>>> m = nn.Flatten()
>>> output = m(input)
>>> output.size()
torch.Size([32, 25])
>>> # With non-default parameters
>>> m = nn.Flatten(0, 2)
>>> output = m(input)
>>> output.size()
torch.Size([160, 5])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 计算x元素的双曲正切，tanh

# Tensorflow语法：
tf.math.tanh(x)
# Pytorch语法：
torch.tanh(x)
1
2
3
4

• 计算x元素的自然对数。

# Tensorflow语法：
tf.math.log(x)
# Pytorch语法：
torch.log(x)
1
2
3
4

• 构造一个单位矩阵，或一批矩阵。

# Tensorflow语法：
tf.eye(num_rows)

# Construct one identity matrix.
tf.eye(2)
==> [[1., 0.],
     [0., 1.]]

# Construct a batch of 3 identity matrices, each 2 x 2.
# batch_identity[i, :, :] is a 2 x 2 identity matrix, i = 0, 1, 2.
batch_identity = tf.eye(2, batch_shape=[3])

# Construct one 2 x 3 "identity" matrix
tf.eye(2, num_columns=3)
==> [[ 1.,  0.,  0.],
     [ 0.,  1.,  0.]]
     
# Pytorch语法：
torch.eye(num_rows)

>>> torch.eye(3)
tensor([[ 1.,  0.,  0.],
        [ 0.,  1.,  0.],
        [ 0.,  0.,  1.]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• 应用布尔掩码到张量上

# Tensorflow语法：
tf.boolean_mask(tensor, mask, axis=None, name='boolean_mask')

tensor = [0, 1, 2, 3]  # 1-D example
mask = np.array([True, False, True, False])
out = tf.boolean_mask(tensor, mask)
# out : tf.Tensor([0 2], shape=(2,), dtype=int32)


tensor = [[0,1,2],[3,4,5],[6,7,8]] # 2-D example
mask = np.array([[True,False,False],
				 [False, True,False],
				 [False,False,True]])
out = tf.boolean_mask(tensor, mask)
# out : tf.Tensor([0 4 8], shape=(3,), dtype=int32)

# Pytorch语法：
torch.masked_select(input, mask)

>>> x = torch.randn(3, 4)
>>> x
tensor([[ 0.3552, -2.3825, -0.8297,  0.3477],
        [-1.2035,  1.2252,  0.5002,  0.6248],
        [ 0.1307, -2.0608,  0.1244,  2.0139]])
>>> mask = x.ge(0.5)
>>> mask
tensor([[False, False, False, False],
        [False, True, True, True],
        [False, False, False, True]])
>>> torch.masked_select(x, mask)
tensor([ 1.2252,  0.5002,  0.6248,  2.0139])
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
28
29
30
31

• 计算输入中每个元素的绝对值。

# Tensorflow语法：
tf.math.abs(x)
# Pytorch语法：
torch.abs(x)
1
2
3
4

• 将一个秩-R张量列表堆叠成一个秩-(R+1)张量。

# Tensorflow语法：
tf.stack(values, axis=0, name='stack')
# Pytorch语法：
torch.stack(tensors, dim=0)

1
2
3
4
5

• 计算一个张量维度上元素的平均值

# Tensorflow语法：
tf.math.reduce_mean(x,axis=None)
# Pytorch语法：
torch.mean(x,dim=None)
1
2
3
4

• 用零填充图像到指定的高度和宽度。

# Tensorflow语法：
tf.raw_ops.PadV2(input, paddings=[[pad_top, pad_bottom],[pad_left,pad_right]],constant_values=0)
# Pytorch语法：
torch.nn.functional.pad(input, [pad_left, pad_right, pad_top, pad_bottom],mode='constant', value=0)
1
2
3
4

• 计算输入对数和目标之间的交叉熵损失

# Tensorflow语法：
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(label, logit)
loss_ = tf.reduce_mean(loss)

# logit: tf.Tensor([[-1.6456  0.0097 -1.0953  1.1578  0.917 ]
# 					[ 1.8985  0.3284  0.7734  0.551   0.5097]
#					[ 0.7643  2.2743  1.376   1.3695  0.931 ]], shape=(3, 5), dtype=float32)
# label: tf.Tensor([0 1 2], shape=(3,), dtype=int32)
# loss: tf.Tensor([3.6227016 2.2839847 1.7284999], shape=(3,), dtype=float32)
# loss_: tf.Tensor(2.545062, shape=(), dtype=float32)

# Pytorch语法：
torch.nn.CrossEntropyLoss()

>>> # Example of target with class indices
>>> loss = nn.CrossEntropyLoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.empty(3, dtype=torch.long).random_(5)
>>> output = loss(input, target)
>>> output.backward()

# input:tensor([[-1.6456,  0.0097, -1.0953,  1.1578,  0.9170],
#        		[ 1.8985,  0.3284,  0.7734,  0.5510,  0.5097],
#        		[ 0.7643,  2.2743,  1.3760,  1.3695,  0.9310]], requires_grad=True)
# target:tensor([0, 1, 2])
# output:tensor(2.5451, grad_fn=<NllLossBackward0>)
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

• 改写网络结构，需要用到的：维度交换
  以[ 本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/190316