1. 乾坤的静态引擎目前是否具有解包/脱壳的能力？如果没有，日后是否考虑加入？比如，对Inno Setup/自解压/NSIS打包，UPX这种简单压缩壳的解包脱壳能力。实现之后对通过FakeApp传播的白加黑可以提供pre-execution阶段的检测。2. 乾坤的静态引擎目前是否具备对脚本(vbs, js, ps1, AutoIT, etc.)的特征侦测能力？3. 乾坤是否考虑添加/增强引擎对感染型病毒的修复手段？

问题基本如题使用的具体规格是pytorch1.8-cuda10.2-cudnn7-ubuntu18.04，GPU等情况是：GPU: 1*T4(16GB)|CPU: 8核 32GB，在配置好了相关数据和文件之后，训练开始阶段报错“RuntimeError: cuDNN error: CUDNN_STATUS_NOT_INITIALIZED”。我猜想应该是和cuDNN的安装和版本适配有关，但实在是不清楚具体该怎么在Modelarts上完成配置，各位请不吝赐教QvQ

如题，有客户需要监控系统用在独栋别墅的安防，我想尽量方案做的有竞争力一些，因为客户对价格不是很敏感，但对是否适合自己的需求非常在意，所以求教各位！目前可知的需求，主要是安防方面，主要针对入侵检测、警告等，我能想到的应用场景就是智能识别，不是有人进入特定区域就报警，例如是家庭成员就不报警，狗狗等非人类也不报警；智能化方面，我想知道的就是能否方便接入homeassistant，实现各种想象中的智能，比如说随时随地能知道自己家的小猫等在哪个区域，当然是有视频覆盖的区域等等！另外，如果需要以上功能方便，需要多大的算力？16t，32t？还有，如果用这样的产品，是否一定需要购买有算力的监控摄像机？

【开源资料】XQTyer评估板例程使用手册链接：https://share.weiyun.com/8csewUvh 密码：8r9by7         XQ6657Z35/45-EVM（XQTyer 评估板）是一款基于 TI KeyStone 架构 C6000 系列 TMS320C6657双核C66x 定点/浮点 DSP以及 Xilinx Zynq-7000 系列 XC7Z035/045 SoC 处理器设计的高端异构多核评估板，由核心板与评估底板组成。

import os# os.environ['DEVICE_ID'] = '6'import numpy as npimport mindspore as msfrom mindspore import nnfrom mindspore import contextfrom mindspore import datasetfrom mindspore.train.callback import LossMonitorfrom mindspore.common.api import ms_functionfrom mindspore.ops import operations as Pfrom PIL import Image#当前实验选择算力为Ascend，如果在本地体验，参数device_target设置为"CPU”context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")#要筛选的分辨率条件targetWidth=426targetHeight=640targetChannal=3#读取animal文件夹下所有文件的名字rootDir='animal'fileNameList=['cat','elephant','sheep']label_map = { 'cat': 0, 'elephant': 1, 'sheep': 2}X,Y=[],[]for fileName in fileNameList: fileDir=rootDir+'/'+fileName #print(fileDir) imgNameList=os.listdir(fileDir) #print(imgNameList) for imgName in imgNameList: imgDir=fileDir+'/'+imgName img=Image.open(imgDir) img=np.array(img) if(len(img.shape)==3): width,height,channal=img.shape if width==targetWidth and height==targetHeight and channal==targetChannal:#符合筛选条件的样本留下放到X，其标签放到Y X.append(img.flatten()) Y.append(label_map[fileName])#类别#print(X,Y)#划分训练集和测试集合sampleNum=len(X)train_idx = np.random.choice(sampleNum, int(sampleNum*0.8), replace=False)#取80%的样本作为训练集test_idx = np.array(list(set(range(sampleNum)) - set(train_idx)))#剩下的样本作为测试集X_train=[X[i].astype(np.float32) for i in range(len(X)) if i in train_idx]Y_train=[Y[i] for i in range(len(Y)) if i in train_idx]X_test=[X[i].astype(np.float32) for i in range(len(X)) if i in test_idx]Y_test=[Y[i] for i in range(len(Y)) if i in test_idx]XY_train = list(zip(X_train, Y_train))ds_train = dataset.GeneratorDataset(XY_train, ['x', 'y'])# ds_train.set_dataset_size(sampleNum)ds_train = ds_train.shuffle(buffer_size=sampleNum).batch(32, drop_remainder=True)XY_test = list(zip(X_test, Y_test))ds_test = dataset.GeneratorDataset(XY_test, ['x', 'y'])ds_test = ds_test.batch(30)#具体作用#print(XY_test)for e in X_train: print(e.shape)net = nn.Dense(targetWidth*targetHeight, 3)loss = nn.loss.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')opt = nn.optim.Momentum(net.trainable_params(), learning_rate=0.05, momentum=0.9)model = ms.train.Model(net, loss, opt, metrics={'acc', 'loss'})model.train(25, ds_train, callbacks=[LossMonitor(per_print_times=ds_train.get_dataset_size())], dataset_sink_mode=False)metrics = model.eval(ds_test)print(metrics)本小白正学习如何使用Mindspore，打算用逻辑回归对图片进行分类。输入到回归模型的每个样本数据都是426*640的图片经过flatten后产生的数组，该数组的shape为(817920,)，X_train就是若干这样的数组组成的。构建完模型之后，开始训练时产生了如下的错误：[ERROR] ANALYZER(8534,ffffb5cca780,python):2022-11-30-10:59:18.593.719 [mindspore/ccsrc/pipeline/jit/static_analysis/async_eval_result.cc:66] HandleException] Exception happened, check the information as below.The function call stack (See file '/home/ma-user/work/rank_0/om/analyze_fail.dat' for more details):# 0 In file /home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/wrap/cell_wrapper.py(373) loss = self.network(*inputs) ^# 1 In file /home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/wrap/cell_wrapper.py(111) out = self._backbone(data) ^# 2 In file /home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/layer/basic.py(323) if len(x_shape) != 2:# 3 In file /home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/layer/basic.py(326) if self.has_bias:# 4 In file /home/ma-user/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/layer/basic.py(325) x = self.matmul(x, self.weight) ^---------------------------------------------------------------------------ValueError Traceback (most recent call last)/tmp/ipykernel_8534/2891349598.py in 1 model = ms.train.Model(net, loss, opt, metrics={'acc', 'loss'})----> 2 model.train(25, ds_train, callbacks=[LossMonitor(per_print_times=ds_train.get_dataset_size())], dataset_sink_mode=False) 3 metrics = model.eval(ds_test) 4 print(metrics)~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/train/model.py in train(self, epoch, train_dataset, callbacks, dataset_sink_mode, sink_size) 904 callbacks=callbacks, 905 dataset_sink_mode=dataset_sink_mode,--> 906 sink_size=sink_size) 907 908 def build(self, train_dataset=None, valid_dataset=None, sink_size=-1, epoch=1, jit_config=None):~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/train/model.py in wrapper(self, *args, **kwargs) 85 raise e 86 else:---> 87 func(self, *args, **kwargs) 88 return wrapper 89 ~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/train/model.py in _train(self, epoch, train_dataset, callbacks, dataset_sink_mode, sink_size) 540 self._check_reuse_dataset(train_dataset) 541 if not dataset_sink_mode:--> 542 self._train_process(epoch, train_dataset, list_callback, cb_params) 543 elif context.get_context("device_target") == "CPU": 544 logger.info("The CPU cannot support dataset sink mode currently."~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/train/model.py in _train_process(self, epoch, train_dataset, list_callback, cb_params) 792 cb_params.train_dataset_element = next_element 793 list_callback.step_begin(run_context)--> 794 outputs = self._train_network(*next_element) 795 cb_params.net_outputs = outputs 796 if self._loss_scale_manager and self._loss_scale_manager.get_drop_overflow_update():~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py in __call__(self, *args, **kwargs) 584 logger.warning(f"For 'Cell', it's not support hook function in graph mode. If you want to use hook " 585 f"function, please use context.set_context to set pynative mode.")--> 586 out = self.compile_and_run(*args) 587 return out 588 ~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py in compile_and_run(self, *inputs) 962 """ 963 self._auto_parallel_compile_and_run = True--> 964 self.compile(*inputs) 965 966 new_inputs = []~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/nn/cell.py in compile(self, *inputs) 935 """ 936 if self._dynamic_shape_inputs is None or self._dynamic_shape_inputs[0] is None:--> 937 _cell_graph_executor.compile(self, *inputs, phase=self.phase, auto_parallel_mode=self._auto_parallel_mode) 938 else: 939 self._check_compile_dynamic_shape(*inputs)~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/common/api.py in compile(self, obj, phase, do_convert, auto_parallel_mode, *args) 1004 enable_ge = context.get_context("enable_ge") 1005 self._graph_executor.set_weights_values(obj.parameters_dict())-> 1006 result = self._graph_executor.compile(obj, args_list, phase, self._use_vm_mode()) 1007 obj.compile_cache.add(phase) 1008 if not result:~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/ops/primitive.py in __check__(self, *args) 465 for track in tracks: 466 fn = getattr(self, 'check_' + track)--> 467 fn(*(x[track] for x in args)) 468 469 ~/anaconda3/envs/MindSpore/lib/python3.7/site-packages/mindspore/ops/operations/math_ops.py in check_shape(self, x1, x2) 1387 if np.all(np.array(x1) != -1) and np.all(np.array(x2) != -1): 1388 if x1_col != x2_row:-> 1389 raise ValueError(f"For '{cls_name}', the input dimensions must be equal, but got 'x1_col': {x1_col} " 1390 f"and 'x2_row': {x2_row}. And 'x' shape {x1}(transpose_a={self.transpose_a}), " 1391 f"'y' shape {x2}(transpose_b={self.transpose_b}).")ValueError: For 'MatMul', the input dimensions must be equal, but got 'x1_col': 817920 and 'x2_row': 272640. And 'x' shape [32, 817920](transpose_a=False), 'y' shape [3, 272640](transpose_b=True).请教各位有经验的大佬，我这个模型或者其他代码有什么问题，如何修改？

       感知器准则函数的基本思想是寻找一个权向量，使得规范化增广样本向量集的错分样本数最少。（下面附有源代码，如有问题请批评指正）       下面的代码仅为展示。       奖惩算法的步骤：       （1）设规范化增广样本集合Y={y1,y2,y3...,yn},初始化权向量，置k=0（迭代次数）;       （2）输入n个训练样本，计算判别函数         ，其中a（k）为第k次迭代的权向量；       （3）按照如下公式修改权向量：                                          其中c为正的步长因子（校正增量），如果a(k)转置与yi的内积>0,表示分类正确，不修改权向量，否则就分类错误，修改权向量。      （4）令k = k+1,返回（2），直到权向量对所有训练样本均稳定不变，此时训练样本都被正确分类，得到的权向量就是最优解向量      1.首先导入用到的模块，输入已知样本（线性可分的），定义初始权向量，并对样本进行增广规范化          # -*- coding: utf-8 -*-          import matplotlib.pyplot as plt           plt.rcParams['font.sans-serif'] = ['SimHei']             plt.rcParams['axes.unicode_minus'] = False          import numpy as np         #步长         c = int(input('请输入步长因子:'))         #初始权向量         w = [1,1,1]         #样本         a1 = [0,0]         a2 = [0,1]         a3 = [1,0]         a4 = [1,-1]         #将样本存放在一个二维数组里         train = [a1,a2,a3,a4]         #存储样本点（deepcopy）         #绘图用得到         init_train = [a1[:],a2[:],a3[:],a4[:]]         #增广         for i in range(len(train)):              train.append(1)         print('增广后；',train)         #规范化         for i in range(len(a3)):               a3 = -a3               a4 = -a4             print("处理后的train:\n",train)运行结果：               2.将运算部分以函数的形式呈现，便于后面的实现。   #求解向量          def mulplication(m,n):          """向量积"""          s = 0          for i in range(len(m)):               s += m*n          return s           #测试函数值          print('测试值:',mulplication(a1,w))          print()          print('----------开始进行奖惩算法----------\n\n')          def correct(w,x):             """修正权向量"""                w_new = []                for i in range(len(w)):                     w_new.append(w+c*x)        3.开始利用奖惩思想进行迭代（修正权向量表示惩罚，否则为不罚）         #储存错判类别次数         error = 0            while(True):              for i in range(len(train)):              result = mulplication(train, w)              if result <= 0:                  error += 1                  print('更新前:',w)                  w = correct(w,train)                  print('更新后:',w)              else:                    print('--哈哈,本次未更新')                    continue                       if error == 0:               print('本轮迭代完毕,没有被错判的, w是:',w)               print('*'*35)               print("final w is:",w)               break           else:               print("本轮迭代完毕,有{}次被误判！！！".format(error))               print('*'*35)               error = 0               continue           print("\n判别函数:\n")           print('g(x)='+str(w[0])+'*'+'x1'+'+'+str(w[1])+'*'+'x2'+'+'+str(w[2]))    运行结果：（局部）                  4.由于我给定的样本集是二维的，所以我用python的matplotlib模块进行了可视化。         #判别函数的展示         x1 = []  #x1作为横轴         x2 = []  #x2作为纵轴        #print("ini_train:\n",init_train)        for i in range(len(init_train)):             x1.append(init_train[0])             x2.append(init_train[1])        c_value = ['b','b','g','g']        plt.scatter(x1,x2,c=c_value)        plt.title("判别函数图像")        plt.xlim(-1,2)        plt.ylim(-2,2)       #令判别函数等于0,可得到判别界面:       if w[1] == 0:            x1 = -w[2]/w[0]            plt.vlines(x1,-2,2, colors='r', linestyles='dashed', label='判别函数')       elif w[0]==0:            x2 =  -w[2]/w[1]            plt.hlines(x2,-1,2, colors='b', linestyles='dashed', label='判别函数')      else:            x = np.arange(-1, 2, 0.1)            y = -(w[0]*x+w[2])/w[1]            plt.plot(x,y,color='r',label='判别函数')          plt.legend()      plt.show()                                       到这本次感知器算法基本结束，如有更好的代码模块，咱们共同交流，谢谢。参考文献：模式识别导论课本（西安电子科技大学出版）

NMF，中文译为非负矩阵分解。一篇比较不错的NMF中文介绍文可以见下面一篇博文的链接，《非负矩阵分解：数学的奇妙力量》http://chnfyn.blog.163.com/blog/static/26954632200751625243295/ 这篇博文很大概地介绍了一下NMF的来龙去脉，当然如果你想更深入地了解NMF的话，可以参考Lee和Seung当年发表在Nature上面的NMF原文，"Learning the parts of objects by non-negative matrix factorization"http://www.seas.upenn.edu/~ddlee/Papers/nmf.pdf读了这篇论文，基本其他任何介绍NMF基本方法的材料都是浮云了。 NMF，简而言之，就是给定一个非负矩阵V，我们寻找另外两个非负矩阵W和H来分解它，使得后W和H的乘积是V。论文中所提到的最简单的方法，就是根据最小化||V-WH||的要求，通过Gradient Discent推导出一个update rule，然后再对其中的每个元素进行迭代，最后得到最小值，具体的update rule见下图，注意其中Wia等带下标的符号表示的是矩阵里的元素，而非代表整个矩阵，当年在这个上面绕了好久。。当然上面所提的方法只是其中一种而已，在http://spinner.cofc.edu/~langvillea/NISS-NMF.pdf中有更多详细方法的介绍。相比于PCA、LDA，NMF有个明显的好处就是它的非负，因为为在很多情况下带有负号的运算算起来都不这么方便，但是它也有一个问题就是NMF分解出来的结果不像PCA和LDA一样是恒定的。 

        LDA，基本和PCA是一对双生子，它们之间的区别就是PCA是一种unsupervised的映射方法而LDA是一种supervised映射方法，这一点可以从下图中一个2D的例子简单看出        图的左边是PCA，它所作的只是将整组数据整体映射到最方便表示这组数据的坐标轴上，映射时没有利用任何数据内部的分类信息。因此，虽然做了PCA后，整组数据在表示上更加方便(降低了维数并将信息损失降到最低)，但在分类上也许会变得更加困难；图的右边是LDA，可以明显看出，在增加了分类信息之后，两组输入映射到了另外一个坐标轴上，有了这样一个映射，两组数据之间的就变得更易区分了(在低维上就可以区分，减少了很大的运算量)。        在实际应用中，最常用的一种LDA方法叫作Fisher Linear Discriminant，其简要原理就是求取一个线性变换，是的样本数据中“between classes scatter matrix”(不同类数据间的协方差矩阵)和“within classes scatter matrix”(同一类数据内部的各个数据间协方差矩阵)之比的达到最大。

        PCA，译为主元分析或者主成份分析，是一种很好的简化数据的方法，也是PR中常见到不能再常见的算法之一。CSDN上有一篇很不错的中文博客介绍PCA，《主元分析(PCA)理论分析及应用》，可以见下面链接：http://blog.csdn.net/ayw_hehe/archive/2010/07/16/5736659.aspx        对于我而言，主元分析最大的意义就是让我明白了线性代数中特征值跟特征向量究竟代表什么，从而让我进一步感受到了线性代数的博大精深魅力无穷。 PCA简而言之就是根据输入数据的分布给输入数据重新找到更能描述这组数据的正交的坐标轴，比如下面一幅图，对于那个椭圆状的分布，最方便表示这个分布的坐标轴肯定是椭圆的长轴短轴而不是原来的x y。        那么如何求出这个长轴和短轴呢？于是线性代数就来了：我们求出这堆数据的协方差矩阵(关于什么是协方差矩阵，详见本节最后附的链接)，然后再求出这个协方差矩阵的特征值和特征向量，对应最大特征值的那个特征向量的方向就是长轴(也就是主元)的方向，次大特征值的就是第二主元的方向，以此类推。关于PCA，推荐两个不错的tutorial:(1) A tutorial on Principle Component Analysis从最基本的数学原理到应用都有，让我在被老师的讲课弄晕之后瞬间开悟的tutorial: http://www.cs.otago.ac.nz/cosc453/student_tutorials/principal_components.pdf(2) 里面有一个很生动的实现PCA的例子，还有告诉你PCA跟SVD是什么关系的，对编程实现的帮助很大(当然大多数情况下都不用自己编了): http://www.math.ucsd.edu/~gptesler/283/pca_07-handout.pdf

        贝叶斯方法一篇比较科普的中文介绍可以见pongba的平凡而神奇的贝叶斯方法: http://mindhacks.cn/2008/09/21/the-magical-bayesian-method/，实际实现一个贝叶斯分类器之后再回头看这篇文章，感觉就很不一样。        在模式识别的实际应用中，贝叶斯方法绝非就是post正比于prior*likelihood这个公式这么简单，一般而言我们都会用正态分布拟合likelihood来实现。用正态分布拟合是什么意思呢？贝叶斯方法式子的右边有两个量，一个是prior先验概率，这个求起来很简单，就是一大堆数据中求某一类数据占的百分比就可以了，比如300个一堆的数据中A类数据占100个，那么A的先验概率就是1/3。第二个就是likelihood，likelihood可以这么理解：对于每一类的训练数据，我们都用一个multivariate正态分布来拟合它们(即通过求得某一分类训练数据的平均值和协方差矩阵来拟合出一个正态分布)，然后当进入一个新的测试数据之后，就分别求取这个数据点在每个类别的正态分布中的大小，然后用这个值乘以原先的prior便是所要求得的后验概率post了。        贝叶斯公式中还有一个evidence，对于初学者来说，可能会一下没法理解为什么在实际运算中它不见了。实则上，evidence只是一个让最后post归一化的东西，而在模式分类中，我们只需要比较不同类别间post的大小，归一化反而增加了它的运算量。当然，在有的地方，这个evidence绝对不能省，比如后文提到的GMM中，需要用到EM迭代，这时候如果不用evidence将post归一化，后果就会很可怕。

       K-NN可以说是一种最直接的用来分类未知数据的方法。基本通过下面这张图跟文字说明就可以明白K-NN是干什么的        简单来说，K-NN可以看成：有那么一堆你已经知道分类的数据，然后当一个新数据进入的时候，就开始跟训练数据里的每个点求距离，然后挑离这个训练数据最近的K个点看看这几个点属于什么类型，然后用少数服从多数的原则，给新数据归类。        实际上K-NN本身的运算量是相当大的，因为数据的维数往往不止2维，而且训练数据库越大，所求的样本间距离就越多。就拿我们course project的人脸检测来说，输入向量的维数是1024维(32x32的图，当然我觉得这种方法比较silly)，训练数据有上千个，所以每次求距离(这里用的是欧式距离，就是我们最常用的平方和开根号求距法) 这样每个点的归类都要花上上百万次的计算。所以现在比较常用的一种方法就是kd-tree。也就是把整个输入空间划分成很多很多小子区域，然后根据临近的原则把它们组织为树形结构。然后搜索最近K个点的时候就不用全盘比较而只要比较临近几个子区域的训练数据就行了。