深度学习(23):numpy与tensor的数据转换、相互赋值

一、用一个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。

三、 将int64的numpy数组转成tensor，要求数据类型不变

要将 int64 类型的 NumPy 数组转换为 PyTorch Tensor，同时保持数据类型不变，可以使用 torch.as_tensor() 函数。

下面是一个示例代码，演示了如何将 int64 类型的 NumPy 数组转换为 PyTorch Tensor，而不改变数据类型：

import numpy as np
import torch

# 创建一个 int64 类型的 NumPy 数组
numpy_array = np.array([1, 2, 3, 4, 5], dtype=np.int64)

# 将 NumPy 数组转换为 PyTorch Tensor，保持数据类型不变
tensor = torch.as_tensor(numpy_array)

print(tensor)
print(tensor.dtype)

在上述示例中，我们创建了一个 int64 类型的 NumPy 数组 numpy_array。然后，使用 torch.as_tensor() 函数将该数组转换为 PyTorch Tensor。

输出结果为：

tensor([1, 2, 3, 4, 5])
torch.int64

可以看到，经过转换后的 PyTorch Tensor 的数据类型与原始的 NumPy 数组相同，都是 int64 类型。

使用 torch.as_tensor() 函数可以将 NumPy 数组转换为 PyTorch Tensor，并且保持数据类型不变。这个函数不会创建新的张量副本，而是与原始数据共享内存，因此在处理大型数组时可以提高效率。

四、numpy数组转tensor，数据类型从int64变成torch.float64

在将 NumPy 数组转换为 PyTorch Tensor 时，可以使用 torch.from_numpy() 函数。这个函数将 NumPy 数组转换为相应的 PyTorch Tensor，并且可以指定转换后的数据类型。

下面是一个示例代码，演示了如何将 NumPy 数组转换为 PyTorch Tensor 并改变数据类型为 torch.float64：

import numpy as np
import torch

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

# 将 NumPy 数组转换为 PyTorch Tensor，并指定数据类型为 torch.float64
tensor = torch.from_numpy(numpy_array).type(torch.float64)

print(tensor)
print(tensor.dtype)

在上述示例中，我们创建了一个 NumPy 数组 numpy_array，其中的元素类型为 int64。然后，使用 torch.from_numpy() 函数将该数组转换为 PyTorch Tensor，并通过 type() 方法指定数据类型为 torch.float64。

输出结果为：

tensor([1., 2., 3., 4., 5.], dtype=torch.float64)
torch.float64

可以看到，经过转换后的 PyTorch Tensor 的数据类型变为了 torch.float64，并且元素值保持不变。

使用 torch.from_numpy() 函数可以方便地将 NumPy 数组转换为 PyTorch Tensor，并且可以在转换过程中指定所需的数据类型。