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)