曼哈顿算法

① 什么是曼哈顿更新规则

梯度符号。曼哈顿更新规则和弹性传播训练算法只使用梯度符号。曼哈顿（Manhattan），是美国纽约市5个行政区之中人口最稠密的一个区，也是最小的一个行政区。曼哈顿主要由曼哈顿岛、罗斯福岛组成，并被东河、哈得孙河以及哈莱姆河包围。

② 全面归纳距离和相似度计算方法

距离(distance，差异程度)、相似度(similarity，相似程度)方法可以看作是以某种的距离函数计算元素间的距离，这些方法作为机器学习的基础概念，广泛应用于如：Kmeans聚类、协同过滤推荐算法、相似度算法、MSE损失函数等等。本文对常用的距离计算方法进行归纳以及解析，分为以下几类展开：

对于点x=(x1,x2...xn) 与点y=(y1,y2...yn) , 闵氏距离可以用下式表示：

闵氏距离是对多个距离度量公式的概括性的表述，p=1退化为曼哈顿距离；p=2退化为欧氏距离；切比雪夫距离是闵氏距离取极限的形式。

曼哈顿距离 公式：

欧几里得距离公式：

如下图蓝线的距离即是曼哈顿距离（想象你在曼哈顿要从一个十字路口开车到另外一个十字路口实际驾驶距离就是这个“曼哈顿距离”，此即曼哈顿距离名称的来源，也称为城市街区距离），红线为欧几里得距离：

切比雪夫距离起源于国际象棋中国王的走法，国际象棋中国王每次只能往周围的8格中走一步，那么如果要从棋盘中A格(x1,y1)走到B格(x2,y2)最少需要走几步？你会发现最少步数总是max(|x2-x1|,|y2-y1|)步。有一种类似的一种距离度量方法叫切比雪夫距离。

切比雪夫距离就是当p趋向于无穷大时的闵氏距离：

距离函数并不一定是距离度量，当距离函数要作为距离度量，需要满足：

由此可见，闵氏距离可以作为距离度量，而大部分的相似度并不能作为距离度量。

闵氏距离也是Lp范数（如p==2为常用L2范数正则化）的一般化定义。
下图给出了一个Lp球（ ||X||p = 1 ）的形状随着P的减少的可视化图：

距离度量随着空间的维度d的不断增加，计算量复杂也逐增，另外在高维空间下，在维度越高的情况下，任意样本之间的距离越趋于相等（样本间最大与最小欧氏距离之间的相对差距就趋近于0），也就是维度灾难的问题，如下式结论：

对于维度灾难的问题，常用的有PCA方法进行降维计算。

假设各样本有年龄，工资两个变量，计算欧氏距离（p=2）的时候，(年龄1-年龄2)² 的值要远小于(工资1-工资2)² ，这意味着在不使用特征缩放的情况下，距离会被工资变量（大的数值）主导, 特别当p越大，单一维度的差值对整体的影响就越大。因此，我们需要使用特征缩放来将全部的数值统一到一个量级上来解决此问题。基本的解决方法可以对数据进行“标准化”和“归一化”。

另外可以使用马氏距离（协方差距离），与欧式距离不同其考虑到各种特性之间的联系是（量纲）尺度无关 (Scale Invariant) 的，可以排除变量之间的相关性的干扰，缺点是夸大了变化微小的变量的作用。马氏距离定义为：

马氏距离原理是使用矩阵对两两向量进行投影后，再通过常规的欧几里得距离度量两对象间的距离。当协方差矩阵为单位矩阵，马氏距离就简化为欧氏距离；如果协方差矩阵为对角阵，其也可称为正规化的欧氏距离。

根据向量x,y的点积公式：

我们可以利用向量间夹角的cos值作为向量相似度[1]：

余弦相似度的取值范围为：-1~1，1 表示两者完全正相关，-1 表示两者完全负相关，0 表示两者之间独立。余弦相似度与向量的长度无关，只与向量的方向有关，但余弦相似度会受到向量平移的影响（上式如果将 x 平移到 x+1, 余弦值就会改变）。

另外，归一化后计算欧氏距离，等价于余弦值：两个向量x,y, 夹角为A，欧氏距离D=(x-y)^2 = x ^2+y 2-2|x||y|cosA = 2-2cosA

协方差是衡量多维数据集中，变量之间相关性的统计量。如下公式X，Y的协方差即是，X减去其均值 乘以 Y减去其均值，所得每一组数值的期望（平均值）。

如果两个变量之间的协方差为正值，则这两个变量之间存在正相关，若为负值，则为负相关。

皮尔逊相关系数数值范围也是[-1，1]。皮尔逊相关系数可看作是在余弦相似度或协方差基础上做了优化（变量的协方差除以标准差）。它消除每个分量标准不同（分数膨胀）的影响，具有平移不变性和尺度不变性。

卡方检验X2，主要是比较两个分类变量的关联性、独立性分析。如下公式，A代表实际频数；E代表期望频数：

Levenshtein 距离是 编辑距离 (Editor Distance) 的一种，指两个字串之间，由一个转成另一个所需的最少编辑操作次数。允许的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。
像hallo与hello两个字符串编辑距离就是1，我们通过替换”a“ 为 ”e“，就可以完成转换。

汉明距离为两个等长字符串对应位置的不同字符的个数，也就是将一个字符串变换成另外一个字符串所需要替换的字符个数。例如：1011101 与 1001001 之间的汉明距离是 2，“toned” 与 “roses” 之间的汉明距离是 3

另外的，对于字符串距离来说，不同字符所占的份量是不一样的。比如”我乐了“ 与【“我怒了”，”我乐了啊” 】的Levenshtein 距离都是1，但其实两者差异还是很大的，因为像“啊”这种语气词的重要性明显不如“乐”，考虑字符（特征）权重的相似度方法有：TF-IDF、BM25、WMD算法。

Jaccard 取值范围为0~1，0 表示两个集合没有重合，1 表示两个集合完全重合。

但Dice不满足距离函数的三角不等式，不是一个合适的距离度量。

基础地介绍下信息熵，用来衡量一个随机变量的不确定性程度。对于一个随机变量 X，其概率分布为：

互信息用于衡量两个变量之间的关联程度，衡量了知道这两个变量其中一个，对另一个不确定度减少的程度。公式为：

如下图，条件熵表示已知随机变量X的情况下，随机变量Y的信息熵，因此互信息实际上也代表了已知随机变量X的情况下，随机变量Y的(信息熵)不确定性的减少程度。

JS 散度解决了 KL 散度不对称的问题，定义为：

群体稳定性指标（Population Stability Index，PSI）， 可以看做是解决KL散度非对称性的一个对称性度量指标，用于度量分布之间的差异（常用于风控领域的评估模型预测的稳定性）。

psi与JS散度的形式是非常类似的，如下公式：

PSI的含义等同P与Q，Q与P之间的KL散度之和。

DTW 距离用于衡量两个序列之间的相似性，适用于不同长度、不同节奏的时间序列。DTW采用了动态规划DP（dynamic programming）的方法来进行时间规整的计算，通过自动warping扭曲 时间序列（即在时间轴上进行局部的缩放），使得两个序列的形态尽可能的一致，得到最大可能的相似度。(具体可参考[5])

图结构间的相似度计算，有图同构、最大共同子图、图编辑距离、Graph Kernel 、图嵌入计算距离等方法（具体可参考[4][6]）。

度量学习的对象通常是样本特征向量的距离，度量学习的关键在于如何有效的度量样本间的距离，目的是通过训练和学习，减小或限制同类样本之间的距离，同时增大不同类别样本之间的距离，简单归类如下[2]：

最后，附上常用的距离和相似度度量方法[3]：

③ 常见的相似度度量算法

本文目录：

  定义在两个向量（两个点）上：点x和点y的欧式距离为：

  常利用欧几里得距离描述相似度时，需要取倒数归一化，sim = 1.0/(1.0+distance)，利用numpy实现如下：

python实现欧式距离

  从名字就可以猜出这种距离的计算方法了。想象你在曼哈顿要从一个十字路口开车到另外一个十字路口，驾驶距离是两点间的直线距离吗？显然不是，除非你能穿越大楼。实际驾驶距离就是这个“曼哈顿距离”。而这也是曼哈顿距离名称的来源， 曼哈顿距离也称为城市街区距离(City Block distance)。

  (1)二维平面两点a(x1,y1)与b(x2,y2)间的曼哈顿距离

  (2)两个n维向量a(x11,x12,…,x1n)与 b(x21,x22,…,x2n)间的曼哈顿距离

   python实现曼哈顿距离：

  国际象棋玩过么？国王走一步能够移动到相邻的8个方格中的任意一个。那么国王从格子(x1,y1)走到格子(x2,y2)最少需要多少步？自己走走试试。你会发现最少步数总是max( | x2-x1 | , | y2-y1 | ) 步 。有一种类似的一种距离度量方法叫切比雪夫距离。

  (1)二维平面两点a(x1,y1)与b(x2,y2)间的切比雪夫距离

  (2)两个n维向量a(x11,x12,…,x1n)与 b(x21,x22,…,x2n)间的切比雪夫距离

   python实现切比雪夫距离：

  闵氏距离不是一种距离，而是一组距离的定义。

  两个n维变量a(x11,x12,…,x1n)与 b(x21,x22,…,x2n)间的闵可夫斯基距离定义为：

  其中p是一个变参数。

  当p=1时，就是曼哈顿距离

  当p=2时，就是欧氏距离

  当p→∞时，就是切比雪夫距离

  根据变参数的不同，闵氏距离可以表示一类的距离。

  闵氏距离，包括曼哈顿距离、欧氏距离和切比雪夫距离都存在明显的缺点。

  举个例子：二维样本(身高,体重)，其中身高范围是150 190，体重范围是50 60，有三个样本：a(180,50)，b(190,50)，c(180,60)。那么a与b之间的闵氏距离（无论是曼哈顿距离、欧氏距离或切比雪夫距离）等于a与c之间的闵氏距离，但是身高的10cm真的等价于体重的10kg么？因此用闵氏距离来衡量这些样本间的相似度很有问题。

  简单说来，闵氏距离的缺点主要有两个：

  (1)将各个分量的量纲(scale)，也就是“单位”当作相同的看待了。

  (2)没有考虑各个分量的分布（期望，方差等)可能是不同的。

  标准欧氏距离的定义

  标准化欧氏距离是针对简单欧氏距离的缺点而作的一种改进方案。标准欧氏距离的思路：既然数据各维分量的分布不一样，好吧！那我先将各个分量都“标准化”到均值、方差相等吧。均值和方差标准化到多少呢？这里先复习点统计学知识吧，假设样本集X的均值(mean)为m，标准差(standard deviation)为s，那么X的“标准化变量”表示为：

  而且标准化变量的数学期望为0，方差为1。因此样本集的标准化过程(standardization)用公式描述就是：

  标准化后的值 = ( 标准化前的值 － 分量的均值 ) /分量的标准差

  经过简单的推导就可以得到两个n维向量a(x11,x12,…,x1n)与 b(x21,x22,…,x2n)间的标准化欧氏距离的公式：

  如果将方差的倒数看成是一个权重，这个公式可以看成是一种加权欧氏距离(Weighted Euclidean distance)。

  有M个样本向量X1~Xm，协方差矩阵记为S，均值记为向量μ，则其中样本向量X到u的马氏距离表示为：

  而其中向量Xi与Xj之间的马氏距离定义为：

  若协方差矩阵是单位矩阵（各个样本向量之间独立同分布）,则公式就成了：

  也就是欧氏距离了。

  若协方差矩阵是对角矩阵，公式变成了标准化欧氏距离。

  马氏距离的优缺点：量纲无关，排除变量之间的相关性的干扰。

  几何中夹角余弦可用来衡量两个向量方向的差异，机器学习中借用这一概念来衡量样本向量之间的差异。

  在二维空间中向量A(x1,y1)与向量B(x2,y2)的夹角余弦公式：

  两个n维样本点a(x11,x12,…,x1n)和b(x21,x22,…,x2n)的夹角余弦

  类似的，对于两个n维样本点a(x11,x12,…,x1n)和b(x21,x22,…,x2n)，可以使用类似于夹角余弦的概念来衡量它们间的相似程度。

  即：

  夹角余弦取值范围为[-1,1]。夹角余弦越大表示两个向量的夹角越小，夹角余弦越小表示两向量的夹角越大。当两个向量的方向重合时夹角余弦取最大值1，当两个向量的方向完全相反夹角余弦取最小值-1。

python实现余弦相似度：

  两个等长字符串s1与s2之间的汉明距离定义为将其中一个变为另外一个所需要作的最小替换次数。例如字符串“1111”与“1001”之间的汉明距离为2。

  应用：信息编码（为了增强容错性，应使得编码间的最小汉明距离尽可能大）。

python实现汉明距离：

  两个集合A和B的交集元素在A，B的并集中所占的比例，称为两个集合的杰卡德相似系数，用符号J(A,B)表示。

  杰卡德相似系数是衡量两个集合的相似度一种指标。

  与杰卡德相似系数相反的概念是杰卡德距离(Jaccard distance)。杰卡德距离可用如下公式表示：

  杰卡德距离用两个集合中不同元素占所有元素的比例来衡量两个集合的区分度。

  可将杰卡德相似系数用在衡量样本的相似度上。

  样本A与样本B是两个n维向量，而且所有维度的取值都是0或1。例如：A(0111)和B(1011)。我们将样本看成是一个集合，1表示集合包含该元素，0表示集合不包含该元素。

  p ：样本A与B都是1的维度的个数

  q ：样本A是1，样本B是0的维度的个数

  r ：样本A是0，样本B是1的维度的个数

  s ：样本A与B都是0的维度的个数

  这里p+q+r可理解为A与B的并集的元素个数，而p是A与B的交集的元素个数。

  而样本A与B的杰卡德距离表示为：

  皮尔逊相关系数即为相关系数 ( Correlation coefficient )与相关距离(Correlation distance)

  相关系数的定义

  相关系数是衡量随机变量X与Y相关程度的一种方法，相关系数的取值范围是[-1,1]。相关系数的绝对值越大，则表明X与Y相关度越高。当X与Y线性相关时，相关系数取值为1（正线性相关）或-1（负线性相关）。

1. 机器学习中的相似性度量

2. 推荐算法入门（1）相似度计算方法大全

3. Python Numpy计算各类距离

4. 皮尔逊积矩相关系数

④ A*算法介绍

姓名：车文扬 学号：16020199006

【嵌牛导读】：A*算法的逐步详解

【嵌牛鼻子】：启发式算法

【嵌牛提问】：A*算法的原理是什么？

【嵌牛正文】：

A*算法

路径规划是指的是机器人的最优路径规划问题，即依据某个或某些优化准则（如工作代价最小、行走路径最短、行走时间最短等），在工作空间中找到一个从起始状态到目标状态能避开障碍物的最优路径。机器人的路径规划应用场景极丰富，最常见如游戏中NPC及控制角色的位置移动，网络地图等导航问题，小到家庭扫地机器人、无人机大到各公司正争相开拓的无人驾驶汽车等。

目前路径规划算法分为：

A*算法原理：

在计算机科学中，A*算法作为Dijkstra算法的扩展，因其高效性而被广泛应用于寻路及图的遍历，如星际争霸等游戏中就大量使用。在理解算法前，我们需要知道几个概念：

搜索区域（The Search Area）：图中的搜索区域被划分为了简单的二维数组，数组每个元素对应一个小方格，当然我们也可以将区域等分成是五角星，矩形等，通常将一个单位的中心点称之为搜索区域节点（Node）。

开放列表(Open List)：我们将路径规划过程中待检测的节点存放于Open List中，而已检测过的格子则存放于Close List中。

父节点（parent）：在路径规划中用于回溯的节点，开发时可考虑为双向链表结构中的父结点指针。

路径排序（Path Sorting）：具体往哪个节点移动由以下公式确定：F(n) = G + H 。G代表的是从初始位置A沿着已生成的路径到指定待检测格子的移动开销。H指定待测格子到目标节点B的估计移动开销。

启发函数（Heuristics Function）：H为启发函数，也被认为是一种试探，由于在找到唯一路径前，我们不确定在前面会出现什么障碍物，因此用了一种计算H的算法，具体根据实际场景决定。在我们简化的模型中，H采用的是传统的曼哈顿距离（Manhattan Distance），也就是横纵向走的距离之和。

如下图所示，绿色方块为机器人起始位置A，红色方块为目标位置B，蓝色为障碍物。

我们把要搜寻的区域划分成了正方形的格子。这是寻路的第一步，简化搜索区域。这个特殊的方法把我们的搜索区域简化为了2 维数组。数组的每一项代表一个格子，它的状态就是可走(walkalbe)或不可走(unwalkable) 。现用A*算法寻找出一条自A到B的最短路径，每个方格的边长为10，即垂直水平方向移动开销为10。因此沿对角移动开销约等于14。具体步骤如下：

从起点 A 开始，把它加入到一个由方格组成的open list(开放列表) 中，这个open list像是一个购物清单。Open list里的格子是可能会是沿途经过的，也有可能不经过。因此可以将其看成一个待检查的列表。查看与A相邻的8个方格 ，把其中可走的 (walkable) 或可到达的(reachable) 方格加入到open list中。并把起点 A 设置为这些方格的父节点 (parent node) 。然后把 A 从open list中移除，加入到close list(封闭列表) 中，close list中的每个方格都是不需要再关注的。

如下图所示，深绿色的方格为起点A，它的外框是亮蓝色，表示该方格被加入到了close list 。与它相邻的黑色方格是需要被检查的，他们的外框是亮绿色。每个黑方格都有一个灰色的指针指向他们的父节点A。

下一步，我们需要从open list中选一个与起点A相邻的方格。但是到底选择哪个方格好呢？选F值最小的那个。我们看看下图中的一些方格。在标有字母的方格中G = 10 。这是因为水平方向从起点到那里只有一个方格的距离。与起点直接相邻的上方，下方，左方的方格的G 值都是10 ，对角线的方格G 值都是14 。H值通过估算起点到终点( 红色方格) 的Manhattan 距离得到，仅作横向和纵向移动，并且忽略沿途的障碍。使用这种方式，起点右边的方格到终点有3 个方格的距离，因此H = 30 。这个方格上方的方格到终点有4 个方格的距离( 注意只计算横向和纵向距离) ，因此H = 40 。

比较open list中节点的F值后，发现起点A右侧节点的F=40，值最小。选作当前处理节点，并将这个点从Open List删除，移到Close List中。

对这个节点周围的8个格子进行判断，若是不可通过（比如墙，水，或是其他非法地形）或已经在Close List中，则忽略。否则执行以下步骤：

若当前处理节点的相邻格子已经在Open List中，则检查这条路径是否更优，即计算经由当前处理节点到达那个方格是否具有更小的 G值。如果没有，不做任何操作。相反，如果G值更小，则把那个方格的父节点设为当前处理节点 ( 我们选中的方格 ) ，然后重新计算那个方格的 F 值和 G 值。

若当前处理节点的相邻格子不在Open List中，那么把它加入，并将它的父节点设置为该节点。

按照上述规则我们继续搜索，选择起点右边的方格作为当前处理节点。它的外框用蓝线打亮，被放入了close list 中。然后我们检查与它相邻的方格。它右侧的3个方格是墙壁，我们忽略。它左边的方格是起点，在close list 中，我们也忽略。其他4个相邻的方格均在open list 中，我们需要检查经由当前节点到达那里的路径是否更好。我们看看上面的方格，它现在的G值为14 ，如果经由当前方格到达那里，G值将会为20( 其中10为从起点到达当前方格的G值，此外还要加上从当前方格纵向移动到上面方格的G值10) ，因此这不是最优的路径。看图就会明白直接从起点沿对角线移动到那个方格比先横向移动再纵向移动要好。

当把4个已经在open list 中的相邻方格都检查后，没有发现经由当前节点的更好路径，因此不做任何改变。接下来要选择下一个待处理的节点。因此再次遍历open list ，现在open list中只有7 个方格了，我们需要选择F值最小的那个。这次有两个方格的F值都是54，选哪个呢？没什么关系。从速度上考虑，选择最后加入open list 的方格更快。因此选择起点右下方的方格，如下图所示。

接下来把起点右下角F值为54的方格作为当前处理节点，检查其相邻的方格。我们发现它右边是墙（墙下面的一格也忽略掉，假定墙角不能直接穿越)，忽略之。这样还剩下 5 个相邻的方格。当前方格下面的 2 个方格还没有加入 open list ，所以把它们加入，同时把当前方格设为他们的父亲。在剩下的 3 个方格中，有 2 个已经在 close list 中 ( 一个是起点，一个是当前方格上面的方格，外框被加亮的 ) ，我们忽略它们。最后一个方格，也就是当前方格左边的方格，检查经由当前方格到达那里是否具有更小的 G 值。没有，因此我们准备从 open list 中选择下一个待处理的方格。

不断重复这个过程，直到把终点也加入到了open list 中，此时如下图所示。注意在起点下方2 格处的方格的父亲已经与前面不同了。之前它的G值是28并且指向它右上方的方格。现在它的G 值为20 ，并且指向它正上方的方格。这是由于在寻路过程中的某处使用新路径时G值更小，因此父节点被重新设置，G和F值被重新计算。

那么我们怎样得到实际路径呢？很简单，如下图所示，从终点开始，沿着箭头向父节点移动，直至回到起点，这就是你的路径。

A*算法总结：

1. 把起点加入 open list 。

2. 重复如下过程：

a. 遍历open list ，查找F值最小的节点，把它作为当前要处理的节点，然后移到close list中

b. 对当前方格的 8 个相邻方格一一进行检查，如果它是不可抵达的或者它在close list中，忽略它。否则，做如下操作：

□  如果它不在open list中，把它加入open list，并且把当前方格设置为它的父亲

□  如果它已经在open list中，检查这条路径 ( 即经由当前方格到达它那里 ) 是否更近。如果更近，把它的父亲设置为当前方格，并重新计算它的G和F值。如果你的open list是按F值排序的话，改变后你可能需要重新排序。

c. 遇到下面情况停止搜索：

□  把终点加入到了 open list 中，此时路径已经找到了，或者

□  查找终点失败，并且open list 是空的，此时没有路径。

3. 从终点开始，每个方格沿着父节点移动直至起点，形成路径。

⑤ 已知两点经纬度，怎么求两点的曼哈顿距离

假设地球半径为R曼哈顿距离求的即是球面直角三角形两条直角边的距离之和。设点1(x1,y1)，点2(x2,y2)假设x2>x1以x2所在纬线(半径为R2)为基准，d1=2 pi R2 |y2-y1|/360，东经为正，西经为负，若|y2-y1|>180，实际的d1*=2 pi R2-d1，若|y2-y1|<180，d1*=d1d2=2 pi R |x2-x1|/360，北纬为正，南纬为负d=d2+d1*

⑥ 聚类算法有哪些分类

聚类算法的分类有：

1、划分法

划分法(partitioning methods)，给定一个有N个元组或者纪录的数据集，分裂法将构造K个分组，每一个分组就代表一个聚类，K小于N。而且这K个分组满足下列条件：

（1） 每一个分组至少包含一个数据纪录；

（2）每一个数据纪录属于且仅属于一个分组（注意：这个要求在某些模糊聚类算法中可以放宽）；

2、层次法

层次法(hierarchical methods)，这种方法对给定的数据集进行层次似的分解，直到某种条件满足为止。具体又可分为“自底向上”和“自顶向下”两种方案。

例如，在“自底向上”方案中，初始时每一个数据纪录都组成一个单独的组，在接下来的迭代中，它把那些相互邻近的组合并成一个组，直到所有的记录组成一个分组或者某个条件满足为止。

3、密度算法

基于密度的方法(density-based methods)，基于密度的方法与其它方法的一个根本区别是：它不是基于各种各样的距离的，而是基于密度的。这样就能克服基于距离的算法只能发现“类圆形”的聚类的缺点。

4、图论聚类法

图论聚类方法解决的第一步是建立与问题相适应的图，图的节点对应于被分析数据的最小单元，图的边（或弧）对应于最小处理单元数据之间的相似性度量。因此，每一个最小处理单元数据之间都会有一个度量表达，这就确保了数据的局部特性比较易于处理。图论聚类法是以样本数据的局域连接特征作为聚类的主要信息源，因而其主要优点是易于处理局部数据的特性。

5、网格算法

基于网格的方法(grid-based methods)，这种方法首先将数据空间划分成为有限个单元（cell）的网格结构,所有的处理都是以单个的单元为对象的。这么处理的一个突出的优点就是处理速度很快，通常这是与目标数据库中记录的个数无关的，它只与把数据空间分为多少个单元有关。

代表算法有：STING算法、CLIQUE算法、WAVE-CLUSTER算法；

6、模型算法

基于模型的方法(model-based methods)，基于模型的方法给每一个聚类假定一个模型，然后去寻找能够很好的满足这个模型的数据集。这样一个模型可能是数据点在空间中的密度分布函数或者其它。它的一个潜在的假定就是：目标数据集是由一系列的概率分布所决定的。

通常有两种尝试方向：统计的方案和神经网络的方案。

(6)曼哈顿算法扩展阅读：

聚类算法的要求：

1、可伸缩性

许多聚类算法在小于 200 个数据对象的小数据集合上工作得很好；但是，一个大规模数据库可能包含几百万个对象，在这样的大数据集合样本上进行聚类可能会导致有偏的结果。

我们需要具有高度可伸缩性的聚类算法。

2、不同属性

许多算法被设计用来聚类数值类型的数据。但是，应用可能要求聚类其他类型的数据，如二元类型(binary)，分类/标称类型（categorical/nominal），序数型（ordinal）数据，或者这些数据类型的混合。

3、任意形状

许多聚类算法基于欧几里得或者曼哈顿距离度量来决定聚类。基于这样的距离度量的算法趋向于发现具有相近尺度和密度的球状簇。但是，一个簇可能是任意形状的。提出能发现任意形状簇的算法是很重要的。

4、领域最小化

许多聚类算法在聚类分析中要求用户输入一定的参数，例如希望产生的簇的数目。聚类结果对于输入参数十分敏感。参数通常很难确定，特别是对于包含高维对象的数据集来说。这样不仅加重了用户的负担，也使得聚类的质量难以控制。

5、处理“噪声”

绝大多数现实中的数据库都包含了孤立点，缺失，或者错误的数据。一些聚类算法对于这样的数据敏感，可能导致低质量的聚类结果。

6、记录顺序

一些聚类算法对于输入数据的顺序是敏感的。例如，同一个数据集合，当以不同的顺序交给同一个算法时，可能生成差别很大的聚类结果。开发对数据输入顺序不敏感的算法具有重要的意义。

⑦ 人工智能 A*算法原理

A 算法是启发式算法重要的一种，主要是用于在两点之间选择一个最优路径，而A 的实现也是通过一个估值函数

上图中这个熊到树叶的 曼哈顿距离 就是蓝色线所表示的距离，这其中不考虑障碍物，假如上图每一个方格长度为1，那么此时的熊的曼哈顿距离就为9.
起点（X1,Y1）,终点（X2,Y2）,H=|X2-X1|+|Y2-Y1|
我们也可以通过几何坐标点来算出曼哈顿距离，还是以上图为例，左下角为（0，0）点，熊的位置为（1，4），树叶的位置为（7，1），那么H=|7-1|+|1-4|=9。

还是以上图为例，比如刚开始熊位置我们会加入到CLOSE列表中，而熊四周它可以移动到的点位我们会加入到OPEN列表中，并对熊四周的8个节点进行F=G+H这样的估值运算，然后在这8个节点中选中一个F值为最小的节点，然后把再把这个节点从OPEN列表中删除，加入到Close列表中，从接着在对这个节点的四周8个节点进行一个估值运算，再接着依次运算，这样说大家可能不是太理解，我会在下边做详细解释。

从起点到终点，我们通过A星算法来找出最优路径

我们把每一个方格的长度定义为1，那从起始点到5位置的代价就是1，到3的代价为1.41，定义好了我们接着看上图，接着运算

第一步我们会把起始点四周的点加入OPEN列表中然后进行一个估值运算，运算结果如上图，这其中大家看到一个小箭头都指向了起点，这个箭头就是指向父节点，而open列表的G值都是根据这个进行计算的，意思就是我从上一个父节点运行到此处时所需要的总代价，如果指向不一样可能G值就不一样，上图中我们经过计算发现1点F值是7.41是最小的，那我们就选中这个点，并把1点从OPEN列表中删除，加入到CLOSE列表中，但是我们在往下运算的时候发现1点的四周，2点，3点和起始点这三个要怎么处理，首先起始点已经加入到了CLOSE，他就不需要再进行这种运算，这就是CLOSE列表的作用，而2点和3点我们也可以对他进行运算，2点的运算，我们从1移动到2点的时候，他需要的代价也就是G值会变成2.41，而H值是不会变的F=2.41+7=9.41，这个值我们发现大于原来的的F值，那我们就不能对他进行改变（把父节点指向1，把F值改为9.41，因为我们一直追求的是F值最小化），3点也同理。

在对1点四周进行运算后整个OPEN列表中有两个点2点和3点的F值都是7.41，此时我们系统就可能随机选择一个点然后进行下一步运算，现在我们选中的是3点，然后对3点的四周进行运算，结果是四周的OPEN点位如果把父节点指向3点值时F值都比原来的大，所以不发生改变。我们在看整个OPEN列表中，也就2点的7.41值是最小的，那我们就选中2点接着运算。

我们在上一部运算中选中的是1点，上图没有把2点加入OPEN列表，因为有障碍物的阻挡从1点他移动不到2点，所以没有把2点加入到OPEN列表中，整个OPEN列表中3的F=8是最小的，我们就选中3，我们对3点四周进行运算是我们发现4点经过计算G=1+1=2，F=2+6=8所以此时4点要进行改变，F变为8并把箭头指向3点（就是把4点的父节点变为3），如下图

我们就按照这种方法一直进行运算，最后 的运算结果如下图

而我们通过目标点位根据箭头（父节点），一步一步向前寻找最后我们发现了一条指向起点的路径，这个就是我们所需要的最优路径。 如下图的白色选中区域

但是我们还要注意几点

最优路径有2个

这是我对A*算法的一些理解，有些地方可能有BUG，欢迎大家指出，共同学习。

⑧ lua语言a星寻路算法路径怎么平滑

在项目中遇到了自动寻路的需求，于是决定开始学习一下A星，对于A星我也没有深究，只能说是勉强搞定了需求，在这和大家分享一下，相互进步，

A星有个公式 f(x) = g(x) + h(x)
,搞清楚这个公式就好办了，f(x)就是当前位置到下一个位置的总价值，g(x)表示实际价，这是说这一部分代价是确定的，h(x)表示估价值，就是说我
从下一个位置到到终点的代价是未知的，所以叫估价值，如图中所示，黑色格子表示当前位置，绿色格子表示下一步可能到达的位置，即上、下、左、右这几个方
向，红色格子表示终点，褐色表示障碍物，现在要从黑色格子到达红色格子，那么黑色格子的下一步肯定是绿色格子当中的一个，黑色格子到绿色格子之间是相挨着
的，所以我们可以很明确的知道它的实际代价为1（移动一步的代价）即g(x)，绿色格子到红色格子之间隔着很长的距离，中间还有障碍物，所以这个代价是未
知的，即h(x)，所以总的代价就为f(x) = g(x) +
h(x)，我们看到周围有4个绿色的格子，到底走那一步比较好呢，所以我们要把这4个格子的f(x)值都求出来，然后进行排序，选择f(x)值最小的，即
总代价最少的那个格子，以此方法继续下去，直到到达终点 或者 地图上没有绿色格子了

下面来看一下这个工具类，g(x)和h(x)要选的比较合适，一般就是采用的曼哈顿算法，即两点在x方向和y方向的距离之和，
-- Filename: PathUtil.lua
-- Author: bzx
-- Date: 2014-07-01
-- Purpose: 寻路

mole("PathUtil", package.seeall)

local _map_data -- 地图数据
local _open_list -- 开放节点
local _open_map -- 开放节点，为了提高性能而加
local _close_map -- 关闭节点
local _deleget -- 代理
local _dest_point -- 目标点
local _start_point -- 起点
local _path -- 路径

-- 寻找路径
--[[
deleget = {
g = function(point1, point2)
-- add your code
-- 返回点point1到点point2的实际代价
end
h = function(point1, point2)
-- add your code
-- 返回点point1到点point2的估算代价
end
getValue = function(j, i)
-- 返回地图中第i行，第j列的数据 1为障碍物，0为非障碍物
end
width -- 地图宽度
height -- 地图高度
}
--]]
function findPath(deleget, start_point, dest_point)
_deleget = deleget
_dest_point = dest_point
_start_point = start_point
init()
while not table.isEmpty(_open_list) do
local cur_point = _open_list[1]
table.remove(_open_list, 1)
_open_map[cur_point.key] = nil
if isEqual(cur_point, dest_point) then
return makePath(cur_point)
else
_close_map[cur_point.key] = cur_point
local next_points = getNextPoints(cur_point)
for i = 1, #next_points do
local next_point = next_points[i]
if _open_map[next_point.key] == nil and _close_map[next_point.key] == nil and isObstacle(next_point) == false then
_open_map[next_point.key] = next_point
table.insert(_open_list, next_point)
end
end
table.sort(_open_list, compareF)
end
end
return nil
end

function init()
_open_list = {}
_open_map = {}
_close_map = {}
_path = {}
_map_data = {}
for i = 1, _deleget.height do
_map_data[i] = {}
for j = 1, _deleget.width do
local value = _deleget.getValue(j, i)
_map_data[i][j] = value
end
end
_open_map[getKey(_start_point)] = _start_point
table.insert(_open_list, _start_point)
end

function createPoint(x, y)
local point = {
["x"] = x,
["y"] = y,
["last"] = nil,
["g_value"] = 0,
["h_value"] = 0,
["f_value"] = 0
}
point["key"] = getKey(point)
return point
end

-- 得到下一个可以移动的点
-- @param point 当前所在点
function getNextPoints(point)
local next_points = {}
for i = 1, #_deleget.directions do
local offset = _deleget.directions[i]
local next_point = createPoint(point.x + offset[1], point.y + offset[2])
next_point["last"] = point
if next_point.x >= 1 and next_point.x <= _deleget.width and next_point.y >= 1 and next_point.y <= _deleget.height then
next_point["g_value"] = _deleget.g(point, next_point)
next_point["h_value"] = _deleget.h(point, _dest_point)--math.abs(next_points.x - _dest_point.x) + math.abs(next_points.y - _dest_point.y)
next_point["f_value"] = next_point.g_value + next_point.h_value
table.insert(next_points, next_point)
end
end
return next_points
end

-- 得到路径
-- @param end_point 目标点
function makePath(end_point)
_path = {}
local point = end_point
while point.last ~= nil do
table.insert(_path, createPoint(point.x, point.y))
point = point.last
end
local start_point = point
table.insert(_path, start_point)
return _path
end

-- 两个点的代价比较器
function compareF(point1, point2)
return point1.f_value < point2.f_value
end

-- 是否是障碍物
function isObstacle(point)
local value = _map_data[point.y][point.x]
if value == 1 then
return true
end
return false
end

-- 两个点是否是同一个点
function isEqual(point1, point2)
return point1.key == point2.key
end

-- 根据点得到点的key
function getKey(point)
local key = string.format("%d,%d", point.x, point.y)
return key
end

下面是工具类PathUtil的用法
local deleget = {}
deleget.g = function(point1, point2)
return math.abs(point1.x - point2.x) + math.abs(point1.y - point2.y)
end
deleget.h = deleget.g
deleget.getValue = function(j, i)
local index = FindTreasureUtil.getIndex(j, i)
local map_info = _map_info.map[index]
if map_info.display == 0 and map_info.eid ~= 1 then
return 0
end
return 1
end
deleget.directions = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}} -- 左，上，下，右
deleget.width = _cols
deleget.height = _rows

local dest_row, dest_col = FindTreasureUtil.getMapPosition(tag)
local dest_point = PathUtil.createPoint(dest_col, dest_row)
local start_row, start_col = FindTreasureUtil.getMapPosition(_player_index)
local start_point = PathUtil.createPoint(start_col, start_row)
_path = PathUtil.findPath(deleget, start_point, dest_point)

_path就是我们找到的路径，起点为最后一个元素，终点为第一个元素