比如订阅的这个盘古大模型，部署后启动时报错：  根据报错信息，首先想解决一下Numpy的版本问题，（截图显示的numpy的包的版本不符合要求 最低要1.16.5-1.23.0 而检测到安装的是1.16.2） 但是订阅来的模型，没有办法修改运行时依赖，也就是无法指定去安装指定的numpy版本  这里是灰的。

简介在深度学习数据处理过程中经常会用到的四个科学计算的基础库，分别是：NumPy、Pandas、Matplotlib和SciPy。本篇将先分享下Numpy的介绍和个人的学习步骤。NumPyNumPy大概是是数据处理中使用次数最多的计算库，它提供了很多的基础计算，按照NumPy官网的说明：NumPy是一个功能强大的Python库，主要用于对多维数组执行计算。NumPy这个词来源于两个单词-- Numerical和Python。NumPy提供了大量的库函数和操作，可以轻松地进行数值计算。安装：安装非常的简单，内存占用也非常小，直接在自己的python环境下‘pip install numpy’就可以安装，几乎不会存在安装失败。安装后简单检验下导入使用，这样便是正常的。接下来就是入门教程，教程中说到NumPy是Python中的一个运算速度非常快的一个数学库，它非常重视数组。它允许你在Python中进行向量和矩阵计算。NumPy绝对是科学Python成功的关键之一，如果你想要进入Python中的数据科学和/或机器学习，你就要必须学习它。创建数组既然它都这么说了，这里就从创建一个数组开始。图中是四种简单的创建数组的方法，这里我们创建的是一维数组，可以直接把列表或者元组传递给array()函数，创建出的数组是一样的。arange()函数可以传递进去范围，从0开始到参数的前一位的所以整数。linspace()函数主要体现出数组的**症特性，即使其中有长度不同的数，也会按照统一的宽度显示，非常整齐。再试试创建个二维的数组玩一玩，首先进行了一次错误的尝试，这里将两个列表传递给了array()函数，出现以下报错。很明显array()函数只要一个参数，所以可以在列表里再创建几组列表，如下面图中所示。创建成功了，元素的位置依然是非常的对齐，所以创建数组的维度和外边包装的列表层数有关，这里用列表中括号包裹了两层，就创建了二维的数组。在想要查看某一个位置的元素时可以根据坐标的方法。根据测试，左上角是**(0,0)的位置，其中的第一个0表示所在行，第二个0表示列。如果是三维的数组呢，继续试一试。创建出来了，三层的列表中括号一定要查清楚哦。这里对位置查询有不太明白的，可以参考上面方法，上面采取的从**开始查找并控制两个参数不变改变另一个参数的方法。接下来再试一试基本的操作符，看到这里的时候突然有种“欲练此功，必先自宫，如不自宫，也能成功”的感觉，害我在创建三维数组的时候数了那么多层的中括号。简单的方法试一试。数组计算创建没有问题了，直接reshape就能够设置了数组的维度。当然不能仅仅止步于数组的创建上，我们最终需要做的就是运算数组，这里还从最基本的运算方法‘+’‘-’‘*’‘/’试一试。以上计算都冇问题，在根据条件对比两个数组时也得到了想要的结果，继续试试特殊的运算符。上面的max()、min()和sum()都没有问题，而且很好理解规则。其中的cumsun()的计算规则是从前到后一个累加计算，dot()函数的计算有些不太直观的看出来，这里解释了详细的计算步骤，供大家理解。以b.dot(a)为例，diy下计算过程[603=63*0+45*3+78*6  789=63*1+45*4+78*7  975=63*2+45*5+78*8 240=98*0+12*3+34*6  384=98*1+12*4+34*7  528=98*2+12*5+34*8  267=52*0+17*3+36*6  372=52*1+17*4+36*7  477=52*2+17*5+36*8]如果是a.dot(b)就是交换下计算的顺序。数组索引根据我们的条件筛选出符合的元素。简单的小试，根据下标进行的索引。再根据判断条件试试总结本篇内容为Numpy的初级使用，主要尝试了Numpy的安装、创建数组、数组计算和索引的四个部分。MindSpore深度学习框架中也提供了Numpy的接口，后续将会结合使用，并逐渐深入学习使用Numpy的用法，也将继续给大家分享。欢迎大家留言讨论~

1. MindSpore框架的SciPy模块    SciPy 是基于NumPy实现的科学计算库，主要用于数学、物理学、生物学等科学以及工程学领域。诸如高阶迭代，线性代数求解等都会需要用到SicPy。SciPy大体上有数值最优化、线性代数、积分、插值、信号处理、常微分方程求解等计算求解模块。    原生的SciPy科学计算库仅可CPU平台下使能，对于GPU、Ascend等计算平台无法使用且没有高效的实现。MindSpore是以Python作为表达语言的AI框架，能够合理利用GPU和Ascend的计算能力进行高效计算，并且MindSopre提供了SciPy模块。mindsopre.scipy是MindSpore基于mindspore.numpy和自研算子实现的科学计算库，不仅兼容原生的SciPy能在CPU平台高效运行，而且支持在GPU、Ascend等平台加速计算。    mindspore.scipy在CPU后端不仅能借助Minspore底层高效的CPU算子而且针对GPU平台也自实现了一系列的GPU底层高效算子。在GPU场景下能够提升硬件算力利用率，大幅提升科学计算的速度。随着后续的更新迭代，Ascend平台上也会使能高性能的mindspore.scipy模块。    除支持在不同硬件平台加速计算外，mindspore.scipy的接口定义与原生的SciPy保持高度一致，而当前业界已知的TensorFlow和PyTorch等框架中对于科学计算的接口支持与原生SciPy的接口对比存在差异。对于当前MindSpore已经支持的接口，原生的SciPy实现可以直接替换成mindspore.scipy的实现（后面的例子可以看到）。接口定义的高度一致最大程度地降低用户的迁移成本，提高minspore.scipy的易用性。2.安装mindspore.scipy    MindSpore的SciPy模块是作为科学计算的组件嵌入在MindSpore中的。当用户成功安装MindSpore框架后，minspore.scipy也会随之安装。MindSpore的安装命令由下图所示。     推荐使用采用pip的方式完成MindSpore的安装。值得注意的是，mindspore.scipy目前仅支持1.6.0及以上的版本，并且支持的平台仅包含CPU(Linux-x86_64)以及GPU(Linux-x86_64)，Windows以及Ascend平台目前尚未支持。mindspore.scipy还在不断的发展，在后续的更新迭代中会逐渐更丰富、更高效、更便捷的用户接口以及更多计算平台。Linux系统下CPU的pip安装命令为:    pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.6.0/MindSpore/cpu/x86_64/mindspore-1.6.0-cp37-cp37m-linux_x86_64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simpleLinux 系统下GPU的pip安装命令为:   pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.6.0/MindSpore/cpu/x86_64/mindspore-1.6.0-cp37-cp37m-linux_x86_64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple安装成功后显示的界面如下：import mindspore import mindspore.scipy print(mindspore.__version__)如果输出1.6.0并且没有错误提示的话，说明mindspore.scipy正确安装了。除了上述的pip命令安装，还可以用别的方式（例如源码）进行安装，详细的执行步骤可以参考https://www.mindspore.cn/install。3.如何使用mindspore.scipy    从1,2小节可知，mindspore.scipy的接口是与原生SciPy高度对齐的，以下是一个简单的例子来展示如何极小程度修改原生SciPy的脚本，使能GPU计算。   以下代码是使用原生NumPy和SciPy计算一个正定对称的实数矩阵进行cholesky分解和求解线性方程的过程：import numpy as np from scipy.linalg import cho_factor as cho_factor from scipy.linalg import cho_solve as cho_solve a = np.array([[9., 3., 1., 5.], [3., 7., 5., 1.], [1., 5., 9., 2.], [5., 1., 2., 6.]]) b = np.array([1., 1., 1., 1.]) c, low = cho_factor(A) # 计算 A = L L* x = cho_solve((c, low), b) # 计算 A x = b print(np.dot(A, x) - b) # 输出 A x - b 是否为0运行上述脚本输出为：[0.00000000e+00 2.22044605e-16 0.00000000e+00 0.00000000e+00] 上述脚本中的分解和求解方程只能通过CPU进行计算，因为原生NumPy和SciPy只能在CPU上运行。安装了GPU下的MindSpore之后，将import的包改为mindspore.scipy，便可在GPU下对矩阵进行运算。修改后的脚本为：import mindspore.numpy as np # 修改为mindspore.numpy from mindspore.scipy.linalg import cho_factor as cho_factor # 修改为mindspore.scipy from mindspore.scipy.linalg import cho_solve as cho_solve # 修改为mindspore.scipy a = np.array([[9., 3., 1., 5.], [3., 7., 5., 1.], [1., 5., 9., 2.], [5., 1., 2., 6.]]) b = np.array([1., 1., 1., 1.]) c, low = cho_factor(A) x = cho_solve((c, low), b) print(np.dot(A, x) - b)运行上述脚本，输出结果为：[-5.9604645e-08 0.0000000e+00 0.0000000e+00 -5.9604645e-08] 值得注意的是，mindspore.numpy.array默认构造的浮点类型是float32，如果需要更高的精度，用户可以将对应输入数据类型指定为float64，即a = np.array([[9., 3., 1., 5.], [3., 7., 5., 1.], [1., 5., 9., 2.], [5., 1., 2., 6.]], dtype=np.float64)若用户使用mindspore.scipy时存在编译时间过长的问题，可以尝试使用动态图模式运行MindSpore。mindspore.scipy的接口支持动静态图两种模式运行。默认情况下，MindSpore的运行是图模式（GRAPH_MODE），用户进需要输入代码，即可切换为动态图模式（PYNATIVE_MODE）：from mindspore import context context.set_context(mode=context.PYNATIVE_MODE)关于cholesky分解，mindspore.scipy.linalg中有mindspore.scipy.linalg.cho_factor、mindspore.scipy.linalg.cholesky两个对外接口，对应的api描述可在https://www.mindspore.cn/docs/api/zh-CN/master/api_python/scipy/mindspore.scipy.linalg.cho_factor.html#mindspore.scipy.linalg.cho_factor 中查看。4.更多的mindspore.scipy接口    更多具体的接口开放信息，可以查看对应的官方文档链接。        目前mindspore.scipy模块初步完成了scipy.linalg(线性代数)、scipy.sparse.linalg(稀疏线性代数)、scipy.optimize(数值优化)这几个模块中的部分基础接口的开发。接口和文档都在持续完善中，最新、最全面的接口信息均可在https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.scipy.html 中查看。其中包含了mindspore.scipy模块支持的所有接口，以及每个接口对应的输入输出，简单用例代码等。QA     Q1：我安装了MindSpore 1.5的cpu 版本，为什么无法使用SciPy？    A1：mindspore.scipy 是r1.6以后开源到MindSpore的，用户可以安装更新的版本(r1.6)或者master上的MindSpore源码进行安装体验。    Q2:  我安装了MindSpore 1.6的cpu windows版本，为什么无法使用SciPy？    A2：mindspore.scipy 当前还未支持windows操作系统，后续会加紧迭代加入，可以使用linux-x86-64下的cpu或者gpu版本安装体验。    Q3：我想用mindspore.scipy模块下的xxx API，但是在官网的并未查询到相应的支持，怎么办？    A3：如果在官网的最新介绍中没有查询到xxx API,可以再MindSpore的社区提issue给社区维护人员，我们会根据计划尽快开发xxx API。         MindSpore码云：https://gitee.com/mindspore/mindspore         MindSpore官网：https://www.mindspore.cn

MindStudio运行python脚本时，出现no module named ‘numpy’错误。在哪里配置解决这个问题呢？

【功能模块】离线模型推理功能【操作步骤&问题现象】1、air转om格式成功了2、运行主函数在导入数据部分报错，对于报错，验证过data.size就是int，不知道为什么会报这个错【截图信息】【日志信息】（可选，上传日志内容或者附件）

原文链接：https://blog.csdn.net/qq_49821869/article/details/122388098一、Numpy的属性ndim 维度shape 形状dtype 类型size 大小array = np.array([[1,2,3],                 [4,5,6]])print(array)123[[1 2 3] [4 5 6]]12print(array.ndim) # 维度121print(array.shape) # 形状1(2, 3)1print(array.dtype) # 元素类型1int641print(array.size) # 大小161二、创建array指定数据属性创建一维数据、二维数据zeros 全0、 ones 全1、 empty 全接近于0、 arange 等差一维数组reshape 改变矩阵形状a = np.array([1,2,3],dtype=np.int32) # 指定数据类型print(a)12[1 2 3]1b = np.array([1,2,3],dtype=np.float) # 指定数据类型 print(b.dtype)12float641c = np.array([1,2,3]) # 一维数据print(c)12[1 2 3]1d = np.array([[1,2,3],[4,5,6]]) # 二维数据print(d)12[[1 2 3] [4 5 6]]12zero = np.zeros((2,3)) # 生成2行3列的全0矩阵print(zero)12[[0. 0. 0.] [0. 0. 0.]]12one = np.ones((3,4)) # 生成3行4列的全1矩阵print(one)12[[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]]123empty = np.empty((3,3)) # 生成3行3列的全都接近于0（不等于0）的矩阵print(empty)12[[6.92430951e-310 4.67278860e-310 6.92414190e-310] [6.92414190e-310 6.92414190e-310 6.92414190e-310] [6.92414190e-310 6.92414190e-310 3.95252517e-322]]123e = np.arange(5) print(e)12[0 1 2 3 4]1f = np.arange(4,12)print(f)12[ 4  5  6  7  8  9 10 11]1g = np.arange(4,12,2)print(g)12[ 4  6  8 10]1h = np.arange(8).reshape(4,2) # 重新定义矩阵的形状print(h)12[[0 1] [2 3] [4 5] [6 7]]三、Numpy的运算‘+ - * / // ** % >’np.dot(arr1,arr2) == arr1.dot(arr2) 矩阵乘法arr1.T == np.transpose(arr1)arr1 = np.array([1,2,3])arr2 = np.array([4,5,6])print(arr1,arr2)123[1 2 3] [4 5 6]1print(arr1+arr2)1[5 7 9]1print(arr1-arr2)1[-3 -3 -3]1print(arr1*arr2)1[ 4 10 18]1print(arr1/arr2)1[0.25 0.4  0.5 ]1print(arr1**arr2)1[  1  32 729]1print(arr1 // arr2)1[0 0 0]1print(arr1 % arr2)1[1 2 3]1print(arr1 + 1)1[2 3 4]1print(arr1 * 3)1[3 6 9]1print(arr1 > 3)1[False False False]1arr3 = np.arange(6).reshape(3,2)arr4 = np.arange(6).reshape(2,3)12np.dot(arr3,arr4) # 矩阵乘法1array([[ 3,  4,  5],       [ 9, 14, 19],       [15, 24, 33]])arr3.dot(arr4)1array([[ 3,  4,  5],       [ 9, 14, 19],       [15, 24, 33]])123print(arr3.T) # 矩阵转置1[[0 2 4] [1 3 5]]12print(arr3)1[[0 1] [2 3] [4 5]]123print(np.transpose(arr3))1[[0 2 4] [1 3 5]]12四、随机数生成及矩阵的统计np.random.random 0-1的随机数np.random.normal 符合正态分布的随机数np.random.randint(0,10,size=()) 生成从0到10的size形状的随机整数np.sum() 求和、np.mean() 求平均值 np.max() 求最大值、 np.min() 求最小值np.sort() 排序、np.sqrt() 开方、 np.median() 求中位数、 axis=0 0行1列np.argmin() 求最小值的下标、np.argmax() 求最大值下标arr1 = np.random.random((2,2)) # 生成2行2列从0到1的随机数print(arr1)12[[0.70322893 0.62660424] [0.10822154 0.70288038]]12arr2 = np.random.normal(size=(3,3)) # 生成3行3列的符合标准正态分布的随机数print(arr2)12[[ 0.27050106  0.66089326  0.05234379] [ 0.81437662 -0.41467658  2.49832908] [-0.17560416  0.42175065 -1.02400744]]123arr3 = np.random.randint(0,10,size=(4,3)) # 生成4行3列的从0到10的随机整数print(arr3)12[[4 1 9] [8 7 9] [9 1 9] [5 0 9]]np.sum(arr1) # 求和 == arr1.sum()12.14093509458232761np.min(arr1) # 求最小值 == arr1.min()10.108221541469485151np.max(arr1) # 求最大值 == arr1.max()10.70322892713526411np.sum(arr1,axis=0) # 对列求和1array([0.81145047, 1.32948463])1np.sum(arr1,axis=1) # 对行求和1array([1.32983317, 0.81110192])1np.argmin(arr1) # 求最小值的索引 从0开始121np.argmax(arr1) # 求最大值的索引101np.mean(arr1) # 求平均值 == np.sum(arr1) / arr1.size == arr1.mean()10.53523377364558191np.median(arr1) # 求中位数10.66474231298878931np.sqrt(arr1) # 开方 == arr1 ** 0.51array([[ True,  True],       [ True,  True]])12np.sort(arr1) # 排序 每一行是升序1array([[0.62660424, 0.70322893],       [0.10822154, 0.70288038]])12np.clip(arr1,0.5,0.6) # 小于0.5变成0.5 大于0.6就变成0.61array([[0.6, 0.6],       [0.5, 0.6]])12五、Numpy索引索引arr1[1,2] == arr1[1][2]切片 [:,:] 逗号前面代表行，后面代表列遍历行、遍历列、遍历元素print(arr1)1[[0.62660424 0.70322893] [0.10822154 0.70288038]]12print(arr1[0]) 1[0.62660424 0.70322893]1print(arr1[0][1]) == print(arr1[0,1])  10.70322892713526411print(arr1[:,1]) # 第二列1[0.70322893 0.70288038]print(arr1[1,1])0.7028803828361643for i in arr1: # 迭代行    print(i)[0.62660424 0.70322893][0.10822154 0.70288038]for i in arr1.T: # 迭代列    print(i)[0.62660424 0.10822154][0.70322893 0.70288038]arr1.reshape(1,-1)array([[0.62660424, 0.70322893, 0.10822154, 0.70288038]])for i in arr1.flat: # 迭代所有元素    print(i)0.62660424314141430.70322892713526410.108221541469485150.7028803828361643六、合并一维数据合并 np.vstack 垂直合并、 np.hstack 水平合并多维数据合并 np.concatenate((arr1,arr2)) # 默认垂直合并、np.concatenate((arr1,arr2),axis=1) # 水平合并增加一个新的维度np.newaxis变成nd数据 np.atleast_nd n可以为1、2、3、4…arr1 = np.arange(3)arr2 = np.arange(3)print(arr1,arr2)[0 1 2] [0 1 2]np.vstack((arr1,arr2)) # 垂直合并array([[0, 1, 2],       [0, 1, 2]])np.hstack((arr1,arr2)) # 水平合并array([0, 1, 2, 0, 1, 2])np.concatenate((arr1,arr2)) array([0, 1, 2, 0, 1, 2])arr3 = np.arange(4).reshape(2,2) np.concatenate((arr3,arr3))array([[0, 1],       [2, 3],       [0, 1],       [2, 3]])np.concatenate((arr3,arr3),axis=1)  # 该方法不能对1维数据进行垂直合并array([[0, 1, 0, 1],       [2, 3, 2, 3]])arr1.T # 一维数据不能转置array([0, 1, 2])arr1[np.newaxis,:] # 在行这个维度上增加一个维array([[0, 1, 2]])arr1[:,np.newaxis]array([[0],       [1],       [2]])np.atleast_2d(arr1)array([[0, 1, 2]])七、分割等分 np.split 0行1列不等分 np.array_split 0行1列垂直分np.hsplit、水平分np.vsplitarr1 = np.arange(12).reshape(3,4)print(arr1)[[ 0  1  2  3] [ 4  5  6  7] [ 8  9 10 11]]np.split(arr1,2,axis=1) # 竖直方向分割，平均为2份 1[array([[0, 1],        [4, 5],        [8, 9]]), array([[ 2,  3],        [ 6,  7],        [10, 11]])]12345np.split(arr1,3,axis=0) # 水平方向分割，平均为3份1[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]1np.split(arr1,3,axis=1) # 竖直方向分割，平均为3份1---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)/opt/conda/lib/python3.6/site-packages/numpy/lib/shape_base.py in split(ary, indices_or_sections, axis)    866     try:--> 867         len(indices_or_sections)    868     except TypeError:TypeError: object of type 'int' has no len()During handling of the above exception, another exception occurred:ValueError                                Traceback (most recent call last)<ipython-input-112-2e738d9e1da7> in <module>----> 1 np.split(arr1,3,axis=1) # 水平方向分割，平均为3份<__array_function__ internals> in split(*args, **kwargs)/opt/conda/lib/python3.6/site-packages/numpy/lib/shape_base.py in split(ary, indices_or_sections, axis)    871         if N % sections:    872             raise ValueError(--> 873                 'array split does not result in an equal division')    874     return array_split(ary, indices_or_sections, axis)    875 ValueError: array split does not result in an equal divisionnp.array_split(arr1,3,axis=1) # 竖直方向分割，不等分为3份1[array([[0, 1],        [4, 5],        [8, 9]]), array([[ 2],        [ 6],        [10]]), array([[ 3],        [ 7],        [11]])]np.vsplit(arr1,3) # == np.split(arr1,3,axis=0) # 水平方向分割，平均为3份1[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]1np.hsplit(arr1,2)# == np.split(arr1,2,axis=1) # 竖直方向分割，平均为2份 1[array([[0, 1],        [4, 5],        [8, 9]]), array([[ 2,  3],        [ 6,  7],        [10, 11]])]12345八、深浅拷贝Python是引用传递，默认内存共享arr1.copy() 深拷贝 完全独立开arr11array([[ 0,  1,  2,  3],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr2 = arr11arr2[0] = 0arr212array([[ 0,  0,  0,  0],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr11array([[ 0,  0,  0,  0],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr3 = arr1.copy() # 深拷贝1arr3[0] = 11arr31array([[ 1,  1,  1,  1],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])123arr11array([[ 0,  0,  0,  0],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])

NumPy 1.22.0 是一个大型版本，其中包含153位贡献者的工作，分布在609个拉取请求中。此版本进行多项改进，其中值得关注的有：主命名空间的注解基本完成，上游是一个不断变化的目标，因此可能会有进一步的改进，但主要工作已经完成。这可能是此版本中用户最明显的增强功能。提供了提议的 Array-API 的初步版本、NumPy 现在有一个 DLPack 后端。此外，该版本的Python 版本为 3.8-3.10，Python 3.7已被删除。

华为的老师们好，我们遇到的问题是在昇腾1.0.9.alpha版本驱动的代码仓的环境下，如何将通过网络udp接收到的numpy.ndarray格式的图片转换为深度学习网络需要的AclImage类格式的图片，希望华为的老师们可以指导一下，谢谢

NumPy 是Python 编程语言的库，增加了对大型、多维数组和矩阵的支持，以及对这些数组进行操作的大量高级数学函数集合。将Torch中Tensor 转换为 NumPy 数组，反之亦然是轻而易举的！Torch Tensor 和 NumPy 数组将共享它们的底层内存位置 ，改变一个将改变另一个。「将 Torch 张量转换为 NumPy 数组：」a = torch.ones(5) print(a)输出：tensor([1., 1., 1., 1., 1.])b = a.numpy() print(b)输出：[1., 1., 1., 1., 1.]让我们执行求和运算并检查值的变化：a.add_(1) print(a) print(b)输出：tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]「将 NumPy 数组转换为 Torch 张量：」import numpy as no a = np.ones(5) b = torch.from_numpy(a) np.add(a, 1, out=a) print(a) print(b)输出：[2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

**MindSpore中张量的使用** 张量（Tensor）是MindSpore网络运算中的基本数据结构。张量中的数据类型可参考[dtype](https://www.mindspore.cn/docs/programming_guide/zh-CN/r1.3/operators.html "dtype")。 不同维度的张量分别表示不同的数据，0维张量表示标量，1维张量表示向量，2维张量表示矩阵，3维张量可以表示彩色图像的RGB三通道等等。 MindSpore张量支持不同的数据类型，包含int8、int16、int32、int64、uint8、uint16、uint32、uint64、float16、float32、float64、bool_，与NumPy的数据类型一一对应。 在MindSpore的运算处理流程中，Python中的int数会被转换为定义的int64类型，float数会被转换为定义的float32类型。 详细的类型支持情况请参考：https://www.mindspore.cn/docs/api/zh-CN/r1.3/api_python/mindspore.html#mindspore.dtype。 首先导入需要的模块和接口，如下所示： ```python import numpy as np from mindspore import Tensor from mindspore import dtype as mstype ``` 初始化张量 张量的初始化方式有多种，构造张量时，支持传入Tensor、float、int、bool、tuple、list和NumPy.array类型。 根据数据直接生成 可以根据数据创建张量，数据类型可以设置或者自动推断。 ```python x = Tensor(0.1) ``` 从NumPy数组生成 可以从NumPy数组创建张量。 ```python arr = np.array([1, 0, 1, 0]) x_np = Tensor(arr), ``` 初始值是NumPy.array，则生成的Tensor数据类型与之对应。 继承另一个张量的属性，形成新的张量 ```python from mindspore import ops oneslike = ops.OnesLike() x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32)) output = oneslike(x) print(output) ``` 输出指定大小的恒定值张量 shape是张量的尺寸元组，确定输出的张量的维度。 ```python from mindspore.ops import operations as ops shape = (2, 2) ones = ops.Ones() output = ones(shape, mstype.float32) print(output) zeros = ops.Zeros() output = zeros(shape, mstype.float32) print(output) ``` Tensor初始化时，可指定dtype，如mstype.int32、mstype.float32、mstype.bool_等。 **张量和Numpy的互相转换** NumPy 是 Python 语言的一个扩展程序库,支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。所以下面展示下MindSpore中张量和Numpy类型的互相转换。 张量转换为NumPy ```python 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))) ``` 输出： ```python output: n_output: ``` NumPy转换为张量 ```python output = np.array([1, 0, 1, 0]) print("output: {}".format(type(output))) t_output = Tensor(output) print("t_output: {}".format(type(t_output))) ``` 输出： ```python output: t_output: ``` **张量的属性和运算** 张量之间有很多运算，包括算术、线性代数、矩阵处理（转置、标引、切片）、采样等，下面介绍其中几种操作，张量运算和NumPy的使用方式类似。 标准的类似NumPy的索引和切片： ```python tensor = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32)) print("First row: {}".format(tensor[0])) print("First column: {}".format(tensor[:, 0])) print("Last column: {}".format(tensor[..., -1])) ``` Concat将给定维度上的一系列张量连接起来。 ```python 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则是从另一个维度上将两个张量合并起来。 ```python 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) ``` 普通运算： ```python 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) ``` 参考文献：[MindSpore NumPy函数](https://www.mindspore.cn/docs/programming_guide/zh-CN/r1.3/operators.html "MindSpore NumPy函数") [Tensor](https://www.mindspore.cn/docs/programming_guide/zh-CN/r1.3/operators.html "Tensor")

```C++ // 导入自定义.h文件 #include "minddata/dataset/kernels/py_func_op.h" // 导入系统标准库文件 #include #include // 导入自定义.h文件 #include "minddata/dataset/core/tensor.h" #include "minddata/dataset/kernels/tensor_op.h" #include "minddata/dataset/util/status.h" // 双重命名空间 namespace mindspore { namespace dataset { Status PyFuncOp::Compute(const TensorRow &input, TensorRow *output) { IO_CHECK_VECTOR(input, output); // PyFunc 调用成功 Status ret = Status(StatusCode::kSuccess, "PyFunc Call Succeed"); { // 获取 Python GIL py::gil_scoped_acquire gil_acquire; if (Py_IsInitialized() == 0) { // Python 解释器完成 ret = Status(StatusCode::kMDPythonInterpreterFailure, "Python Interpreter is finalized"); goto ComputeReturn; } try { // 将输入张量向量转换为 numpy 数组向量 py::tuple input_args(input.size()); py::object ret_py_obj; if (input.size() > 0) { // 遍历 for (size_t i = 0; i input.size(); i++) { py::array new_data; RETURN_IF_NOT_OK(input.at(i)->GetDataAsNumpy(&new_data)); // 可能的 memcpy 在这里 input_args[i] = new_data; } // 调用python函数 ret_py_obj = this->py_func_ptr_(*input_args); } else { ret_py_obj = this->py_func_ptr_(); } if (output_type_ != DataType::DE_UNKNOWN) { RETURN_IF_NOT_OK(CastOutput(ret_py_obj, output)); } else { if (py::isinstance(ret_py_obj)) { // 在 n-m 映射的情况下，返回值将是一个 numpy 数组的元组 py::tuple ret_py_tuple = ret_py_obj.cast(); // 同时迭代两个容器进行内存复制 for (size_t i = 0; i ret_py_tuple.size(); i++) { py::object ret_py_ele = ret_py_tuple[i]; // 如果pyfunc超时，则对象为none if (ret_py_ele.is_none()) { MS_LOG(INFO) "PyFunc execute time out"; goto TimeoutError; } if (!py::isinstance(ret_py_ele)) { goto ShapeMisMatch; } std::shared_ptr out; RETURN_IF_NOT_OK(Tensor::CreateFromNpArray(ret_py_ele.cast(), &out)); output->push_back(out); } } else if (py::isinstance(ret_py_obj)) { // 在 n-1 映射的情况下，返回值将是一个 numpy 数组 std::shared_ptr out; RETURN_IF_NOT_OK(Tensor::CreateFromNpArray(ret_py_obj.cast(), &out)); output->push_back(out); // 尾插 } else { goto ShapeMisMatch; } } } catch (const py::error_already_set &e) { ret = Status(StatusCode::kMDPyFuncException, e.what()); } } ComputeReturn: return ret; ShapeMisMatch: // PyFunc 应该返回一个 numpy 数组或一个 numpy 数组元组 ret = Status(StatusCode::kMDShapeMisMatch, __LINE__, __FILE__, "PyFunc should return a numpy array or a numpy array tuple"); goto ComputeReturn; TimeoutError: // PyFunc 执行超时 ret = Status(StatusCode::kMDTimeOut, __LINE__, __FILE__, "PyFunc execute time out"); goto ComputeReturn; } Status PyFuncOp::CastOutput(const py::object &ret_py_obj, TensorRow *output) { try { std::shared_ptr out; switch (output_type_) { case DataType::DE_INT32: RETURN_IF_NOT_OK(Tensor::CreateEmpty(TensorShape({1}), DataType(DataType::DE_INT32), &out)); RETURN_IF_NOT_OK(out->SetItemAt({0}, ret_py_obj.cast())); break; case DataType::DE_BOOL: RETURN_IF_NOT_OK(Tensor::CreateScalar(ret_py_obj.cast(), &out)); break; default: // 未找到指定数据类型的强制转换 RETURN_STATUS_UNEXPECTED("No cast for the specified DataType was found."); } output->push_back(out); // 尾插 } catch (const std::exception &e) { return Status(StatusCode::kMDUnexpectedError, e.what()); } return Status::OK(); } Status PyFuncOp::to_json(nlohmann::json *out_json) { nlohmann::json args; args["tensor_op_name"] = py_func_ptr_.attr("__class__").attr("__name__").cast(); args["is_python_front_end_op"] = true; *out_json = args; // 轻量级 return Status::OK(); } bool PyFuncOp::IsRandom() { bool random = true; if (py::hasattr(py_func_ptr_, "random") && py::reinterpret_borrow(py_func_ptr_.attr("random")) == false) random = false; return random; } } // 命名空间 dataset } // 命名空间 mindspore ```

在Python中，我们可以利用Numpy模块中的numpy.fft  轻松实现快速傅立叶变换（FFT）运算操作。在理解了傅里叶变换背后的基本理论之后，我们就可以研究如何控制频谱输出来处理图像了。首先，我们需要了解低/高通滤波器。低通滤波器低通滤波器是一种只允许低频谱通过的滤波器。图像中的低频谱意味着像素值变化缓慢。例如，图像中颜色变化较小的平滑区域（如新空白白纸的中心）被视为低频谱内容。由于低通滤波器的输出只允许低频通过，对噪声等高频谱内容进行了阻塞，使得处理后的图像具有较少的噪声像素。因此，低通滤波器被广泛应用于图像的去噪。高通滤波器相反，高通滤波器是只允许高频谱通过的滤波器。图像中的高频谱意味着像素值变化很大。例如，图像中颜色变化较大的边缘区域，如两张重叠的白纸和黑纸之间的边缘，被认为是高频谱内容。在图像中，通过做适当的重复计算来锐化原图像，能用适当的重复计算来锐化原始图像的图像，从高通滤波器的输出可获得图像中的边缘。这将增强原始图像的清晰度，使边缘更加清晰。从图e（5）和图f（5），我们可以注意到这两个滤波器呈现不同的特性。低通滤波器倾向于保留图像中的整体信息。另一方面，高通滤波器试图辨别出图像中的变化。在了解了前一节中的低通/高通滤波器的工作原理后，让我们继续认识滤波器形状理想的滤波器公式 (a): 在理想低通滤波器的公式中，D₀是合理常量，D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离在理想滤波器背后的概念非常简单：给定一个半径值D₀作为阈值，低通滤波器图（g）（1）在阈值下H（u，v）等于1，在阈值以上H（u，v）等于0。公式(b): 在理想高通滤波器的公式中，D₀是合理常量，D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离相反，高通滤波器图（g）（2）在阈值下H（u，v）等于0，在阈值以上H（u，v）等于1。巴特沃思（Btterworth）滤波器公式(c): 在Butterworth低通滤波器的公式中， D₀是一个合理常量， D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离与理想滤波器不同的是，巴特沃斯滤波器没有明显的不连续性，使得通过的频率和被过滤的频率之间有明显的边界。巴特沃斯滤波器在函数中引入了一个新的参数n。当操作n时，它影响着通过的频率和被过滤的频率之间边界的清晰程度。图（h）和图（i）公式(d): 在Butterworth高通滤波器的公式中， D₀是一个合理常量，D（u，v）是频域中一点（u，v）与频域矩形中心之间的距离

MindSpore中张量的使用 张量（Tensor）是MindSpore网络运算中的基本数据结构。张量中的数据类型可参考dtype。 不同维度的张量分别表示不同的数据，0维张量表示标量，1维张量表示向量，2维张量表示矩阵，3维张量可以表示彩色图像的RGB三通道等等。 MindSpore张量支持不同的数据类型，包含int8、int16、int32、int64、uint8、uint16、uint32、uint64、float16、float32、float64、bool_，与NumPy的数据类型一一对应。 在MindSpore的运算处理流程中，Python中的int数会被转换为定义的int64类型，float数会被转换为定义的float32类型。 详细的类型支持情况请参考：https://www.mindspore.cn/docs/api/zh-CN/r1.3/api_python/mindspore.html#mindspore.dtype。 首先导入需要的模块和接口，如下所示：import numpy as npfrom mindspore import Tensorfrom mindspore import dtype as mstype初始化张量 张量的初始化方式有多种，构造张量时，支持传入Tensor、float、int、bool、tuple、list和NumPy.array类型。 根据数据直接生成 可以根据数据创建张量，数据类型可以设置或者自动推断。 x = Tensor(0.1) 从NumPy数组生成 可以从NumPy数组创建张量。 arr = np.array([1, 0, 1, 0]) x_np = Tensor(arr) 初始值是NumPy.array，则生成的Tensor数据类型与之对应。 继承另一个张量的属性，形成新的张量from mindspore import ops oneslike = ops.OnesLike() x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32)) output = oneslike(x) print(output)输出指定大小的恒定值张量 shape是张量的尺寸元组，确定输出的张量的维度。from mindspore.ops import operations as opsshape = (2, 2)ones = ops.Ones()output = ones(shape, mstype.float32)print(output)zeros = ops.Zeros()output = zeros(shape, mstype.float32)print(output)Tensor初始化时，可指定dtype，如mstype.int32、mstype.float32、mstype.bool_等。张量和Numpy的互相转换 NumPy 是 Python 语言的一个扩展程序库,支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。所以下面展示下MindSpore中张量和Numpy类型的互相转换。张量转换为NumPyzeros = ops.Zeros()output = zeros((2,2), mstype.float32)print("output: {}".format(type(output)))n_output = output.asnumpy()print("n_output: {}".format(type(n_output)))输出：output: <class 'mindspore.common.tensor.Tensor'> n_output: <class 'numpy.ndarray'>NumPy转换为张量output = np.array([1, 0, 1, 0])print("output: {}".format(type(output)))t_output = Tensor(output)print("t_output: {}".format(type(t_output)))输出：output: <class 'numpy.ndarray'> t_output: <class 'mindspore.common.tensor.Tensor'>张量的属性和运算 张量之间有很多运算，包括算术、线性代数、矩阵处理（转置、标引、切片）、采样等，下面介绍其中几种操作，张量运算和NumPy的使用方式类似。标准的类似NumPy的索引和切片：tensor = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))print("First row: {}".format(tensor[0]))print("First column: {}".format(tensor[:, 0]))print("Last column: {}".format(tensor[..., -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)原文链接：https://forum.trustie.net/forums/4466/detail

【功能模块】在openEuler 20.09系统下安装 依赖包时出错，麻烦看看怎样才能安装这3个依赖包呢?谢谢，在centos 7.6下，可以安装成功。 yum -y install zlib* lapack* blas* python3.aa4 cmake3* boost_python* boost boost-devel numpy* python36-numpy flex bison【操作步骤&问题现象】1、2、【截图信息】【日志信息】（可选，上传日志内容或者附件）

【功能模块】win10 64位minspore 1.5python 3.7.5【操作步骤&问题现象】1、使用min函数时显示图模式不支持该函数     NameError: mindspore\ccsrc\pipeline\jit\parse\function_block.cc:190 HandleNamespaceInfo] The builtin function 'min' of python is not supported in graph mode.2、在类里使用numpy的函数时总是无故报错，在construct函数里更是显示     NotImplementedError: Mindspore does not support to use the numpy methods within the construct() or @ms_function decorated function in graph mode.【截图信息】【日志信息】（可选，上传日志内容或者附件）