一、用一个tensor使用赋值初始化另一个 tensor 的后果

1 前言

最近在调试程序的时候，发现自己为了方便，使用直接赋值来获取和前面已经定义的 tensor 相同形状的 tensor，这样是不可取的

2 用一个tensor赋值初始化另一个tensor–出问题

下面用 tensor a 赋值 tensor b，对 tensor b 进行初始化

import torch
a=torch.ones((3,4))
print("a:",a)
print("================")
b=a
print("a:",a)
print("b:",b)
print("================")
b[1][2]=5
print("a:",a)
print("b:",b)
print("================")

运行python脚本，输出如下。可以明显看出，修改 tensor b ，导致 tensor a也被修改

a: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
================
a: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
b: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
================
a: tensor([[1., 1., 1., 1.],
        [1., 1., 5., 1.],
        [1., 1., 1., 1.]])
b: tensor([[1., 1., 1., 1.],
        [1., 1., 5., 1.],
        [1., 1., 1., 1.]])
================

3 tensor的内存共享机制

为了实现高效计算，PyTorch提供了一些原地操作运算，即in-place operation，不经过复制，直接在原来的内存上进行计算。对于内存共享，主要有如下3种情况

通过Tensor初始化Tensor: 直接通过Tensor来初始化另一个Tensor，或者通过Tensor的组合、分块、索引、变形操作来初始化另一个Tensor，则这两个Tensor共享内存。
原地操作符: PyTorch对于一些操作通过加后缀 “ _ ” 实现了原地操作，如add_()和resize_()等，这种操作只要被执行，本身的Tensor则会被改变。
Tensor与NumPy转换: Tensor与NumPy可以高效地进行转换，并且转换前后的变量共享内存。在进行PyTorch不支持的操作时，甚至可以曲线救国，将Tensor转换为NumPy类型，操作后再转换为Tensor
参考：PyTorch基础：Tensor的内存共享

4 定义和前面形状 tensor 一样的 tensor

import torch
a=torch.ones((3,4))
print("a:",a)
print("================")
"""  错误示范
b=a
print("a:",a)
print("b:",b)
print("================")
# 对 b 进行操作 
b[1][2]=5
print("a:",a)
print("b:",b)
print("================")
"""
b=torch.ones(a.shape)  # 或  b=torch.zeros(a.shape)
print("a:",a)
print("b:",b)
print("================")
# 对 b 进行操作
b[1][2]=5
print("a:",a)
print("b:",b)
print("================")

运行输出。此时，改变 b 并没有影响 a

a: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
================
a: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
b: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
================
a: tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
b: tensor([[1., 1., 1., 1.],
        [1., 1., 5., 1.],
        [1., 1., 1., 1.]])
================

5.使用torch.clone()

可以使用 torch.clone() 函数创建一个和原有 tensor 有相同 shape 和数据的新 tensor，然后对这个新的 tensor 进行操作，这样原有的 tensor 就不会受到影响。

import torch

# 原有 tensor
x = torch.tensor([[1, 2], [3, 4]])
print('x before update: ', x)

# 创建新 tensor，并对其进行操作
y = x.clone()
y[0, 0] = 5
print('y: ', y)

# 原有 tensor 不受影响
print('x after update: ', x)

输出结果为：

x before update:  tensor([[1, 2],
        [3, 4]])
y:  tensor([[5, 2],
        [3, 4]])
x after update:  tensor([[1, 2],
        [3, 4]])

二、用一个numpy使用赋值初始化另一个 numpy 的后果

1. numpy和tensor一样也有内存共享机制

>>> import numpy as np
>>> a=np.ones((3,3))
>>> a
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])
>>> b=a
>>> b[1][1]=3
>>> b
array([[1., 1., 1.],
       [1., 3., 1.],
       [1., 1., 1.]])
>>> a
array([[1., 1., 1.],
       [1., 3., 1.],
       [1., 1., 1.]])

2.使用numpy.copy()

要复制一个 NumPy 数组并且不使用内存共享，可以使用 copy() 方法。这将返回一个新的数组，它的数据不与原数组共享内存。
例子如下:

import numpy as np

# 创建一个 NumPy 数组
a = np.array([1, 2, 3, 4, 5])

# 复制该数组并返回新的数组
b = a.copy()

# 修改新的数组
b[0] = 10

# 查看两个数组的值
print(a)  # 输出 [1 2 3 4 5]
print(b)  # 输出 [10  2  3  4  5]

在上面的例子中，我们首先创建了一个包含 5 个元素的 NumPy 数组 a，然后使用 copy() 方法将其复制到新的数组 b 中。然后，我们修改了新数组 b 的第一个元素，并查看了两个数组的值。由于 a 和 b 不共享内存，因此修改 b 并不会影响 a。