要将这个数组转换成 PyTorch 张量，可以使用
torch.tensor()
函数。需要注意的是，这个数组包含多个数组，因此需要先将它们合并成一个数组。可以使用
np.concatenate()
函数来完成这一步。
以下是实现代码：
import numpy as np
import torch
# 定义原始数组
arr = [np.array([5, 0, 0, 0, 0, 0], dtype=np.uint32),
np.array([0, 1, 0, 4, 0, 0], dtype=np.uint32),
np.array([0, 0, 0, 3, 3, 3], dtype=np.uint32)]
# 将多个数组合并成一个数组
arr_merged = np.concatenate(arr)
# 将数组转换为 PyTorch 张量
tensor = torch.tensor(arr_merged)
# 打印张量
print(tensor)
输出结果应该是一个包含所有元素的 PyTorch 张量。注意，这个张量的形状会自动根据原始数组的维度进行推断。
----------------
执行上面代码后，报错TypeError: can't convert np.ndarray of type numpy.uint32. The only supported types are: float64, float32, float16, complex64, complex128, int64, int32, int16, int8, uint8, and bool，
这个错误说明 PyTorch 中不支持 uint32 类型的数据。解决这个问题的方法是，在将数组转换为 PyTorch 张量之前，先将它们的数据类型转换为 PyTorch 支持的类型。可以使用
astype()
函数来完成这一步。以下是修改后的代码：
import numpy as np
import torch
# 定义原始数组
arr = [np.array([5, 0, 0, 0, 0, 0], dtype=np.uint32),
np.array([0, 1, 0, 4, 0, 0], dtype=np.uint32),
np.array([0, 0, 0, 3, 3, 3], dtype=np.uint32)]
# 将多个数组合并成一个数组，并将数据类型转换为 PyTorch 支持的类型
arr_merged = np.concatenate(arr).astype(np.float32)
# 将数组转换为 PyTorch 张量
tensor = torch.tensor(arr_merged)
# 打印张量
print(tensor)
在这个代码中，我使用了
astype()
函数将原始数组中的数据类型从 uint32 转换为 PyTorch 支持的 float32 类型。然后将合并后的数组转换为 PyTorch 张量，就不会再报类型不支持的错误了。
----------------如何将 tensor([[1., 0., 0., 0., 0., 0.], [2., 1., 0., 4., 0., 0.], [3., 0., 0., 3., 3., 3.], [4., 0., 0., 0., 0., 0.], [5., 1., 0., 4., 0., 0.], [6., 0., 0., 3., 3., 3.], [7., 0., 0., 0., 0., 0.], [8., 1., 0., 4., 0., 0.], [9., 0., 0., 3., 3., 3.]]) 拆分成3份，并随机打乱
要将 PyTorch 张量拆分成多个子张量并随机打乱，可以使用
torch.split()
函数和
torch.shuffle()
函数。具体步骤如下：
-
使用
torch.split()
函数将原始张量拆分成多个子张量。需要确定每个子张量的大小，可以根据原始张量的形状和要拆分成的份数来计算。
-
使用
torch.shuffle()
函数将拆分后的子张量打乱。需要注意的是，
torch.shuffle()
函数只能对第一维进行打乱，因此需要先对子张量进行维度调整。
以下是实现代码：
import torch
import random
# 定义原始张量
tensor = torch.tensor([[1., 0., 0., 0., 0., 0.],
[2., 1., 0., 4., 0., 0.],
[3., 0., 0., 3., 3., 3.],
[4., 0., 0., 0., 0., 0.],
[5., 1., 0., 4., 0., 0.],
[6., 0., 0., 3., 3., 3.],
[7., 0., 0., 0., 0., 0.],
[8., 1., 0., 4., 0., 0.],
[9., 0., 0., 3., 3., 3.]])
# 计算每份子张量的大小
split_size = tensor.shape[0] // 3
# 使用 torch.split() 函数将张量拆分成多个子张量
sub_tensors = torch.split(tensor, split_size)
# 打印拆分后的子张量
print("Sub-tensors before shuffle:")
for sub_tensor in sub_tensors:
print(sub_tensor)
# 使用 torch.shuffle() 函数将子张量打乱
for i in range(len(sub_tensors)):
# 将子张量维度调整为 (size, -1) 的形式，以便使用 torch.shuffle() 函数
sub_tensors[i] = sub_tensors[i].view(split_size, -1)
sub_tensors[i] = torch.shuffle(sub_tensors[i], dim=0)
# 将子张量维度调整回 (n, m) 的形式
sub_tensors = [sub_tensor.view(-1, tensor.shape[1]) for sub_tensor in sub_tensors]
# 打印打乱后的子张量
print("Sub-tensors after shuffle:")
for sub_tensor in sub_tensors:
print(sub_tensor)
在这个代码中，我先使用
torch.split()
函数将原始张量
tensor
拆分成 3 份，然后对每个子张量使用
torch.shuffle()
函数进行随机打乱。最后将打乱后的子张量打印出来，以验证是否打乱成功。
如果需要先对 PyTorch 张量进行随机打乱，然后再将其拆分成多个子张量，可以按照以下步骤操作：
-
使用
torch.randperm()
函数生成一个长度为原始张量大小的随机索引序列。
-
使用随机索引序列对原始张量进行重排，得到打乱后的张量。
-
使用
torch.split()
函数将打乱后的张量拆分成多个子张量。同样需要确定每个子张量的大小。
以下是实现代码：
import torch
import random
# 定义原始张量
tensor = torch.tensor([[1., 0., 0., 0., 0., 0.],
[2., 1., 0., 4., 0., 0.],
[3., 0., 0., 3., 3., 3.],
[4., 0., 0., 0., 0., 0.],
[5., 1., 0., 4., 0., 0.],
[6., 0., 0., 3., 3., 3.],
[7., 0., 0., 0., 0., 0.],
[8., 1., 0., 4., 0., 0.],
[9., 0., 0., 3., 3., 3.]])
# 使用 torch.randperm() 函数生成随机索引序列，并用其对张量进行重排
shuffle_indices = torch.randperm(tensor.shape[0])
shuffled_tensor = tensor[shuffle_indices]
# 计算每份子张量的大小
split_size = shuffled_tensor.shape[0] // 3
# 使用 torch.split() 函数将张量拆分成多个子张量
sub_tensors = torch.split(shuffled_tensor, split_size)
# 打印拆分后的子张量
print("Sub-tensors after shuffle:")
for sub_tensor in sub_tensors:
print(sub_tensor)
在这个代码中，我先使用
torch.randperm()
函数生成一个长度为原始张量大小的随机索引序列，并用这个索引序列对原始张量进行重排，得到了打乱后的张量
shuffled_tensor
。然后，我使用
torch.split()
函数将
shuffled_tensor
拆分成 3 份子张量，并打印出来以验证是否拆分成功。
