数据降维概述1.数据降维概述　　所谓的数据降维就是指采用某种映射方法，将原高维空间中的数据点映射到低维度的空间中，可以解决大规模特征下的数据显示问题，使得数据集更易使用，降低后续算法的计算，消除噪声影响并使得结果更易理解。 数据降维的方法有很多，可从线性或非线性角度对其简单分类。 线性降维是指通过降维所得到的低维数据能保持高维数据点之间的线性关系，主要包括　　主成分分析（Principal Component Analysis，PCA)、线性判别分析（Linear Discriminant Analysis，LDA）；　　非线性降维一类是基于核的，如 KPCA（Kernel PCA）；另一类就是通常所说的流形学习：从高维采样数据中恢复出低维流形结构，即找到高维空间中的低维流形，并求出相应的嵌入映射，如：等距映射（Isomap）、局部线性嵌入（Locally Linear Embedding，LLE）等。 整体来说，线性方法计算块，复杂度低，但对复杂的数据降维效果较差。2.有监督和无监督　　有监督学习：对具有概念标记（分类）的训练样本进行学习，以尽可能对训练样本集外的数据进行标记（分类）预测。这里，所有的标记（分类）是已知的。因此，训练样本的岐义性低。　　无监督学习：对没有概念标记（分类）的训练样本进行学习，以发现训练样本集中的结构性知识。这里，所有的标记（分类）是未知的。因此，训练样本的岐义性高。聚类就是典型的无监督学习。3.线性降维　　主成分分析（Principal Component Analysis，PCA）是最常用的线性降维方法，是一种无监督的降维方法。它的目标是通过某种线性投影，将高维的数据映射到低维的空间中表示，并期望在所投影的维度上数据的方差最大，以此使用较少的数据维度，同时保留住较多的原数据点的特性。常用于高维数据的降维，例如二维数据集降维就是把点投射成一条线，数据集的每个样本都可以用一个值表示，同样也可以利用主成分分析将三维的图像转换成二维的。 PCA 追求的是在降维之后能够最大化保持数据的内在信息，并通过衡量在投影方向上的数据方差的大小来衡量该方向的重要性，但是这样投影以后对数据的区分作用并不大，反而可能使得数据点揉杂在一起无法区分。　　下图是PCA的投影的一个表示，黑色的点是原始的点，带箭头的虚线是投影的向量，pc1表示特征值最大的特征向量，pc2表示特征值次大的特征向量，两者是彼此正交的，因为这原本是一个2维的空间，所以最多有两个投影的向量。4.非线性降维　　主成分分析（PCA）和线性判别分析（LDA）能很好地解决呈线性关系的数据的降维，但是对于有非线性结构的数据，这种变换会丢失部分重要信息。事实上，存在非线性关系的数据集并不少见，例如将一把椅子平移，那各个平移点可看做存在线性关系，但将其旋转时，就变为了非线性关系。这种情况下，通常采用流形学习的方法。　　等距映射（Isomap）是一种较为经典的非线性降维算法，其主要目标是找到给定的高维流形对应的低维嵌入，使得高维流形上数据点间的近邻结构在低维嵌入中得以保持。算法通过将每个数据点和临近的数据点连接构成图，用图论中的dijkstra距离来估计流形的测地距离。其创新之处在于计算高维流形上数据点间距离时，不是用传统的欧式距离，而是采用微分几何中的测地线距离，并且找到了一种用实际输入数据估计其测地线距离的算法（即图论中的最小路径逼近测地线距离）。Isomap的优点在于：　　(1) 求解过程依赖于线性代数的特征值和特征向量问题，保证了结果的稳健性和全局最优性；　　(2) 能通过剩余方差判定隐含的低维嵌入的本质维数；　　(3) Isomap方法计算过程中只需要确定唯一的一个参数（近邻参数k或邻域半径e）。在Python中，Scikit-Learn库提供了用于等距映射的类，其构造函数为：　　(4) sklearn.manifold.Isomap(n_neighbors=5,n_components=2,eigen_solver='auto',tol=0,max_iter=None,path_method='auto',neighbors_algorithm='auto', n_jobs=1)。局部线性嵌入（Locally linear embedding，LLE）也是一种非线性降维算法，它能够使降维后的数据较好地保持原有流形结构，LLE 是许多其它流形学习方法的基础。LLE 算法认为每一个数据点都可以由其近邻点的线性加权组合构造得到。算法的主要步骤分为三步：　　(1) 寻找每个样本点的 k 个近邻点；　　(2) 由每个样本点的近邻点计算出该样本点的局部重建权值矩阵；　　(3) 由该样本点的局部重建权值矩阵和其近邻点计算出该样本点的输出值。 在 Python 中，Scikit-Learn 库提供了用于局部线性嵌入的类，其构造函数为：sklearn.manifold.LocallyLinearEmbedding(n_neighbors=5,n_components=2,reg=0.001,eigen_solver='auto',tol=1e-06,max_iter=100,method='standard',hessian_tol=0.0001,modified_tol=1e-12,neighbors_algorithm='auto',random_state=None, n_jobs=1)。　　通过修改参数method可以设置局部线性嵌入的具体版本，如使用标准的局部线性嵌入则将该参数设为 standard。5.数据标准化　　数据标准化处理是数据挖掘的一项基础工作，不同评价指标往往具有不同的量纲和量纲单位，这样的情况会影响到数据分析的结果，为了消除指标之间的量纲影响，需要进行数据标准化处理。最基本的标准化方法有：　　(1) 中心化：将变量的每一个数值减去该变量的均值；　　(2) 缩放：将变量的每一个数值除以该变量的标准差；　　(3) 归一化：对变量的每一个数值做中心化和缩放处理，使得每一个数值代表其与均值相差的标准差的倍数。　　在Python中，Scikit-Learn库提供了用于数据标准化的类，其构造函数为：sklearn.preprocessing.StandardScaler(copy=True,with_mean=True, with_std=True)，通过参数copy可以设置是否在原数据上进行标准化，默认为 True 即标准化后生成新的拷贝，通过参数 with_mean 和 with_std 决定是否中心化和缩放，默认都为 True。6.常用降维方法简介　　几种常用的降维方法有：缺失值比率、低方差滤波、高相关滤波、随机森林/组合树、主成分分析、反向特征消除、前向特征构造。　　(1) 缺失值的比率　　数据列如果存在太多的缺失值是不可能有太多的有用信息，因此设定一个阈值，如果数据列缺失的数据大于阈值时将数据列删除。设定的阈值越大，删除的数据列越多随之维度减少的幅度也越大。　　(2) 低方差过滤　　和缺失值比率很相似，数据列中的数据很小的变动即方差过小时（低于预先设定的阈值）删除数据列。特别注意的是：方差是依赖于范围的，因此在应用该方法前对数据正则化处理。　　(3) 高相关过滤　　数据列中有相似趋势往往也存在着相似的信息，这种情况下往往一个数据列就可以参与机器学习的模型的建立了，因此我们需要计算数值列之间的相关系数和标称列之间的皮尔逊积矩系数和皮尔逊卡方值，双列的相关系数高于设定的阈值时可以减少到只有一个。提醒一下：相关量比较敏感，因此列的归一化需要一个相对有意义的相关性比较。　　(4) Random Forests/Ensemble Trees　　决策树的 Ensemble 也成为 RF（随机森林），除了在做有效的分类器很有用外，在特征选择方面也很有效果。一种降维的方法是针对目标属性生成一个大的和构造的树，然后使用每个属性的使用统计数据发现大多数信息的特征子集。可以生成大量层次很低的树（2 层），与每棵树正在训练总额的一小部分数量的属性。如果一个属性经常被选为最佳的，它是最有可能被保留的一个有效特征。在 RF 中分数计算的随机属性的使用统计数据告诉我们——相对于其他属性——这是最有预测力的属性。　　(5) PCA（主成分分析）　　主成分分析（PCA）是一种正交统计过程,将一个数据集的原始 n 坐标转换成一个新的 n 组坐标（叫做主成分）。转化的结果，第一个主成分具有最大可能的方差，在正交于（不相关）先前的主成分的限制条件下，每个成功转化后的成分都具有最高可能的方差。只保留第一个 m < n 成分降低了数据的维度，同时保留大部分的数据信息也就是变化的数据。注意， PCA 转化对原始变量的变化比例很敏感。数据列（维度）范围在应用 PCA 之前需要正则化；同时也要注意新的坐标系（PCs）不再是真正的系统变量了；PCA 在应用到你的数据集产生新的维度时也就失去了它的可解释性，如果结果的可解释性对于你的数据分析很重要，那么在针对你的项目分析时，PCA 不能作为你的首要选择转化方法。　　(6) 反向特征的消除　　这个方法中，在给定的迭代次数下选定的分类算法对 n 个输入特征进行训练，然后每次删除一个输入特征用相同的模型对剩下的 n-1 个输入特征训练 n 次，删除的输入特征在错误率上已产生最小的增长应该就将其删除，留给将剩余的 n-1 个输入特征。分类器接着使用 n-2 个特征作为输入，等等…每次迭代 k 产生一个模型训练 n-k 特征和一个出错率 e(k)；选择一个最大可容许的错误率，我们定义的最小数量的特性必须达到所选的机器学习算法的分类器的性能。　　(7) 正向特征的构建　　这种方法和反向特征消除方法具有相反的处理过程。刚开始只处理一个特征，然后逐步每次添加一个特征，也就是说输入特征即特征维度在分类器的性能上产生最大的增加。就这两种算法而言，计算特别耗时而且计算量也特别大，它们实际上只适用于一个数据集已经相对具有较少的输入列（特侦维度）。　　除了上面谈到的几种方法外，随机推测、NMF、自动编码器、卡方检验或信息增益、多维度等级法、一致性分析、因子分析、聚类和贝叶斯模型在数据降维上表现也不错。

基于距离的离群点检测算法异常检测简介异常检测的实质是寻找观测值和参照值之间有意义的偏差。数据库中的数据由于各种原因常常会包含一些异常记录，对这些异常记录的检测和解释有很重要的意义。异常检测目前在入侵检测、金融欺诈、股票分析等领域都有着比较好的实际应用效果。离群点检测是异常检测中最常用的方法之一。离群点检测的主要目的是为了检测出那些与正常数据行为或特征属性差别较大的异常数据或行为，在一些文献中，这些数据和行为又被叫做孤立点、噪音、异常点或离群点，这些叫法中离群点的叫法较为普遍。离群点检测算法分类目前主要的离群点检测技术包括：基于统计的离群检测方法、基于聚类的离群检测方法、基于分类的离群检测方法、基于距离的离群检测方法、基于密度的离群检测方法和基于信息熵的离群检测方法。centos 7xCentOS（Community Enterprise Operating System）是[Linux]发行版之一，它是来自于[Red Hat Enterprise Linux]依照[开放源代码]规定发布的源代码所编译而成。由于出自同样的源代码，因此有些要求高度稳定性的服务器以CentOS替代商业版的[Red Hat Enterprise Linux]使用。两者的不同，在于CentOS并不包含封闭源代码软件。CentOS 对上游代码的主要修改是为了移除不能自由使用的商标。2014年，CentOS宣布与Red Hat合作，但CentOS将会在新的委员会下继续运作，并不受RHEL的影响。CentOS和[RHEL]一样，都可以使用[Fedora EPEL]来补足软件。python 3.6Python（英国发音：[/ˈpaɪθən/] 美国发音：[/ˈpaɪθɑːn/]，是一种广泛使用的[解释型]，[高级编程]，[通用型编程语言]，由[吉多·范罗苏姆]创造，第一版发布于1991年。可以视之为一种改良（加入一些其他编程语言的优点，如面向对象）的[LISP]。Python的设计哲学强调代码的[可读性]和简洁的语法（尤其是使用[空格缩进]划分代码块，而非使用大括号或者关键词）。相比于C++或Java，Python让开发者能够用更少的代码表达想法。不管是小型还是大型程序，该语言都试图让程序的结构清晰明暸。与[Scheme]、[Ruby]、[Perl]、[Tcl]等动态类型编程语言一样，Python拥有[动态类型系统]和[垃圾回收]功能，能够自动管理内存使用，并且支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。其本身拥有一个巨大而广泛的标准库。Python 本身几乎可以在所有的[操作系统]中运行。Python的其中一个[CPython]是用[C语言]编写的、是一个由社群驱动的自由[软件]，当前由[Python软件基金会]管理步骤１：环境准备本项目所需要的依赖包（已安装）matplotlib在有网的情况下可以使用以下命令安装上述依包。pip3 install matplotlibLOF算法的python实现lof.py：# -*- coding: utf8 -*-from __future__ import divisiondef distance_euclidean(instance1, instance2):     """     Computes the distance between two instances. Instances should be tuples of equal length.     Returns: Euclidean distance     Signature: ((attr_1_1, attr_1_2, ...), (attr_2_1, attr_2_2, ...)) -> float     """     def detect_value_type(attribute):         """         Detects the value type (number or non-number).         Returns: (value type, value casted as detected type)         Signature: value -> (str or float type, str or float value)         """         from numbers import Number         attribute_type = None         if isinstance(attribute, Number):             attribute_type = float             attribute = float(attribute)        else:             attribute_type = str             attribute = str(attribute)        return attribute_type, attribute    # check if instances are of same length     if len(instance1) != len(instance2):        raise AttributeError("Instances have different number of arguments.")    # init differences vector     differences = [0] * len(instance1)    # compute difference for each attribute and store it to differences vector     for i, (attr1, attr2) in enumerate(zip(instance1, instance2)):         type1, attr1 = detect_value_type(attr1)         type2, attr2 = detect_value_type(attr2)        # raise error is attributes are not of same data type.         if type1 != type2:            raise AttributeError("Instances have different data types.")        if type1 is float:            # compute difference for float             differences[i] = attr1 - attr2        else:            # compute difference for string             if attr1 == attr2:                 differences[i] = 0             else:                 differences[i] = 1     # compute RMSE (root mean squared error)     rmse = (sum(map(lambda x: x ** 2, differences)) / len(differences)) ** 0.5     return rmseclass LOF:     """     Helper class for performing LOF computations and instances normalization.     """     def __init__(self, instances, normalize=True, distance_function=distance_euclidean):         self.instances = instances         self.normalize = normalize         self.distance_function = distance_function        if normalize:             self.normalize_instances()    def compute_instance_attribute_bounds(self):         min_values = [float("inf")] * len(self.instances[0])  # n.ones(len(self.instances[0])) * n.inf         max_values = [float("-inf")] * len(self.instances[0])  # n.ones(len(self.instances[0])) * -1 * n.inf         for instance in self.instances:             min_values = tuple(map(lambda x, y: min(x, y), min_values, instance))  # n.minimum(min_values, instance)             max_values = tuple(map(lambda x, y: max(x, y), max_values, instance))  # n.maximum(max_values, instance)         self.max_attribute_values = max_values         self.min_attribute_values = min_values    def normalize_instances(self):         """         Normalizes the instances and stores the infromation for rescaling new instances.         """         if not hasattr(self, "max_attribute_values"):             self.compute_instance_attribute_bounds()         new_instances = []        for instance in self.instances:             new_instances.append(                 self.normalize_instance(instance))  # (instance - min_values) / (max_values - min_values)         self.instances = new_instances    def normalize_instance(self, instance):         return tuple(map(lambda value, max, min: (value - min) / (max - min) if max - min > 0 else 0,                          instance, self.max_attribute_values, self.min_attribute_values))    def local_outlier_factor(self, min_pts, instance):         """         The (local) outlier factor of instance captures the degree to which we call instance an outlier.         min_pts is a parameter that is specifying a minimum number of instances to consider for computing LOF value.         Returns: local outlier factor         Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> float         """         if self.normalize:             instance = self.normalize_instance(instance)        return local_outlier_factor(min_pts, instance, self.instances, distance_function=self.distance_function)def k_distance(k, instance, instances, distance_function=distance_euclidean):     # TODO: implement caching     """     Computes the k-distance of instance as defined in paper. It also gatheres the set of k-distance neighbours.     Returns: (k-distance, k-distance neighbours)     Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> (float, ((attr_j_1, ...),(attr_k_1, ...), ...))     """     distances = {}    for instance2 in instances:         distance_value = distance_function(instance, instance2)        if distance_value in distances:             distances[distance_value].append(instance2)        else:             distances[distance_value] = [instance2]     distances = sorted(distances.items())     neighbours = []     k_sero = 0     k_dist = None     for dist in distances:         k_sero += len(dist[1])         neighbours.extend(dist[1])         k_dist = dist[0]        if k_sero >= k:            break     return k_dist, neighboursdef reachability_distance(k, instance1, instance2, instances, distance_function=distance_euclidean):     """     The reachability distance of instance1 with respect to instance2.     Returns: reachability distance     Signature: (int, (attr_1_1, ...),(attr_2_1, ...)) -> float     """     (k_distance_value, neighbours) = k_distance(k, instance2, instances, distance_function=distance_function)    return max([k_distance_value, distance_function(instance1, instance2)])def local_reachability_density(min_pts, instance, instances, **kwargs):     """     Local reachability density of instance is the inverse of the average reachability     distance based on the min_pts-nearest neighbors of instance.     Returns: local reachability density     Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> float     """     (k_distance_value, neighbours) = k_distance(min_pts, instance, instances, **kwargs)     reachability_distances_array = [0] * len(neighbours)  # n.zeros(len(neighbours))     for i, neighbour in enumerate(neighbours):         reachability_distances_array[i] = reachability_distance(min_pts, instance, neighbour, instances, **kwargs)     sum_reach_dist = sum(reachability_distances_array)    if sum_reach_dist == 0:        return float('inf')    return len(neighbours) / sum_reach_distdef local_outlier_factor(min_pts, instance, instances, **kwargs):     """     The (local) outlier factor of instance captures the degree to which we call instance an outlier.     min_pts is a parameter that is specifying a minimum number of instances to consider for computing LOF value.     Returns: local outlier factor     Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> float     """     (k_distance_value, neighbours) = k_distance(min_pts, instance, instances, **kwargs)     instance_lrd = local_reachability_density(min_pts, instance, instances, **kwargs)     lrd_ratios_array = [0] * len(neighbours)    for i, neighbour in enumerate(neighbours):         instances_without_instance = set(instances)         instances_without_instance.discard(neighbour)         neighbour_lrd = local_reachability_density(min_pts, neighbour, instances_without_instance, **kwargs)         lrd_ratios_array[i] = neighbour_lrd / instance_lrd    return sum(lrd_ratios_array) / len(neighbours)def outliers(k, instances, **kwargs):     """     Simple procedure to identify outliers in the dataset.     """     instances_value_backup = instances     outliers = []    for i, instance in enumerate(instances_value_backup):         instances = list(instances_value_backup)         instances.remove(instance)         l = LOF(instances, **kwargs)         value = l.local_outlier_factor(k, instance)        if value > 1:             outliers.append({"lof": value, "instance": instance, "index": i})     outliers.sort(key=lambda o: o["lof"], reverse=True)    return outliers测试代码测试上述代码，测试脚本看附件！

基于聚类的离群点检测方法1.基于聚类的离群点检测概述　　在利用python进行数据挖掘时，离群点检测经常是必不可少的一部分。离群点检测的任务是发现与大部分其它对象显著不同的对象。大部分数据挖掘方法都将这种差异信息视为噪声丢弃，然而在部分情况下，罕见的数据可能蕴含着更大的研究价值。2.丢弃远离其他簇的小簇　　一种利用聚类检测离群点的方法是丢弃远离其他簇的小簇。通常，该过程可以简化为丢弃小于某个最小阔值的所有簇。　　这个方法可以和其他任何聚类技术一起使用，但是需要最小簇大小和小簇与其他簇之间距离的阈值。而且这种方案对簇个数的选择高度敏感，使用这个方案很难将离群点得分附加到对象上。　　在下图图1中，聚类簇数K=2，可以直观地看出其中一个包含5个对象的小簇远离大部分对象，可以视为离群点。3.基于原型的聚类　　另一种比较系统的方法，首先聚类所有对象，然后评估对象属于簇的程度（离群点得分）。在这种方法中，可以用对象到它的簇中心的距离来度量属于簇的程度。特别的，如果删除一个对象导致该目标的明显改进，则可将该对象视为离群点。例如，在K均值算法中，删除远离其相关簇中心的对象能够显著地改进该簇的误差平方和（SSE）。　　对于基于原型的聚类，评估对象属于簇的程度（离群点得分）主要有两种方法：一是度量对象到簇原型的距离，并用它作为该对象的离群点得分；二是考虑到簇具有不同的密度，可以度量簇到原型的相对距离，相对距离是点到质心的距离与簇中所有点到质心距离的中位数之比。　　可以注意到，在基于聚类的离群点检测中，对象是否被认为是离群点可能高度依赖于簇的个数（如K很大时的噪声簇）。该问题也没有一个简单的答案，这里提供两种解决思路：一种是改变簇的个数重复检测分析，另一种是聚类得到大量小簇，此时若存在离群点，则它多半真的是一个离群点（但这样的缺点是一组离群点可能形成小簇从而逃避检测）。4.基于聚类的离群点检测的改进　　离群点对初始聚类的影响：通过聚类检测离群点时，离群点会影响聚类结果。为了处理该问题，可以使用的方法有：对象聚类、删除离群点、对象再次聚类（这个不能保证产生最优结果）。　　还有一种更复杂的方法：取一组不能很好地拟合任何簇的特殊对象，这组对象代表潜在的离群点。随着聚类过程的进展，簇在变化。不再强属于任何簇的对象被添加到潜在的离群点集合；测试当前在该集合中的对象，如果它现在强属于一个簇，就可以将它从潜在的离群点集合中移除。聚类过程结束时还留在该集合中的点被分类为离群点（这种方法也不能保证产生最优解，甚至不比前面的简单算法好，在使用相对距离计算离群点得分时，这个问题特别严重）。　　对象是否被认为是离群点可能依赖于簇的个数（如 K 很大时的噪声簇）。该问题也没有简单的答案。一种策略是对于不同的簇个数重复该分析。另一种方法是找出大量小簇，其想法如下：　　(1) 较小的簇倾向于更加凝聚；　　(2) 如果存在大量小簇时，一个对象是离群点，则它多半是一个真正的离群点。 不利的一面是一组离群点可能形成小簇从而逃避检测。 利用前面的数据进行聚类分析，并计算各个样本到各自聚类中心的距离，分析离群样本，得到距离误差图。

基于密度的离群点检测方法1.平稳性检验　　通过估计概率分布的参数来建立一个数据模型。如果一个数据对象不能很好地同该模型拟合，即如果它很可能不服从该分布，则它是一个离群点。2.一元正态分布中的的离群点检测　　正态分布是统计学中最常用的分布之一。 若随机变量x的密度函数如下式：则称x服从正态分布，简称x服从正态分布N(μ,σ)，其中参数μ和σ分别为均值和标准差。　　下图所示N(0,1)的密度函数：　　N(0,1)的数据对象出现在该分布的两边尾部的机会很小，因此可以用它作为检测数据对象是否是离群点的基础。数据对象落在3倍标准差中心区域之外的概率仅有0.0027。3.混合模型的离群点检测　　混合模型是一种特殊的统计模型，它使用若干统计分布对数据建模。每一个分布对应一个簇，而每个分布的参数提供对应簇的描述，通常用中心和发散描述。　　混合模型将数据看作从不同的概率分布得到的观测值的集合。概率分布可以是任何分布，但是通常是多元正态的，因为这种类型的分布不难理解，容易从数学上进行处理，并且已经证明在许多情况下都能产生好的结果。这种类型的分布可以对椭圆簇建模。　　总的来说，混合模型数据产生过程为：定几个类型相同但参数不同的分布，随机地选取一个分布并由它产生一个对象。重复该过程m次，其中m是对象的个数。　　具体地讲，假定有K个分布和m个对象X=x1,x2,…,xm。设第j个分布的参数为句，并设 A 是所有参数的集合，即A=a1, a2, … , ak。则$P(x_i|a_j)$是第i个对象来自第j个分布的概率。选取第j个分布产生一个对象的概率由权值$w_j(1 ≤ j ≤ K)$给定，其中权值（概率）受限于其和为1的约束，即：于是，对象x的概率由以下公式给出：　　如果对象以独立的方式产生，则整个对象集的概率是每个个体对象局的概率的乘积，公式如下：　　对于混合模型，每个分布描述一个不同的组，即一个不同的簇。通过使用统计方法，可以由数据估计这些分布的参数，从而描述这些分布（簇）。也可以识别哪个对象属于哪个簇。然而，泪合模型只是给出具体对象属于特定簇的概率。　　聚类时，混合模型方法假定数据来自混合概率分布，并且每个簇可以用这些分布之一识别。同样，对于离群点检测，用两个分布的混合模型建模，个分布为正常数据，而另一个为离群点。　　聚类和离群点检测的目标都是估计分布的参数，以最大化数据的总似然。 离群点检测常用的简单的方法：先将所有数据对象放入正常数据集，这时离群点集为空集；再用一个迭代过程将数据对象从正常数据集转移到离群点集，该转移能提高数据的总似然。　　具体操作如下：　　假设数据集U包含来自两个概率分布的数据对象：M是大多数(正常)数据对象的分布，而 N 是离群点对象的分布。数据的总概率分布可以记作：$U(x) = (1 -\lambda M(x) + \lambda N(x)$，其中，x是一个数据对象；$\lambda ∈[0,1]$，给出离群点的期望比例。分布M由数据估计得到，而分布N通常取均匀分布。设Mt和Nt分别为时刻t正常数据和离群点对象的集合。初始t=0，M0=D，而N0≠Ø。　　根据公式混合模型中公式$P(x|A)=\sum_{j=1}^K w_jP_j(x|a_j)$推导，在整个数据集的似然和对数似然可分别由下面两式给出：　　其中PD、PMt、PNt分别是 、Mt、Nt的概率分布函数。　　因为正常数据对象的数量比离群点对象的数量大很多，因此当一个数据对象移动到离群点集后，正常数据对象的分布变化不大。在这种情况下，每个正常数据对象的总似然的贡献保持不变。此外，如果假定离群点服从均匀分布，则移动到离群点集的每一个数据对象对离群点的似然贡献一个固定的量。这样，当一个数据对象移动到离群点集时，数据总似然的改变粗略地等于该数据对象在均匀分布下的概率（用λ加权）减去该数据对象在正常数据点的分布下的概率（用 l-λ加权)。从而，离群点由这样一些数据对象组成。这样，数据对象在均匀分布下的概率比正常数据对象分布下的概率高。　　在某些情况下是很难建立模型的。例如，因为数据的统计分布未知或没有训练数据可用。在这种情况下，可以考虑其他不需要建立模型的检测方法。

离群点检测概述1.离群点检测概念　　离群点是由系统受外部干扰而产生的。但是，形成离群点的系统外部干扰非常多。可能是采样中的误差，计算错误等，都有可能产生极端大值或者极端小值。其次可能是被研究的对象受到非正常的因素影响而引起的，例如在人口死亡序列中，由于某年发生了海啸，使该月死亡人数剧增，形成离群点；在股票价格序列中，由于受某项政策出台或某种谣传等等，都会出现极增，极减现象，变现为序列中的离群点。　　就餐饮企业而言，经常会碰到如下问题。　　(1) 如何根据客户的消费记录检测是否为异常刷卡消费?　　(2) 如何检测是否有异常订单?　　这一类异常问题可以通过离群点检测来解决。 离群点检测是数据挖掘中重要的一部分，它的任务是发现与大部分其他对象显著不同的对象。大部分数据挖掘方法都将这种差异信息视为噪声而丢弃，然而在一些应用中，罕见的数据可能蕴含着更大的研究价值。　　在数据的散布图中，图1所示离群点远离其他数据点。因为离群点的属性值明显偏离期望的或常见的属性值，所以离群点检测也称偏差检测。        离群点检测已经被广泛应用于电信和信用卡的诈骗检测、贷款审批、电子商务、网络入侵和天气预报等领域。例如，可以利用离群点检测分析运动员的统计数据，以发现异常的运动员。2.离群点的成因　　离群点的主要成因有：数据来源于不同的类、自然变异、数据测量和收集误差。3.离群点的类型　　　从数据范围:全局离群点和局部离群点；从整体来看，某些对象没有离群特征，但是从局部来看，却显示了一定的离群性。如图所示，C是全局离群点，D是局部离群点。　　从数据类型 :数值型离群点和分类型离群点，这是以数据集的属性类型进行划分的。　　从属性的个数:一维离群点和多维离群点，一个对象可能有一个或多个属性。 　4.常用离群点检测方法　　常用离群点检测方法描述与评估如图所示：        基于统计模型的离群点检测方法需要满足统计学原理，如果分布已知，则检验可能非常有效。基于邻近度的离群点检测方法比统计学方法更一般、更容易使用，因为确定数据集有意义的邻近度量比确定它的统计分布更容易。基于密度的离群点检测与基于邻近度的离群点检测密切相关，因为密度常用邻近度定义：　　(1) 一种是定义密度为到K个最邻近的平均距离的倒数，如果该距离小，则密度高；　　(2) 另一种是使用DBSCAN聚类算法，一个对象周围的密度等于该对象指定距离d内对象的个数。

又碰到一个问题，基础环境选的是all in one, pip 安装依赖的时候报错

使用python的SDK生成了一个预签名url，根据文档示例使用python代码来PUT请求上传文件成功。但是当我通过该url使用postman调用put请求上传文件时却显示状态码为403请问这种问题应该如何解决？以下是详细报错信息：

### 思路 大家好，我是一名在读研究生，很有幸参加了这个比赛，遇到了很多优秀的同学，值得我学习，感谢华为主办方，下面分享一下我的思路，当然不是很优秀，我编写的配送员智商可能只有三岁哈哈哈 视频讲解：https://pan.baidu.com/s/1S1gpbMLwdxXJMAnkDiRGZA 提取码：72x8 1. 我没有做太多的思考，思路也很容易理解，不需要写地图，直接对坐标操作，首先先到的就是greedy策略，每次都选择当前最好的选择，当然这只能考虑到局部最优，但最后结果还不错，能排进前二十。 2. 每次配送的时候都优先选择离当前最近的需求点配送，取货的时候给每个捐赠小区一个ranking，就按照捐赠数量/距离来做，试了一下距离的平方结果不如绝对值。 3. 配送有几种情况需要考虑： - 车上口罩为0，那么肯定要去取货，那么就按ranking来选择，回到仓库加满 - 车上口罩为100，那么肯定要去送货，就选择最近的，因为最远的周边可能后续会生成捐赠小区 - 接下的两种情况最难考虑，就是送完一个小区或者刚取完一些车上还剩，那么是去接着送别的小区，还是取货呢？我的想法就是也写一个ranking比较，送货和取货的价值比较，但要考虑一些特殊情况，如果此时的货够最近的需求小区a那么就去送，如果此时的货加上离aranking最高的取货点足够那么就直接去取货点取货，当然这考虑非常不够，很需要改进,可以学习一一下别的选手的思路。 4.经过一些稀奇古怪的想法可以提高，大概最好就是96了.. ### 代码分析 下面对我的代码进行讲解，用python写的. load:当前装载量 target：目标地 p,pos当前坐标 R(字典)：对应坐标的货量，需求点就是负值，捐赠和仓库就是正值，R为空或者没有负值就是结束啦 choose_target（）：选择装货点 choose_na_target（）：选择配送点 #### 主函数 ##### 需求小区仓库初始化 ```python if __name__ == '__main__': new_string=input() s_list=new_string.split() S=(int(s_list[1]),int(s_list[2])) R={} R[(int(s_list[1]),int(s_list[2]))]=100 for i in range(0,5): new_string=input() r_list=new_string.split() R[(int(r_list[1]),int(r_list[2]))]=int(r_list[3]) p=list(S) load=0 #初始化装载量为0 target=S ``` ##### 选择（每次到达小区或者捐赠点就行下一步的选择) 这里我加入了一个配送时如果有顺路的捐赠小区，那就去取一下 ```python while True: P=tuple(p) if P == S: load = 100 target = choose_na_target(p) elif P in R.keys(): sum=load+R[P] if R[P] < 0: if sum<0: load=0 R[P]=sum if R[closest(p)] >= -R[P]: target = closest(p) else: target= choose_target(p) #车空就去送取货 else: del R[P] if len(R)==0: break if min(R.values())>0: break load=sum target1 = choose_na_target(p) target2 = choose_target(p) target3 = choose_target(target1) if load >= -R[target1]: target = target1 elif load + R[target3] >= -R[target1]: target = target3 else: target = com_value(p ,target1,target2) else: if sum > 100: load=100 R[P]=sum-100 target = choose_na_target(p) else: del R[P] load=sum target1 = choose_na_target(p) target2 = choose_target(p) if load >= -R[target1]: target = target1 else: target = com_value(p ,target1,target2) for k in R.keys(): #顺路就去取 if R[k] > 0: if(k[0]>=target[0] and k[0]<=p[0]) or (k[0]<=target[0] and k[0]>=p[0]): if(k[1]>=target[1] and k[1]<=p[1]) or (k[1]<=target[1] and k[1]>=p[1]): target = k ``` ##### 读取命令行输入 ```python new_string=input() if new_string=='G': #读取到行动的命令，向target移动 p,next_step=step(p,target) print(next_step) else: r_list=new_string.split() if p[0] == int(r_list[1]) and p[1] == int(r_list[2]): #空投贴脸hhh if load + int(r_list[3]) <= 100: load = load + int(r_list[3]) else: R[(int(r_list[1]),int(r_list[2]))]=int(r_list[3])-100+load load = 100 else: R[(int(r_list[1]),int(r_list[2]))]=int(r_list[3]) #更新一下选择 if R[target] > 0: #注意R里没有S target = choose_target(p) else: cur_target = (int(r_list[1]),int(r_list[2])) target = com_value(p ,target,cur_target) ``` ##### 移动函数 ```python def step(pos,to): if pos[0]to[0]: pos[0]=pos[0]-1 return pos,'N' else: if pos[1] return pos,'E' else: pos[1]=pos[1]-1 return pos,'W' ``` ##### 选择捐赠小区和需求小区 ```python def choose_na_target(pos): na_distance=0 global load for k in R.keys(): if R[k] na_distance: na_distance = cur_dis2 tar = k return tar ```python def choose_target(pos): po_distance=0 global load distance = (100-load)/ (abs(pos[0]-S[0])+abs(pos[1]-S[1])+1) for k in R.keys(): if R[k] > 0: if k[0]==pos[0] and k[1]==pos[1]: continue if R[k] + load > 100: cur_dis1 = (100-load)/ (abs(pos[0]-k[0])+abs(pos[1]-k[1])+1) else: cur_dis1 = R[k] / (abs(pos[0] - k[0]) + abs(pos[1] - k[1])+1) if cur_dis1 > po_distance: po_distance = cur_dis1 tar =k if po_distance> distance: return tar else: return S ``` ##### 捐赠小区和需求小区的比较ranking ```python def com_value(pos,target1,target2): global target if load < -R[target1]: cur_value1 = load else: cur_value1 = -R[target1] value1 = cur_value1 / (abs(pos[0]-target1[0])+abs(pos[1]-target1[1])+1) if load +R[target2] > 100: cur_value2 = 100 -load else: cur_value2 = R[target2] value2 = cur_value2 / (abs(pos[0]-target2[0])+abs(pos[1]-target2[1])+1) if value1 >value2: return target1 else: return target2 ```

说明：为了让大家辛苦分享的内容不被埋没，可以被看到，已经把所有选手分享的内容都汇总到本帖，也请大家看到优秀内容给分享者一些鼓励，多多评论点赞哦~欢迎参加赛道一的童鞋，在论坛中发帖进行互动分享，我们将在所有参与发帖的选手中，进行抽奖~活动截止日期为5月15日，抽奖结果将于5月18日公布，优秀内容分享者有机会进入华为云人才库~一、分享内容相关说明分享内容包括但不限于：1. 参赛心得 2. 算法思路分享 3. 代码分享 4. 测试工具分享 5.讲解视频分享分享操作步骤：1.在本论坛找到并点击【发表主题】，发布分享帖，在分享帖子的时候，请在选择主题分类时，选择【大赛专区】，需要在标题标明赛道一2.版主每日会在论坛找大家发布的帖子，并汇总在本帖，方便大家观看奖品：200元京东卡 7名；100元京东卡 3名； 50元京东卡 18名二、内容汇总如下视频分享帖：1.华为云DevCloud软件编程大赛—优秀选手作品展播2.华为云DevCloud软件编程大赛 直播答疑会 视频录播3.5月7日直播录播4.txt文档和pygame实现每日pk地图本机跑5.赛道一：思路及经验分享，希望对大家有所帮助！！（来自有幸被选中优秀选手视频展播的小白）6.赛道一思路分享（一等奖）7.【华为云DEVCLOUD软件编程大赛赛道一】参赛视频分享及初级代码讲述、心得体会心得、算法思路类分享帖：1.口罩大作战（赛道一）二等奖解题思路分享2.最后一天的十次机会也用完了，来说说感受3.关于口罩大作战赛道一（C++）的记录和总结——White-Loub4.赛道一小结(C++)_本次竞赛算法思路与部分具体实现代码以及学习c++的资源链接和计算机速成课视频链接5.口罩大作战（赛道一）python思路以及代码分享6.赛道一解题思路分享7.赛道一：思路及经验分享，希望对大家有所帮助！！（来自有幸被选中优秀选手视频展播的小白）8.【华为云DEVCLOUD软件编程大赛赛道一】参赛视频分享及初级代码讲述、心得体会9.赛道一思路分享（一等奖）10.口罩大作战（赛道一）陪跑经历和算法思路代码(C++)分享11.【华为云DEVCLOUD软件编程大赛赛道一】参赛视频分享及初级代码讲述、心得体会12.口罩大作战（赛道一）算法思路分享（三等奖）16.赛道一 综合排名第六 算法小白思路分享（三等奖）代码分享帖：1.口罩大作战（赛道一）二等奖解题思路分享2.赛道一口罩配送大作战代码分享3.关于口罩大作战赛道一（C++）的记录和总结——White-Loub4.txt文档和pygame实现每日pk地图本机跑5.赛道一python地图绘制分享6.赛道一python分享7.大赛塞到一代码。献丑了。8.口罩大作战（赛道一）python思路以及代码分享9.赛道一解题思路分享10.赛道一：思路及经验分享，希望对大家有所帮助！！（来自有幸被选中优秀选手视频展播的小白）11.【华为云DEVCLOUD软件编程大赛赛道一】参赛视频分享及初级代码讲述、心得体会12.口罩大作战（赛道一）陪跑经历和算法思路代码(C++)分享13.【华为云DEVCLOUD软件编程大赛赛道一】参赛视频分享及初级代码讲述、心得体会14.【赛道一代码分享】 可以完成 但效果不好测试工具分享：1.官方测试工具2.赛道一，基于官方测试程序改的随机地图生成，自动测试1000幅（可自己更改测试数目），适用于配送结束未配送完的同学其他：华为云DevCloud软件编程大赛常见问题华为云DevCloud软件编程大赛——选手问题收集帖

刚刚仓库丢了，现在补上用pygame绘制，随机产生数据可以跑，但是与程序的连接还没完成，后天结束了，怕是完成不了了，对地图有兴趣的朋友可以试试看。坐标和口罩数量随机生成可以显示。图片素材在附近，从每日pk上下载来的。首先，导包，初始化变量。import random import pygame from pygame.color import THECOLORS pic=['./pic/xq.png','./pic/jzxq.png','./pic/kdy.png'] #需求小区，捐赠小区，快递员图片 xqxq=[[1,5],[6,6],[2,5],[8,9]] #需求小区坐标 jzxq=[[1,9],[11,11],[11,9]]#捐赠小区坐标 xqsl=[-200,-111,-40,-99,-41]#数量 jzsl=[100,100,11]#捐赠数量 cangku=[3,3]初始化pygame界面，建立快递员，小区的类。pygame.init() class ck(pygame.sprite.Sprite):#仓库     def __init__(self,top,left):         pygame.sprite.Sprite.__init__(self)         self.image = pygame.image.load(pic[3])         self.image=pygame.transform.scale(self.image, (52, 52))         self.rect = self.image.get_rect()         self.rect.left = left*50         self.rect.top = top*50         self.num=100 class kdy(pygame.sprite.Sprite):#快递员     def __init__(self):         pygame.sprite.Sprite.__init__(self)         self.image = pygame.image.load(pic[2])         self.image=pygame.transform.scale(self.image, (52, 52))         self.rect = self.image.get_rect()         self.rect.left = 0#快递员的位置，与华为题目一致，x为东西，原点在左上角         self.rect.top = 0         self.num=100 #快递员目前有多少口罩，要在图上显示     def move(self, top,left):#快递员位置改变的方法         self.rect.left = left*50         self.rect.top = top*50     def get(self,num):         self.num=num class xq(pygame.sprite.Sprite):     def __init__(self,top,left):         pygame.sprite.Sprite.__init__(self)         self.image = pygame.image.load(pic[0])         self.image=pygame.transform.scale(self.image, (51, 51))         self.rect = self.image.get_rect()         self.rect.left = left*50         self.rect.top = top*50         self.num=-100#需求小区的需求数量     def move(self, num):         self.num=num#改变目前所需口罩数量 class jz(pygame.sprite.Sprite):     def __init__(self,top,left):         pygame.sprite.Sprite.__init__(self)         self.image = pygame.image.load(pic[1])         self.image=pygame.transform.scale(self.image, (51, 51))         self.rect = self.image.get_rect()         self.rect.left = left*50#捐赠小区位置         self.rect.top = top*50         self.num=100#捐赠数量     def move(self, num):         self.num = num#改变数量 kdy=kdy()#实例化快递员 ck=ck(cangku[0],cangku[1])继续初始化pygamesize = width,height = 600,600 screen = pygame.display.set_mode(size) pygame.display.set_caption('postman') clock = pygame.time.Clock()def draw():     for i in range(0,12,2):         for j in range(0,12,2):             pygame.draw.rect(screen, [0,255,100],[i*50,j*50,50,50],0)     for i in range(1,12,2):         for j in range(1,12,2):             pygame.draw.rect(screen, [0,255,100],[i*50,j*50,50,50],0)     for i in range(1,12,2):         for j in range(0,12,2):             pygame.draw.rect(screen, [0,240,100],[i*50,j*50,50,50],0)     for i in range(0,12,2):         for j in range(1,12,2):             pygame.draw.rect(screen, [0,240,100],[i*50,j*50,50,50],0) draw()#绘制地图，不含小区和快递员 xq_font = pygame.font.Font(None, 30)#初始化显示的文本def animate():#重新绘制界面     #先绘制地图，再绘制需求小区，捐赠小区，再更新数量的文本显示，把仓库也画上     draw()     for i in xqzb:         screen.blit(i.image, i.rect)     for i in jzzb:         screen.blit(i.image, i.rect)     xqxs = []  # 需求数量显示     jzxs = []  # 捐赠数量显示     for i in range(len(xqxq)):         xqxs.append(xq_font.render(str(xqzb.num), 1, THECOLORS['black']))     for i in range(len(jzxq)):         jzxs.append(xq_font.render(str(jzzb.num), 1, THECOLORS['white']))     for i in range(len(xqxs)):         screen.blit(xqxs,[xqxq[1]*50,xqxq[0]*50])     for i in range(len(jzxs)):         screen.blit(jzxs,[jzxq[1]*50,jzxq[0]*50])     screen.blit(kdy.image, kdy.rect)#重新绘制快递员并更新数量     screen.blit(xq_font.render(str(kdy.num), 1, THECOLORS['white']), kdy.rect)     screen.blit(ck.image, ck.rect)     pygame.display.flip()#刷新界面running = True while running:#开始循环刷新地图     b=random.randint(1,12)#随机增加捐赠小区     if b >10:         jzxq.append([b,b,b])     xqzb = []  # 需求小区类的实现，5个实现写到列表里保存     jzzb = []  # 捐赠小区类的实现，同列表保存     for i in range(len(xqxq)):         xqzb.append(xq(xqxq[0], xqxq[1]))     for i in range(len(jzxq)):         jzzb.append(jz(jzxq[0], jzxq[1]))     for event in pygame.event.get():         if event.type == pygame.QUIT:#如果点退出，就关闭界面              running = False          a=random.randint(1,11)#以下同于改变文本显示的口罩数量     for i in range(len(xqzb)):         xqzb.num=a*10     for i in range(len(jzzb)):         jzzb.num=a*11     clock.tick(3)#控制帧速率     kdy.move(a,a)#快递员的位置改变，直接给坐标，如（1，2）     animate()#调用方法，刷新地图和房子，快递员等 pygame.quit()

用Python实现，总共大约300行。还是很简单的，新手，没有花里胡哨的用法。global是全局变量，为了函数内能改变它的值。导入numpy会增加200ms左右的时间，全篇没有用numpy。不然numpy的结构化数组挺好用的。这里定义了很多变量。首先：while true循环接受输入，控制前6个输入部署状态。ta = 0  tihuon = 100 label = {'s': 0, 'r1': 0, 'r2': 0, 'r3': 0, 'r4': 0, 'r5': 0} #s是仓库坐标，r1-r5是小区坐标 need = {'r1': 0, 'r2': 0, 'r3': 0, 'r4': 0, 'r5': 0}#需求数量 give = {}#捐赠小区 give_ = {}#捐赠数量 distance = {'r1': 0, 'r2': 0, 'r3': 0, 'r4': 0, 'r5': 0} #计算当前位置与仓库距离 distancegi = {'r1': 0, 'r2': 0, 'r3': 0, 'r4': 0, 'r5': 0} #中间变量，为了排序 distance_give = {} #捐赠小区与需求小区之间距离 now = [0, 0]#目前的走向 now_go = None #目的地 shave = 100 #目前有的口罩数 flag = True #是否重新规划路线 cangku = [] #仓库坐标 flag_back = True #是否取货 step = 0 flag_give = False #是否取捐赠小区取货 edu=51 #额度，低于这个值就要取货 edu1=0 #另一个额度，目前没用到 edugive=0 #额度，如果捐赠小区的数量+edgive大于某值，就去取货while True:     step += 1     inputs = input()     inputs = inputs.strip().split()          if step <= 6:         if step == 1:             label['s'] = [int(inputs[1]), int(inputs[2])]             cangku = [int(inputs[1]), int(inputs[2])]             continue                      if step == 2:             label['r1'] = [int(inputs[1]), int(inputs[2])]             need['r1'] = int(inputs[3])             continue                      if step == 3:             label['r2'] = [int(inputs[1]), int(inputs[2])]             need['r2'] = int(inputs[3])             continue                      if step == 4:             label['r3'] = [int(inputs[1]), int(inputs[2])]             need['r3'] = int(inputs[3])             continue                      if step == 5:             label['r4'] = [int(inputs[1]), int(inputs[2])]             need['r4'] = int(inputs[3])             continue                      if step == 6:             label['r5'] = [int(inputs[1]), int(inputs[2])]             need['r5'] = int(inputs[3])             continue如果输入是Gif inputs == ['G']:        如果目前的口罩书小于额度，就取货。              if shave<edu:     if flag_back == True: #判断是否规划路线         caculate_give_distance() #计算当前点与各个捐赠点的距离         now_go_give, now_give = get_near_give() #获取目的地，路径。[2,2]代表需要向南，东，各2步。         now_to_cangku = [cangku[0] - label['s'][0], cangku[1] - label['s'][1]] #目前去仓库的路径         if now_go_give != None and ((abs(now_give[0]) + abs(now_give[1])) < (abs(now_to_cangku[0]) + abs(now_to_cangku[1]))) and any(             [abs(v) for k, v in need.items() if abs(v) <= (give[now_go_give][2])+edugive]):#如果去捐赠小区拿货比取仓库拿货近，而且能拿够指定数量（大于需求量的最小值）             now = now_give #去捐赠小区             now_go = now_go_give             flag_back = False             flag_give = True         else:             now = [cangku[0] - label['s'][0], cangku[1] - label['s'][1]] #否则就去仓库             now_go = 's'             flag_back = False     a = random.randint(1, 2) #先东西方向走还是南北走，1就先南北，后东西，随机走，万一碰到捐赠，不经意取到货     if a == 1:         if now[0] < 0:             print('N')             label['s'][0] -= 1             now[0] += 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue         if now[0] > 0:             print('S')             label['s'][0] += 1             now[0] -= 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue         if now[1] > 0:             print('E')             label['s'][1] += 1             now[1] -= 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue         if now[1] < 0:             print('W')             label['s'][1] -= 1             now[1] += 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue     if a == 2:         if now[1] > 0:             print('E')             label['s'][1] += 1             now[1] -= 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue         if now[1] < 0:             print('W')             label['s'][1] -= 1             now[1] += 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue         if now[0] < 0:             print('N')             label['s'][0] -= 1             now[0] += 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue         if now[0] > 0:             print('S')             label['s'][0] += 1             now[0] -= 1             zt_change()             xiehuo()             if len(need) == 0:                 break             continue def caculate_give_distance():     global distance_give     distance_give = {}     for i in give:         distance_give = abs(give[0] - label['s'][0]) + abs(give[1] - label['s'][1])         if distance_give==0:             distance_give=100 def get_near_give():     near_label = (sorted(distance_give, key=distance_give.get))     now_go = None     now = None     for i in near_label:         if give[2] != 0:             now_go = i             now = [give[0] - label['s'][0], give[1] - label['s'][1]]             break         else:             continue     return now_go, now否则就配送    elif shave != 0:         if flag == True:    #规划配送路线             caculate_distance()             now_go, now = get_near()                  flag = False         a=random.randint(1,2)         if a ==1:             if now[0] < 0:                 print('N')                 label['s'][0] -= 1                 now[0] += 1                 zt_change()                 xiehuo()                      if len(need)==0:                     break                 continue             if now[0] > 0:                 print('S')                 label['s'][0] += 1                 now[0] -= 1                 zt_change()                 xiehuo()                 if len(need)==0:                     break                 continue             if now[1] > 0:                 print('E')                 label['s'][1] += 1                 now[1] -= 1                 zt_change()                 xiehuo()                 if len(need)==0:                     break                 continue             if now[1] < 0:                 print('W')                 label['s'][1] -= 1                 now[1] += 1                 zt_change()                 xiehuo()                 if len(need)==0:                     break                 continue         if a==2:                  if now[1] > 0:                 print('E')                 label['s'][1] += 1                 now[1] -= 1                 zt_change()                 xiehuo()                 if len(need) == 0:                     break                 continue             if now[1] < 0:                 print('W')                 label['s'][1] -= 1                 now[1] += 1                 zt_change()                 xiehuo()                 if len(need) == 0:                     break                 continue             if now[0] < 0:                 print('N')                 label['s'][0] -= 1                 now[0] += 1                 zt_change()                 xiehuo()                      if len(need) == 0:                     break                 continue             if now[0] > 0:                 print('S')                 label['s'][0] += 1                 now[0] -= 1                 zt_change()                 xiehuo()                 if len(need) == 0:                     break                 continue def caculate_distance():     for i in distance:         distance = abs(label['s'][0] - label[0]) + abs(label['s'][1] - label[1]) def get_near():     near_label = (sorted(distance, key=distance.get))     now_go = None     now = None     for i in range(5):         if need[near_label] != 0:             now_go = near_label            now = [label[now_go][0] - label['s'][0], label[now_go][1] - label['s'][1]]             break         else:             continue     return now_go, now如果输入捐赠小区，处理give有关字典。并更新当前状态（万一捐赠小区与当前位置重合）if inputs[0] == 'R':     if ''.join(inputs) in give_.keys():         give[''.join(inputs)][2] += int(inputs[3])     else:         give[''.join(inputs)] = ([int(inputs[1]), int(inputs[2]), int(inputs[3])])         give_[''.join(inputs)] = [int(inputs[1]), int(inputs[2])]     zt_change()     continue更新状态的函数def zt_change():     global now, now_go, exchang, shave, flag_back, flag, need, ta     if [label['s'][0], label['s'][1]] == cangku:#经过仓库         shave = 100     if ([label['s'][0], label['s'][1]] in give_.values()):#经过捐赠小区         key = get_key1(give_, [label['s'][0], label['s'][1]])         exchan = give[key[0]][2]         shave += exchan         if shave > 100:             a = shave             shave = 100             give[key[0]][2] = a - 100         else:             give[key[0]][2] = 0             give_.pop(key[0])             give.pop(key[0])     if ([label['s'][0], label['s'][1]] in list(label.values())[1:]):#经过需求小区         l = {key: value for key, value in label.items() if key in ['r1', 'r2', 'r3', 'r4', 'r5']}         key = get_key1(l, [label['s'][0], label['s'][1]])         exchang = need[key[0]]         need[key[0]] += shave         if need[key[0]] < 0:             shave = 0         if need[key[0]] >= 0:             shave = need[key[0]]             need[key[0]] = 0         if now[0] == 0 and now[1] == 0:             ta += need[key[0]] - exchang             flag = True         if need[key[0]] == 0:             need.pop(key[0])             distance.pop(key[0])             distancegi.pop(key[0])             label.pop(key[0])     if shave<edu:         flag_back = True其它函数def caculate_dis_return_need(x, y):     a = 0     for i in distancegi:         distancegi = (abs(x - label[0]) + abs(y - label[1]))     near = (sorted(distancegi, key=distancegi.get))     for i in range(5):         if need[near] != 0:             a = need[near]             break         else:             continue     return abs(a) def get_key1(dct, value): #根据字典值获取键     return list(filter(lambda k: dct[k] == value, dct)) def xiehuo(): #到达目的地需要重新规划路径     global now, now_go, exchang, shave, flag_back, flag, need     if now[0] == 0 and now[1] == 0:         flag = True

请问我在把编译后的例程拷到mdc mini上后运行时这个报错是因为什么呢？mini上的python是按照文档从host上拷过来，host里有python2和python3两个版本，mini里好像只有python3的版本。提前谢过大师们！

1.      配置yum源cd /etc/yum.repos.d/保留CentOS-Base.repo，同时vim cdrom.repo添加以下信息    [cdrom]    name=cdrom    baseurl=file:///mnt    enabled=1    gpgcheck=02.      挂载镜像mout -o loop Centos******.iso /mnt3.      安装相关依赖yum install numpy opencv* python-devel gstreamer-plugins-base-devel libv4l-devel libpng-devel libjpeg-turbo-devel jasper-devel openexr-devel libtiff-devel libwebp-devel python-sphinx texlive python3-devel python3.aarch64 -y #这部分依赖可以根据需要进行安装，参考链接：https://docs.opencv.org/3.0-beta/doc/py_tutorials/py_setup/py_setup_in_fedora/py_setup_in_fedora.html安装numpy    export CFLAGS="-O0"      #-O1 -O2 -O3会报错，需指定为-O0    pip3 install numpy==1.17.0 4.      下载opencv和opencv-contrib包https://github.com/opencv/opencv_contrib/releases/tag/4.3.0https://github.com/opencv/opencv/releases/tag/4.3.0说明:opencv和opencv_contrib的版本必须对应，否则可能造成编译失败分别上传到系统相目录下，然后解压5.      编译cd opencv-4.3.0/mkdir buildcd buildcmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_opencv_python3=YES -D BUILD_opencv_python2=NO -D PYTHON3_NUMPY_INCLUDE_DIRS=/usr/local/lib64/python3.6/site-packages/numpy/core/include/ -D OPENCV_EXTRA_MODULES=../../opencv_contrib-4.3.0/modules/ -D  PYTHON3_LIBRARIES=/lib64/libpython3.so -D PYTHON_DEFAULT_EXECUTABLE=/usr/bin/python3 -D __INSTALL_PATH_PYTHON3=/usr/local/lib/python3.6/site-packages/ .. 上面的命令根据实际情况进行修改或增加参数；cmake完成后需确认python3相应的四个参数均有值，如下图所示：6.      make -j64 && make install     7.      验证        

【Python算法】--非平稳时间序列分析1.非平稳时间序列分析　　上节介绍了对平稳时间序列进行分析的方法。实际上，在自然界中绝大部分序列都是非平稳的。因而对非平稳序列的分析更普遍、更重要，创造出来的分析方法也更多。　　对非平稳时间序列的分析方法可以分为确定性因素分解的时序分析和随机时序分析两大类。　　确定性因素分解的方法把所有序列的变化都归结为4个因素（长期趋势、季节变动、循环变动和随机波动）的综合影响，其中长期趋势和季节变动的规律性信息通常比较容易提取，而由随机因素导致的波动则非常难确定和分析，对随机信息浪费严重，会导致模型拟合精度不够理想。　　随机时序分析法的发展就是为了弥补确定性肉素分解方法的不足。根据时间序列的不同特点，随机时序分析可以建立的模型有ARIMA模型、残差自回归模型、季节模型、异方差模型等。 本节重点介绍使用ARIMA模型对非平稳时间序列进行建模的方法。2.差分运算　　1.p阶差分　　相距一期的两个序列值之间的减法运算称为一阶差分运算。　　2.步差分　　相距k期的两个序列值之间的减法运算称为k步差分运算。3.ARIMA模型　　差分运算具有强大的确定性信息提取能力，许多非平稳序列差分后会显示出平稳序列的性质，这时称这个非平稳序列为差分平稳序列。对差分平稳序列可以使用 ARMA 模型进行拟合。ARIMA 模型的实质就是差分运算与 ARMA 模型的组合，掌握了 ARMA 模型的建模方法和步骤以后，对序列建立 ARIMA 模型是比较简单的。　　差分平稳时间序列建模步骤如图所示：　　例：就餐饮企业而言，经常会碰到如下问题： 由于餐饮行业是生产和销售同时进行的，因此销售预测对于餐饮企业十分必要。如何基于菜品历史销售数据，做好餐饮销售预测，以便减少莱品脱销现象和避免因备料不足而造成的生产延误，从而减少菜品生产等待时间，提供给客户更优质的服务，同时可以减少安全库存量，做到生产准时制，降低物流成本。　　餐饮销售预测可以看作是基于时间序列的短期数据预测，预测对象为具体菜品销售量。 常用按时间顺序排列的一组随机变量X1, X2, … , Xt来表示一个随机事件的时间序列，简记为{Xt}；用x1,x2, … , xn或{xt , t = 1,2, … , n}表示该随机序列的 n 个有序观察值，称之为序列长度为 n 的观察值序列。 称之为序列长度为n的观察值序列。　　应用上述理论，可对2015/1/1~2015/2/6某餐厅的销售数据进行建模。　　具体数据如图所示:1.检验序列的平衡性　　①原始序列的时序图：　　时序图显示该序列具有明显的单调递增趋势，可以判断为是非平稳序列。　　② 原始序列的自相关图：　　自相关图显示自相关系数长期大于零，说明序列间具有很强的长期相关性。　　③ 原始序列的单位根检验，如图所示：　　单位根检验统计量对应的p值显著大于0.05，最终将该序列判断为非平稳序列（非平稳序列一定不是白噪声序列）。　　2.对一阶差分后的序列再次做平稳性判断　　① 一阶差分之后序列的时序图：　　② 一阶差分之后序列的自相关图：　　一阶差分之后序列的单位根检验，如图所示：　　结果显示，一阶差分之后的序列的时序图在均值附近比较平稳的波动、自相关图有很强的短期相关性、单位根检p值小于0.05，所以一阶差分之后的序列是平稳序列。　　对一阶差分后的序列做自噪声检验，如图所示：　　输出的p值远小于0.05，所以一阶差分之后的序列是平稳非白噪声序列。　　3.对一阶差分之后的平稳非白噪声序列拟合ARMA模型　　下面进行模型定阶。模型定阶就是确定p和q。 第一种方法：人为识别。经过一节差分后自相关图显示出一阶截尾，偏自相关图显示出拖尾性，所以可以考虑用MA(1)模型拟合一阶差分后的序列，即对原始序列建立 ARIMA(0,1,1)模型。　　第二种方法：相对最优模型识别。 计算ARMA(p,q)，当p和q均小于等于3的所有组合的BIC信息量，取其中BIC信息量达到最小的模型阶数。计算完成BIC矩阵如下：432.068472   422.510082  426.088911     426.595507  423.628276   426.073601  NaN            NaN  426.774824   427.395787  430.709154     NaN  430.317524   NaN         NaN            436.478109　　p值为0、q 值为1时最小BIC 值为：430.1374。p、q 定阶完成。 用AR(1)模型拟合一阶差分后的序列，即对原始序列建立ARIMA(0,1,1)模型。虽然两种方法建立的模型是一样的，但模型是非唯一的，可以检验 ARIMA(1,1,0)和 ARIMA(1,1,1)，这两个模型也能通过检验。　　4.对一阶差分后的序列拟合AR(1)模型进行分析 模型检验。残差为白噪声序列，p 值为：0.627016。 参数检验和参数估计如图所示：　　5.ARIMA模型预测 应用 ARIMA(0,1,1)对表某餐厅的销售数据做为期5天的预测，结果如图所示:　　需要说明的是，利用模型向前预测的时期越长，预测误差将会越大，这是时间预测的典型特点。

【Python算法】--平稳时间序列分析1.概述　　ARMA（Auto-Regressive and Moving Average Model）模型的全称是自回归移动平均模型，它是目前最常用的拟合平稳序列的模型。它又可以细分为AR模型、MA模型和ARMA三大类，三种模型都可以看作是多元线性回归模型。2.AR模型　　具有如下结构的模型称为p阶自回归模型，简记为 AR(p)。平稳AR模型的性质如图1所示：　(1) 均值　　对满足平稳性条件的AR(p)模型的方程，两边取期望，得：(2) 方差　　平稳AR(p)模型的方差有界，等于常数。　　(3) 自相关系数（ACF）3. MA模型　　具有如下结构的模型称为q阶自回归模型，简记为 MA(q)。平稳MA(q)模型的性质如图2所示：4.ARMA模型　　具有如下结构的模型称为自回归移动平均模型，简记为 ARMA(p,q)。认为x_txt主要是受过去p期的序列值和过去q期的误差项的共同影响。　　特别的：当q=0时，是AR(p)模型；当p=0时，是MA(q)模型。　　平稳 ARMA(p,q)模型的性质如图3所示:5.平稳时间序列建模　　某个时间序列经过预处理，被判定为平稳非自噪声序列，就可以利用ARMA模型进行建模。计算出平稳非白噪声序列{X_tXt}的自相关系数和偏自相关系数，再由AP(p)模型、MA(q)和ARMA(p,q)的自相关系数和偏自相关系数的性质，选择合适的模型。　　平稳时间序列建模步骤如图4所示：ARMA模型识别，也称为模型定阶，根据AR(P)模型、MA(q)和ARMA(p，q)的自相关系数和偏自相关系数的性质，选择合适的模型。　　识别的原则如图5所示：估计模型中未知参数的值并进行参数进行检验；模型检验；模型优化；模型应用：进行短期预测。