Mindspore学习记录

Mindspore的张量学习
#导入需要的模块和接口
import numpy as np
from mindspore import ops
from mindspore import Tensor, context
from mindspore import dtype as mstype
from mindspore.ops import operations as ops
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
#初始化张量
#根据数据直接生成
x = Tensor(0.1)
#从numpy数组生成
arr = np.array([1,0,1,0])
x_np = Tensor(arr)
print(x_np,x)
#继承另一个张量的属性，形成新的张量
oneslike = ops.OnesLike()
x = Tensor(np.array([[0,1],[2,1]]).astype(np.int32))
output = oneslike(x)
print(output)
#输出指定大小的恒定张量 shape是张量的尺寸元组，确定输出的张量的维度
shape =(2,2)
ones=ops.Ones()
output = ones(shape,mstype.float32)
print(output)
z=ops.Zeros()
output=z(shape,mstype.float32)
print(output)
#Tensor初始化时，可指定dtype，如mstype.int32、mstype.float32、mstype.bool_等。

#张量的属性
#形状（shape）和数据类型（dtype）
t=Tensor(np.zeros([1,2,3]),mstype.float32)
print(format(t.dtype))
print(format(t.shape))

#张量的运算
#索引和切片:
t=Tensor(np.array([[0,1],[2,3]]).astype(np.float32))
print(format(t[0]))
print(format(t[:,0]))
print(format(t[...,-1]))
#Concat将给定维度一系列张量连接起来：
data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
op = ops.Concat()
output = op((data1, data2))
print(output)
#Stack从另一个维度将两个张量合并起来：
data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
op = ops.Stack()
output = op([data1, data2])
print(output)
#相乘：
input_x = Tensor(np.array([1.0, 2.0, 3.0]), mstype.float32)
input_y = Tensor(np.array([4.0, 5.0, 6.0]), mstype.float32)
mul = ops.Mul()
output = mul(input_x, input_y)
print(output)

#张量转换成numpy
zeros = ops.Zeros()
output = zeros((2,2), mstype.float32)
print("output: {}".format(type(output)))
n_output = output.asnumpy()
print("n_output: {}".format(type(n_output)))
#numpy转换成张量
output = np.array([1, 0, 1, 0])
print("output: {}".format(type(output)))
t_output = Tensor(output)
print("t_output: {}".format(type(t_output)))


#mindspore张量支持数据类型:int8、int16、int32、int64、uint8、uint16、uint32、uint64、float16、float32、float64、bool_
#在MindSpore的运算处理流程中，Python中的int数会被转换为定义的int64类型，float数会被转换为定义的float32类型。
#接口:dtype_to_nptype：将MindSpore的数据类型转换为NumPy对应的数据类型。
#dtype_to_pytype：将MindSpore的数据类型转换为Python对应的内置数据类型。
#pytype_to_dtype：将Python内置的数据类型转换为MindSpore对应的数据类型。

#运算：算术运算：加（+）、减（-）、乘（*）、除（/）、取模（%）、幂次方（**）、整除（//）
#逻辑运算：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）
#方法：len()：返回张量的长度。str()：返回张量的字符串表达。repr()：返回张量的字符串表达，供解释器读取。hash()：获取张量的哈希值。all(axis, keep_dims)：在指定维度上通过and操作进行归约，axis代表归约维度，keep_dims表示是否保留归约后的维度。
#any(axis, keep_dims)：在指定维度上通过or操作进行归约，参数含义同all。asnumpy()：将Tensor转换为NumPy的array。
#sum(axis, dtype, keepdims, initial): 在指定维度上对张量进行归约求和，axis代表归约维度，dtype代表输出的数据的类型，keepdims表示是否保留归约后的维度, initial表示规约求和开始前的初始值。

#张量生成
#生成具有相同元素的数组：
input_x = np.full((2, 3), 6, np.float32)
print(input_x)
#生成某个范围数值的数组：
input_x = np.arange(0, 5, 1)
print(input_x)
#生成特殊类型的数组：
input_x = np.tri(3, 3, 1)
print(input_x)
#数组维度变换、分割、拼接
input_x = np.arange(10).reshape(5, 2)
output = np.transpose(input_x)
print(output)

input_x = np.ones((1, 2, 3))
output = np.swapaxes(input_x, 0, 1)
print(output.shape)

input_x = np.arange(9)
output = np.split(input_x, 3)
print(output)
#求平均值：
input_x = np.arange(6).astype('float32')
output = np.mean(input_x)
print(output)
#指数：自然常数e的input_x次方
input_x = np.arange(5).astype('float32')
output = np.exp(input_x)
print(output)
#加法：
input_x = np.full((3, 2), [1, 2])
input_y = np.full((3, 2), [3, 4])
output = np.add(input_x, input_y)
print(output)
#矩阵乘法：
input_x = np.arange(2*3).reshape(2, 3).astype('float32')
input_y = np.arange(3*4).reshape(3, 4).astype('float32')
output = np.matmul(input_x, input_y)
print(output)