---
description: >-
  1. 使用相似性度量等算法类别学习评估大脑神经相似性。 2. 使用混淆矩阵分类器评估相似性，使用斯皮尔曼相关性关联相似度矩阵与混淆矩阵。 3.
  特征化体素选择，优化相似性度量矩阵，用分类器近似大脑状态信息。 4.
  将先验分布建模为二项分布，将更新后的分布建模为另一个二项分布，并计算库尔巴克-莱布勒散度 5. 使用三种分类器：高斯朴素贝叶斯、k最近邻和线性支持向量机。
  6. 使用探照灯视觉检查脑图像
---

# Python体素化脑信息图混淆矩阵相似性指标评估

{% embed url="https://viadean.notion.site/Python-10f1ae7b9a328056855be2e54ae4610c" %}

{% content-ref url="../zhi-dian-mi-jin-brief" %}
[zhi-dian-mi-jin-brief](../zhi-dian-mi-jin-brief)
{% endcontent-ref %}

### 🍪语言内容分比

{% @mermaid/diagram content="pie title 语言分比
 "Python":90
 "R":40
 "C/C++":20" %}

{% @mermaid/diagram content="pie title 内容分比
 "神经科学":40
 "算法模型":80
 "数学、概率统计、矩阵":60
 "几何学":30
 "测量指标":30" %}

### 🍇Python闵可夫斯基距离

闵可夫斯基距离或闵可夫斯基度量是赋范向量空间中的度量，可以看作是欧几里得距离和曼哈顿距离的推广。它以波兰数学家赫尔曼·闵可夫斯基的名字命名。两点之间 p 阶闵可夫斯基距离（其中 p 为整数）

$$
X=\left(x_1, x_2, \ldots, x_n\right) \text { 和 } Y=\left(y_1, y_2, \ldots, y_n\right) \in R ^n
$$

定义为：

$$
D(X, Y)=\left(\sum_{i=1}^n\left|x_i-y_i\right|^p\right)^{\frac{1}{p}}\qquad(1)
$$

对于 $$p \geq 1$$，闵可夫斯基距离是根据闵可夫斯基不等式得出的度量。当 $$p<1$$ 时，(0,0) 和 (1,1) 之间的距离为 $$2^{1 / p}>2$$，但点 (0,1) 与这两个点的距离均为 1。由于这违反了三角不等式，因此对于$$p<1$$，它不是度量。但是，只需删除 1 / p 的指数即可获得这些值的度量。得到的度量也是 F 范数。

通常使用闵可夫斯基距离，其中 p 为 1 或 2 ，分别对应于曼哈顿距离和欧几里得距离。 在 p 趋向无穷大的极限情况下，我们得到切比雪夫距离：

$$
\lim _{p \rightarrow \infty}\left(\sum_{i=1}^n\left|x_i-y_i\right|^p\right)^{\frac{1}{p}}=\max _{i=1}^n\left|x_i-y_i\right|
$$

类似地，对于 p 达到负无穷大，我们有：

$$
\lim _{p \rightarrow-\infty}\left(\sum_{i=1}^n\left|x_i-y_i\right|^p\right)^{\frac{1}{p}}=\min _{i=1}^n\left|x_i-y_i\right|
$$

闵可夫斯基距离也可以看作是 P 和 Q 之间各分量差异的幂均值的倍数。

### Python和C++/C#/Java计算闵可夫斯基距离

给定两个数组 A\[] 和 B\[] 作为 n 维空间中两个点的位置向量以及一个整数 p，任务是计算这两点之间的闵可夫斯基距离。根据上式（1），假设，输入A\[] = {1,2,3,4}, B\[] = {5,6,7,8}, P = 3 输出是 6.340，输入A = {1,2,3,4}, B\[] = {5,6,7,8} P = 2 ，输出是8。

```
 import math
 ​
 def minkowski(A, B, P):
     X = 0.0
     for i in range(len(A)):
         X += abs(A[i] - B[i]) ** P
     
     Z = 1.0 / P
     return X ** Z
 ​
 if __name__ == "__main__":
     A = [1, 2, 3, 4]
     B = [5, 6, 7, 8]
     P = 2.0
 ​
     print(minkowski(A, B, P))
```

C++计算闵可夫斯基距离

```cpp
 #include <bits/stdc++.h>
 using namespace std;
 ​
 double minkowski(const vector<double>& A,
                 const vector<double>& B, double P)
 {
 ​
     double X = 0.0;
     for (size_t i = 0; i < A.size(); ++i) {
         X += pow(abs(A[i] - B[i]), P);
     }
     
     double Z = 1.0 / P;
     return pow(X, Z);
 }
 ​
 int main()
 {
 ​
     vector<double> A = { 1, 2, 3, 4 };
     vector<double> B = { 5, 6, 7, 8 };
     double P = 2.0;
 ​
     cout << minkowski(A, B, P) << endl;
     return 0;
 }
 ​
```

C#计算闵可夫斯基距离

```csharp
 using System;
 using System.Collections.Generic;
 ​
 public class Program
 {
     static double Minkowski(List<double> A, List<double> B, double P)
     {
         double X = 0.0;
         for (int i = 0; i < A.Count; ++i)
         {
             X += Math.Pow(Math.Abs(A[i] - B[i]), P);
         }
         double Z = 1.0 / P;
         return Math.Pow(X, Z);
     }
 ​
     public static void Main()
     {
         List<double> A = new List<double> { 1, 2, 3, 4 };
         List<double> B = new List<double> { 5, 6, 7, 8 };
         double P = 2.0;
         Console.WriteLine(Minkowski(A, B, P));
     }
 }
```

Java计算闵可夫斯基距离

```java
 import java.util.ArrayList;
 import java.util.List;
 ​
 public class MinkowskiDistance {
 ​
     private static double
     minkowski(List<Double> A, List<Double> B, double P)
     {
         double X = 0.0;
         for (int i = 0; i < A.size(); ++i) {
             X += Math.pow(Math.abs(A.get(i) - B.get(i)), P);
         }
         double Z = 1.0 / P;
         return Math.pow(X, Z);
     }
 ​
     public static void main(String[] args)
     {
         List<Double> A = List.of(1.0, 2.0, 3.0, 4.0);
         List<Double> B = List.of(5.0, 6.0, 7.0, 8.0);
         double P = 2.0;
         System.out.println(minkowski(A, B, P));
     }
 }
 ​
```
