昇思25天学习打卡训练营第3天|张量Tensor

张量可以表示矢量、标量与其他张量之间线性关系的多线性䁋，如内积、外积、线性映射、笛卡尔积.坐标在n维空间内有n^r个分量的一种量，每个分量为坐标的函数，在坐标变换时该分量也依照某些规则作线性变换，r称为该张量的秩或阶.(??)

在mindspore中张量是用来表示网络结构的数据结构，定义在下边包中

import numpy as np

import mindspore

from mindspore import ops

from mindspore import Tensor, CSRTensor, COOTensor

import time

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())),'xxxx')

1.创建张量

支持用Tensor,float,int, bool, tuple,list, numpy.ndarray类型构造张量.

1)根据数据生成，如

data = [1,0, 2,0]

x_data=Tensor(data)

print(x_data,x_data.shape, x_data.dtype)

2)从Numpy数组生成

np_array = np.array(data)

x_np = Tensor(np_array)

print(x_np, x_np.shape, x_np.dtype)

3)使用init初始化器构造张量

传入参数可以为

init:支持initializer子类

shape:支持传入list, tuple, int

dtype:支持传入mindspore.dtype

from indspore.common.initializer import One,Normal

tensor1 = mindspore.Tensor(shape=(2,2),dtype = mindspore.float32,init=One())

tensor2 = mindspore.Tensor(shape=(2,2),dtype = mindspore.float32,init=Normal())

print("tensor1:\n", tensor1)

print("tensor2:\n",tensor2)

init主要用于并行模式下延后初始化，正常情况下不建议使用

4)继承另一个张量的属性，形成新的张量

from indspore import ops

x_ones = ops.ones_like(x_data)

print(f"Ones Tensor:\n {x_ones} \n")

x_zeros = ops.zeros_like(x_data)

print(f"Zeros Tensor:\n {x_zeros} \n")

2.张量的属性

包括形状、数据类型、转置张量、单个元素大小、占用字节数量、维数、元素个数和每一维步长

形状(shape):Tensor的shape，为tuple类型

数据类型(dtype):Tensor的dtype, MindSpore的一个数据类型

单个元素大小(itemsize):Tensor中每一个元素占用字节数，为整数

占用字节数量(nbytes):Tensor占用的总字节数，为整数

维数(ndim):Tensor的秩，等于len(tensor.shape)

元素个数(size):Tensor中所有元素的个数

每一维步长(strides):Tensor中每一维所需要的字节数,为tuple

x = Tensor(np.array([[1,2],[3,4]]), mindspore.int32)

print("x_shape:",x.shape)

print("x_dtype:", x.dtype)

print("x_itemsize:", x.itemsize)

print("x_nbytes:",x.nbytes)

print("x_ndim:",x.ndim)

print("x_size:",x.size)

print("x_strides:",x.strides)

3.张量索引

Tensor索引和Numpy索引类似，从0开始，负数表示倒序，:与...表示对数据切片

tensor = Tensor(np.array([[0,1],[2,3]]).astype(np.float32))

print("First row:{}".format(tensor[0]))

print("value of bottom right corner:{}".format(tensor[1,1]))

print("Last column:{}".format(tensor[:,-1]))

print("First column:{}".format(tensor[...,0]))

4.张量运算

算术，线性代数，矩阵处理（转置、标引、切片），采样等

算术运算有:+  - *  / % //

x  = Tensor(np.array([1,2,3]), mindspore.float32)

y = Tensor(np.array([4,5,6]), mindspore.float32)

print("add:", x + y)

print("sub:", x - y)

print("mult:", x * y)

print("div:",  y / x)

print("mod:", y % x)

print("floordiv:", y // x)

print("concat:", ops.concat((x, y), axis = 0) #从给定维度上将张量连接

print("stack：”， ops.stack([x,y]) #从另一维度上将张量合并起来

Tensor可以使用Tensor.asnumpy()转换为Numpy对象,也可以使用Tensor.from_numpy()将numpy对象转换为Tensor对象

t = Tensor([1., 1., 1., 1., 1.])

print(f"t:{t}", type(t))

n = t.asnumpy()

print(f"n:{n}", type(n))

t = Tensor.from_numpy(n)

print(f"t:{t}", type(t))

5.稀疏张量

绝大部分元素为0的张量称稀疏张量.常用表达形式为<indices:Tensor, values:Tensor, shape:Tensor>,其中indices表示非0下标元素，values表示非0元素个数，shape表示被压缩的稀疏张量形状。有三种结构：CSRTensor(Compressed Sparse Row), COOTensor(Coordinate Format),RowTensor

1)CSRTensor

具有高效存储与计算优势，非0元素存放在values中，位置存放在indptr/indices(行/列）中，该三个元素均为一维张量.shape表示被压缩张量形状，数据类型为Tuple

indptr = Tensor([0,1,2])

indices = Tensor([0,1])

values = Tensor([1,2], dtype=mindspore.float32)

shape = (2,4)

csr_tensor = CSRTensor(indptr, indices, values,shape)

print(csr_tensor.astype(mindspore.float64).dtype)

2)COOTensor

indices = Tensor([[0,1],[1,2]],dtype=mindspore.int32)

values = Tensor([1,2],dtype=mindspore.float32)

shape =(3,4)

coo_tensor=COOTensor(indices, values, shape)

print(coo_tensor.values)

print(coo_tensor.indices)

print(coo_tensor.shape)

print(coo_tensor.astype(mindspore.float64).dtype)