张量Tensor

一、如何创建张量？

1.可以根据数据直接创建张量

x_data.shape: 这是x_data的形状（shape）。它返回一个元组，表示x_data在每个维度上的大小。例如，对于一个形状为(60000, 28, 28)的MNIST图像数据集，这意味着有60000个图像，每个图像是28x28像素的。

from mindspore import Tensor
data = [1,0,1]
x_data = Tensor(data)
print(x_data, x_data.shape, x_data.dtype)#.dtype这是一个属性，它返回张量的数据类型
print(x_data.type)#它返回张量的完整类型信息，包括数据类型

 输出：

2.可以从NumPy数组创建张量

np_array = np.array(data)
#错误：print(np_array.type)#.dtype属性用于获取数组的数据类型
print(np_array.dtype)

np_data = Tensor(np_array)
print(np_data.type)#张量用.type

输出：

 3.继承另一个张量的属性，形成新的张量

from mindspore import ops
tensor_1=ops.ones_like(x_data)
print(tensor_1)
tensor_2=ops.zeros_like(x_data)
print(tensor_2)

输出：

 4.使用init初始化器构造张量

from mindspore.common.initializer import One,Normal
#初始化一个张量，初始元素均为1
tensor1=mindspore.Tensor(shape=(3,3,3),dtype=mindspore.float32,init=One())
print("tensor1:\n",tensor1)
#从标准正态分布（均值为0，标准差为1）中抽取的随机数填充的张量。
tensor2=mindspore.Tensor(shape=(4,4),dtype=mindspore.float32,init=Normal())
print("tensor2:\n",tensor2)

 输出：

注：init主要用于并行模式下的延后初始化，在正常情况下不建议使用init对参数进行初始化。

二、张量的属性

ydata=Tensor([[2,6,3,1,1],[1,0,2,5,4]],mindspore.int32)#随手写一个张量看看它的属性
print(ydata)
print("Tensor的shape，是一个tuple; ydata.shape:",ydata.shape)
print("Tensor的dtype，是MindSpore的一个数据类型;ydata.dtype:",ydata.dtype)
print("Tensor中每一个元素占用字节数，是一个整数;ydata.itemsize:",ydata.itemsize)
print("Tensor占用的总字节数，是一个整数。ydata.nbytes:",ydata.nbytes)
print("维数ydata.ndim:",ydata.ndim)
print("Tensor中所有元素的个数，是一个整数。ydata.size:",ydata.size)
print("Tensor每一维所需要的字节数，是一个tuple。ydata.strides:",ydata.strides)

 输出：

三、张量索引

 Tensor索引与Numpy索引类似，索引从0开始编制，负索引表示按倒序编制，冒号:和 ...用于对数据进行切片，:和...用哪个都行

zdata=Tensor([[3,3,2],[2,1,1]])#不加mindspore.int32的时候
print(zdata)
print("打印第一行: {}".format(zdata[0]))
print("打印倒数第一行:{}".format(zdata[-1,:]))
print("打印第二行第二列的元素:{}".format(zdata[1,1]))
print("打印第一列：{}".format(zdata[:,0]))
print("打印最后一列:{}".format(zdata[:,-1]))

输出：

 四、张量运算(比较简单)

1.普通算术运算

普通算术运算有：加（+）、减（-）、乘（*）、除（/）、取模（%）、整除（//）

#首先，随手写两个张量
x=Tensor([1,2,3],mindspore.float32)
y=Tensor([4,5,6],mindspore.float32)
print("x:",x,"\n""y:",y)
add = x+y#对应元素相加
sub = x-y#对应元素相减
mul = x*y
div = y/x
mod = y%x#取余
floordiv=y//x#整除

print("add:",add)
print("sub:",sub)
print("mul:",mul)
print("div:",div)
print("mod:",mod)
print("floordiv:",floordiv)

 输出：

 

 2.ops.concat

ops.concat()将给定维度上的一系列张量连接起来.

x=Tensor([[1,2,3],[6,6,6],[1,1,1]],mindspore.float32)
y=Tensor([[4,5,6],[2,2,2],[3,3,3]],mindspore.float32)
print("x:",x)
print("y:",y)
output1 = ops.concat((x,y),axis=0)
print(output1)
print("x.shape:",x.shape,"\n y.shape:",y.shape,"\n output1.shape:",output1.shape)

输出：

 3.stack

ops.stack()从另一个新的维度上将两个张量合并起来.

output2=ops.stack((x,y))
print(output2)
print("x.shape:",x.shape,"\n y.shape:",y.shape,"\n output2.shape:",output2.shape)

输出：

 五、Tensor与NumPy转换

1.Tensor转换为NumPy

Tensor转换为NumPy，与张量创建相同，使用 .asnumpy() 将Tensor变量转换为NumPy变量

#print(x,"\n",x.type)
print(f"x:{x},type(x):{type(x)}")
np_x=x.asnumpy()
#print(np_x,"\n",np_x.dtype)
print(f"np_x:{np_x},type(np_x):{type(np_x)}")

 输出：

 2.NumPy转换为Tensor

NumPy转换为Tensor,使用Tensor()将NumPy变量转换为Tensor变量

print(f"np_x:{np_x},type(np_x):{type(np_x)}")
x_tensor=Tensor(np_x)
print(f"x_tensor:{x_tensor},type(x_tensor):{type(x_tensor)}")

输出：

 六、稀疏张量

1.CSRTensor

MindSpore现在已经支持最常用的CSR和COO两种稀疏数据格式。
用来表示某一Tensor在给定索引上非零元素的集合，其中行索引由 indptr 表示，列索引由 indices 表示，非零值由 values 表示。
如果 indptr 是[0, 1, 2, 2]， indices 是[1, 2]， values 是[1., 2.]， shape 是(3, 4)，那么它对应的稠密Tensor如下：
[[0., 1., 0., 0.],
 [0., 0., 2., 0.],
 [0., 0., 0., 0.]]
下面是CSRTensor的使用示例:

from mindspore import CSRTensor
indptr=Tensor([0,1,2,2])
indices=Tensor([1,2])
values=Tensor([3,4],mindspore.float32)
shape=(3,4)
# Make a CSRTensor
csr_tensor=CSRTensor(indptr,indices,values,shape)
print(csr_tensor.astype(mindspore.float64).dtype)
print(csr_tensor)

 2.COOTensor

如果 indices 是[[0, 1], [1, 2]]， values 是[1, 2]， shape 是(3, 4)，那么它对应的稠密Tensor如下：
[[0, 1, 0, 0],
 [0, 0, 2, 0],
 [0, 0, 0, 0]]

下面是COOTensor的使用示例:

from mindspore import COOTensor
indices = Tensor([[0, 1], [1, 2]], dtype=mindspore.int32)
values = Tensor([1, 2], dtype=mindspore.float32)
shape = (3, 4)
# Make a COOTensor
coo_tensor = COOTensor(indices, values, shape)
print(coo_tensor.astype(mindspore.float64).dtype)
print(coo_tensor)

 总算把张量过了一遍咯~~~