# Julia和Python线性矩阵机器学习和动态模型代码计算

<details>

<summary>关键词</summary>

Julia | Python | 线性 | 矩阵 | 数学 | 方程 | 矢量 | 聚类 | 几何 | 函数 | 弹性需求 | 价格 | 平衡 | 化学 | 动态 | 质量 | 离散 | 模型 | 建模 | 复合 | 二次状态 | 算法 | 拟合 | 回归 | 作用力 | 序列 | 投资 | 组合 | 价值 | 自适应矩估计 | 逻辑 | 分类 | 深度学习 | K均值 | K最近邻 | 贝叶斯 | 决策树 | 多项式 | 主成分分析 | 隐藏层 | 支持向量机 | 动态模型 | 时间分量 | 轨迹 | 弹簧 | 确定性系统 | 传染病 | 马尔科夫链 | 生存 | 随机性 | 队列 | 噪声 | 卡尔曼滤波 | 动态网络 | 稳定性

</details>

{% embed url="https://viadean.notion.site/Julia-Python-74ddb118ee7a47efad9eaa2a994f3800" %}

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

### 🎯要点

1. Julia和Python线性矩阵数学​方程​及代码​​：🎯矢量计算：🖊矢量：加法、标量向量乘法、内积 | 🖊线性：方程、泰勒近似、回归模型 | 🖊范数和距离：范数、距离、标准差、矢量角度 | 🖊聚类：K均值算法 | 🖊线性独立性：偏差、正交向量、格拉姆-施密特算法。🎯矩阵计算：🖊矩阵：从实体创建矩阵、零矩阵和单位矩阵、转置、加法和范数、矩阵向量乘法 | 🖊示例：几何变换、图的关联矩阵、卷积 | 🖊线性方程：线性和仿射函数、示例：弹性需求价格、平衡化学反应 | 🖊动态系统：示例：人口动态矩阵、疫情动态、截面中质量运动的离散模型 | 🖊矩阵乘法：矩阵-矩阵乘法、线性函数的复合、矩阵幂 | 🖊矩阵逆。🎯最小二乘法：🖊数据拟合、示例：房价回归模型、每小时臭氧水平、广告预算、最小物理作用力序列、复合投资组合价值、线性二次状态估计、算法实现：高斯-牛顿、莱文伯格-马夸特、惩罚算法、增强拉格朗日算法。
2. 静态数据机器学习：🎯Julia神经网络实现：🖊数字分类识别，🖊自适应矩估计算法、🖊随机梯度下降、🖊线性最小二乘法分类器、🖊逻辑回归分类器、🖊支持向量机、🖊随机森林、🖊密集神经网络和卷积神经网络、🖊交叉验证的岭回归、🖊深度学习dropout概率、🖊K均值聚类及层次聚类、🖊主成分分析及示例、🖊马尔可夫决策过程、🖊Q学习、🖊生成对抗网络。🎯Python神经网络实现：🖊贝叶斯线性回归、🖊分类决策树、🖊回归决策树、🖊K-最近邻、🖊K-均值聚类、🖊线性回归、🖊逻辑回归和多项式逻辑回归、🖊感知器、🖊主成分分析、🖊具有一个隐藏层的简单神经网络、🖊Softmax 回归、🖊支持向量机。
3. 动态模型：🎯Julia 时间分量 / 因随机变量：🖊追捕模型轨迹、🖊弹簧和质量动态平衡微分方程、🖊确定性动态系统传染病轨迹、🖊随机分量马尔可夫链、🖊马尔科夫链计算猫和老鼠生存机率、🖊马尔科夫链模拟随机性传染病、🖊先到先得离散队列事件模拟、🖊干扰因素下追捕模型轨迹、🖊卡尔曼滤波、🖊杜布-吉莱斯皮算法评估动态网络稳定性。

### 🍇Python对比Julia模拟性能

大型仿真系统不应该是一个所有事情都在一个地方完成的整体程序。将核心模拟与可视化或数据分析分开是有意义的。显然，模拟系统需要与可视化进行通信，例如使用输出数据文件离线或使用网络流在线。

该模拟是一个简单的空间捕食者-猎物关系模拟。 所有动物，无论是捕食者还是猎物，都被建模为代理。 面向对象编程非常适合这个小例子。 每个代理都是一个对象，我们有不同类型的代理。

#### Python模拟

我们在 Agent() 类中定义代理的通用行为。 update() 方法负责计算代理的新位置。整个模拟非常简单，但表现出相当复杂的行为。

```python
 class Agent():
     def __init__(self, x=None, y=None, world_width=0, world_height=0):
         super().__init__()
         self.vmax = 2.0
         self.world_width = world_width
         self.world_height = world_height
         self.x = x if x else random.randint(0, self.world_width)
         self.y = y if y else random.randint(0, self.world_height)
         self.dx = 0
         self.dy = 0
 ​
         self.is_alive = True
         self.target = None
         self.age = 0
         self.energy = 0
 ​
     def update(self, food=()):
         self.age = self.age + 1
 ​
         if self.vmax == 0:
             return
 ​
         if self.target and not self.target.is_alive:
             self.target = None
 ​
         if self.target:
             squared_dist = (self.x - self.target.x) ** 2 + (self.y - self.target.y) ** 2
             if squared_dist < 400:
                 self.target.is_alive = False
                 self.energy = self.energy + 1
 ​
         if self.target:
             fx += 0.1*(self.target.x - self.x)
             fy += 0.1*(self.target.y - self.y)
 ​
         self.dx = self.dx + 0.05 * fx
         self.dy = self.dy + 0.05 * fy
 ​
 ​
         velocity = math.sqrt(self.dx ** 2 + self.dy ** 2)
         if velocity > self.vmax:
             self.dx = (self.dx / velocity) * (self.vmax)
             self.dy = (self.dy / velocity) * (self.vmax)
 ​
         self.x = self.x + self.dx
         self.y = self.y + self.dy
 ​
         self.x = max(self.x, 0)
         self.x = min(self.x, self.world_width)
         self.y = max(self.y, 0)
         self.y = min(self.y, self.world_height)
```

一旦我们决定测量程序的速度，我们就必须定义将如何准确地做到这一点。乍一看，这似乎是一项微不足道的任务。只需运行该程序并测量需要多长时间。我们的模拟最初由捕食者、猎物和植物组成。 他们每个人都有一个随机位置。 使用固定值来为随机数生成器提供种子是已知的技术。 这保证了如果您运行同一个程序两次，结果将是相同的。

如果您用两种不同的语言编写程序，可能会存在细微的差异。 例如，在像我们这里使用的模拟这样的情况下，舍入误差可能会产生影响。 一种语言可能使用不同的方法进行算术或使用不同的内部符号和浮点数精度。

即使起点完全相同，结果也可能完全不同，因此运行时间也可能完全不同。一种可能的方法是使用随机值（例如当前时间）为随机数生成器提供种子。然后运行实验几次并使用平均运行时间。

#### Julia模拟

```julia
 %%julia
 Base.@kwdef mutable struct Agent
     vmax::Float64 = 2.5
     world_width::Int = 10
     world_height::Int = 10
     x::Int = rand(0:world_width)
     y::Int = rand(0:world_height)
 ​
     dx::Float64 = 0.0
     dy::Float64 = 0.0
 ​
     is_alive::Bool = true
     target::Union{Nothing, Agent} = nothing
     age::Int = 0
     energy::Int = 0
 end
 ​
 Predator(; kwargs...) = Agent(; vmax = 2.5, kwargs...)
 Prey(; kwargs...) = Agent(; vmax = 2.0, kwargs...)
 Plant(; kwargs...) = Agent(; vmax = 0.0, kwargs...)
```

```julia
 %%julia
 function update!(self, food)
     self.age = self.age + 1
 ​
     if self.vmax == 0.0
         return
     end
 ​
     if self.target !== nothing && !self.target.is_alive
         self.target = nothing
     end
 ​
     if self.target !== nothing
         squared_dist = (self.x - self.target.x) ^ 2 + (self.y - self.target.y) ^ 2
         if squared_dist < 400
             self.target.is_alive = false
             self.energy = self.energy + 1
         end
 ​
     else
         min_dist = 9999999
         min_agent = nothing
         for a in food
             if a !== self && a.is_alive
                 sq_dist = (self.x - a.x) ^ 2 + (self.y - a.y) ^ 2
                 if sq_dist < min_dist
                     min_dist = sq_dist
                     min_agent = a
                 end
             end
         end
         if min_dist < 100000
             self.target = min_agent
         end
     end
 ​
     fx = 0.0
     fy = 0.0
 ​
     if self.target !== nothing
         fx += 0.1 * (self.target.x - self.x)
         fy += 0.1 * (self.target.y - self.y)
     end
 ​
     self.dx = self.dx + 0.05 * fx
     self.dy = self.dy + 0.05 * fy
 ​
     velocity = sqrt(self.dx ^ 2 + self.dy ^ 2)
     if velocity > self.vmax
         self.dx = (self.dx / velocity) * (self.vmax)
         self.dy = (self.dy / velocity) * (self.vmax)
     end
 ​
     self.x = self.x + Int(round(self.dx))
     self.y = self.y + Int(round(self.dy))
 ​
     self.x = max(self.x, 0)
     self.x = min(self.x, self.world_width)
     self.y = max(self.y, 0)
     self.y = min(self.y, self.world_height)
 end
```
