【算法】粒子群优化

一、引言

        粒子群优化算法（Particle Swarm Optimization, PSO）是一种基于群体智能的优化技术，由Eberhart和Kennedy在1995年提出。它模拟鸟群觅食行为，通过个体与群体的协作来寻找最优解。通过模拟一群粒子的运动来寻找最优解。每个粒子代表一个可能的解，并且根据自身经验和群体经验来更新位置。

二、算法原理

        PSO算法中，每个解被视为搜索空间中的一个“粒子”，每个粒子代表了问题的潜在解，并具有相应的位置和速度。粒子在搜索空间中飞行，通过跟踪两个“极值”来更新自己的位置和速度：

  • 个体极值：粒子自身所找到的最优解。
  • 全局极值：整个粒子群中所有粒子所找到的最优解。

        粒子的位置和速度根据个体极值和全局极值进行更新。

三、数据结构

PSO算法涉及的主要数据结构包括：

  • 粒子（Particle）：

    • position: 当前粒子的位置
    • velocity: 当前粒子的速度
    • best_position: 粒子的历史最佳位置
    • best_value: 粒子的最佳适应度值

  • 群体（Swarm）：

    • particles: 存储所有粒子的列表
    • global_best_position: 全局最佳位置
    • global_best_value: 全局最佳适应度值
  • 目标函数：粒子优化的目标函数，用于评估解的质量。

四、算法使用场景

PSO算法适用于：

  • 函数优化：连续空间的全局优化问题、寻找函数的最小值或最大值
  • 神经网络训练：作为权重调整的优化算法。

  • 模式识别：特征选择和参数优化。
  • 机器学习参数优化：在训练机器学习模型时，PSO可以用于优化模型参数。
  • 组合优化问题：如旅行商问题（TSP）、排程问题等。
  • 工程设计问题：如结构优化、电路设计等。
  • 路径规划：在机器人和无人机的路径规划中寻找最优路径。
  • 图像处理：图像分割和特征选择等。

五、算法实现

伪代码如下：

function PSO(numParticles, numIterations):
Initialize particles and global best
For each iteration:
For each particle:
Update velocity
Update position
Evaluate the fitness function
Update personal and global bests

六、其他同类算法对比

  • 遗传算法（Genetic Algorithm, GA）：基于自然选择和遗传机制的搜索算法。
  • 模拟退火（Simulated Annealing, SA）：基于物理退火过程的优化方法。
  • 蚁群算法（Ant Colony Optimization, ACO）：模拟蚂蚁觅食行为的启发式搜索算法。

七、多语言代码实现

    Java

import java.util.Random;class Particle {double[] position;double[] velocity;double[] bestPosition;double bestValue;public Particle(int dimensions, double lowerBound, double upperBound) {position = new double[dimensions];velocity = new double[dimensions];bestPosition = new double[dimensions];Random rand = new Random();for (int i = 0; i < dimensions; i++) {position[i] = lowerBound + (upperBound - lowerBound) * rand.nextDouble();velocity[i] = (rand.nextDouble() - 0.5) * 2; // Random velocity}bestPosition = position.clone();bestValue = Double.POSITIVE_INFINITY;}
}class PSO {private Particle[] particles;private double[] globalBestPosition;private double globalBestValue;private int dimensions;private double lowerBound;private double upperBound;private int maxIter;public PSO(int numParticles, int dimensions, double lowerBound, double upperBound, int maxIter) {this.dimensions = dimensions;this.lowerBound = lowerBound;this.upperBound = upperBound;this.maxIter = maxIter;particles = new Particle[numParticles];globalBestPosition = new double[dimensions];globalBestValue = Double.POSITIVE_INFINITY;for (int i = 0; i < numParticles; i++) {particles[i] = new Particle(dimensions, lowerBound, upperBound);}}public void optimize() {Random rand = new Random();for (int iter = 0; iter < maxIter; iter++) {for (Particle particle : particles) {double value = objectiveFunction(particle.position);if (value < particle.bestValue) {particle.bestValue = value;particle.bestPosition = particle.position.clone();}if (value < globalBestValue) {globalBestValue = value;globalBestPosition = particle.position.clone();}}for (Particle particle : particles) {double inertia = 0.5;double cognitive = 1.5 * rand.nextDouble() * (particle.bestPosition[0] - particle.position[0]);double social = 1.5 * rand.nextDouble() * (globalBestPosition[0] - particle.position[0]);for (int i = 0; i < dimensions; i++) {particle.velocity[i] = inertia * particle.velocity[i] + cognitive + social;particle.position[i] += particle.velocity[i];// Bound checkif (particle.position[i] < lowerBound) particle.position[i] = lowerBound;if (particle.position[i] > upperBound) particle.position[i] = upperBound;}}}}private double objectiveFunction(double[] position) {double sum = 0;for (double v : position) {sum += v * v; // Example: sum of squares}return sum;}public double[] getGlobalBestPosition() {return globalBestPosition;}public double getGlobalBestValue() {return globalBestValue;}public static void main(String[] args) {PSO pso = new PSO(30, 2, -10, 10, 100);pso.optimize();System.out.println("Best Position: " + Arrays.toString(pso.getGlobalBestPosition()));System.out.println("Best Value: " + pso.getGlobalBestValue());}
}

C++

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <limits>
#include <cmath>class Particle {
public:std::vector<double> position;std::vector<double> velocity;std::vector<double> bestPosition;double bestValue;Particle(int dimensions, double lowerBound, double upperBound) {position.resize(dimensions);velocity.resize(dimensions);bestPosition.resize(dimensions);for (int i = 0; i < dimensions; ++i) {position[i] = lowerBound + static_cast<double>(rand()) / RAND_MAX * (upperBound - lowerBound);velocity[i] = (static_cast<double>(rand()) / RAND_MAX - 0.5) * 2; // Random velocity}bestPosition = position;bestValue = std::numeric_limits<double>::infinity();}
};class PSO {
private:std::vector<Particle> particles;std::vector<double> globalBestPosition;double globalBestValue;int dimensions;double lowerBound;double upperBound;int maxIter;public:PSO(int numParticles, int dimensions, double lowerBound, double upperBound, int maxIter): dimensions(dimensions), lowerBound(lowerBound), upperBound(upperBound), maxIter(maxIter) {particles.reserve(numParticles);globalBestValue = std::numeric_limits<double>::infinity();for (int i = 0; i < numParticles; ++i) {particles.emplace_back(dimensions, lowerBound, upperBound);}}void optimize() {for (int iter = 0; iter < maxIter; ++iter) {for (auto& particle : particles) {double value = objectiveFunction(particle.position);if (value < particle.bestValue) {particle.bestValue = value;particle.bestPosition = particle.position;}if (value < globalBestValue) {globalBestValue = value;globalBestPosition = particle.position;}}for (auto& particle : particles) {double inertia = 0.5;double cognitive = 1.5 * static_cast<double>(rand()) / RAND_MAX * (particle.bestPosition[0] - particle.position[0]);double social = 1.5 * static_cast<double>(rand()) / RAND_MAX * (globalBestPosition[0] - particle.position[0]);for (int i = 0; i < dimensions; ++i) {particle.velocity[i] = inertia * particle.velocity[i] + cognitive + social;particle.position[i] += particle.velocity[i];// Bound checkif (particle.position[i] < lowerBound) particle.position[i] = lowerBound;if (particle.position[i] > upperBound) particle.position[i] = upperBound;}}}}double objectiveFunction(const std::vector<double>& position) {double sum = 0;for (double v : position) {sum += v * v; // Example: sum of squares}return sum;}const std::vector<double>& getGlobalBestPosition() const {return globalBestPosition;}double getGlobalBestValue() const {return globalBestValue;}
};int main() {srand(static_cast<unsigned>(time(0)));PSO pso(30, 2, -10, 10, 100);pso.optimize();const auto& bestPosition = pso.getGlobalBestPosition();std::cout << "Best Position: ";for (const auto& pos : bestPosition) {std::cout << pos << " ";}std::cout << "\nBest Value: " << pso.getGlobalBestValue() << std::endl;return 0;
}

Python

import numpy as npclass Particle:def __init__(self, bounds):self.position = np.random.uniform(bounds[0], bounds[1], size=(len(bounds)//2,))self.velocity = np.random.uniform(-1, 1, size=(len(bounds)//2,))self.best_position = self.position.copy()self.best_value = float('inf')class PSO:def __init__(self, func, bounds, num_particles, max_iter):self.func = funcself.bounds = boundsself.num_particles = num_particlesself.max_iter = max_iterself.particles = [Particle(bounds) for _ in range(num_particles)]self.global_best_position = Noneself.global_best_value = float('inf')def optimize(self):for _ in range(self.max_iter):for particle in self.particles:value = self.func(particle.position)if value < particle.best_value:particle.best_value = valueparticle.best_position = particle.position.copy()if value < self.global_best_value:self.global_best_value = valueself.global_best_position = particle.position.copy()for particle in self.particles:r1, r2 = np.random.rand(2)inertia = 0.5cognitive = 1.5 * r1 * (particle.best_position - particle.position)social = 1.5 * r2 * (self.global_best_position - particle.position)particle.velocity = inertia * particle.velocity + cognitive + socialparticle.position += particle.velocity# Bound checkparticle.position = np.clip(particle.position, self.bounds[0], self.bounds[1])return self.global_best_position, self.global_best_value# Example usage
def objective_function(x):return sum(x**2)bounds = [-10, 10]
pso = PSO(objective_function, bounds, num_particles=30, max_iter=100)
best_position, best_value = pso.optimize()
print(f"Best Position: {best_position}, Best Value: {best_value}")

 Go

package mainimport ("fmt""math/rand""time"
)type Particle struct {position     []float64velocity     []float64bestPosition []float64bestValue    float64
}type PSO struct {particles          []ParticleglobalBestPosition []float64globalBestValue    float64dimensions         intlowerBound         float64upperBound         float64maxIter            int
}func NewParticle(dimensions, lowerBound, upperBound float64) Particle {position := make([]float64, dimensions)velocity := make([]float64, dimensions)bestPosition := make([]float64, dimensions)for i := 0; i < int(dimensions); i++ {position[i] = lowerBound + rand.Float64()*(upperBound-lowerBound)velocity[i] = (rand.Float64() - 0.5) * 2 // Random velocity}copy(bestPosition, position)return Particle{position, velocity, bestPosition, 1e10}
}func NewPSO(numParticles, dimensions int, lowerBound, upperBound float64, maxIter int) *PSO {particles := make([]Particle, numParticles)for i := 0; i < numParticles; i++ {particles[i] = NewParticle(float64(dimensions), lowerBound, upperBound)}return &PSO{particles, nil, 1e10, dimensions, lowerBound, upperBound, maxIter}
}func (pso *PSO) objectiveFunction(position []float64) float64 {sum := 0.0for _, v := range position {sum += v * v // Example: sum of squares}return sum
}func (pso *PSO) Optimize() {for iter := 0; iter < pso.maxIter; iter++ {for i := range pso.particles {particle := &pso.particles[i]value := pso.objectiveFunction(particle.position)if value < particle.bestValue {particle.bestValue = valueparticle.bestPosition = make([]float64, len(particle.position))copy(particle.bestPosition, particle.position)}if value < pso.globalBestValue {pso.globalBestValue = valuepso.globalBestPosition = make([]float64, len(particle.position))copy(pso.globalBestPosition, particle.position)}}for i := range pso.particles {particle := &pso.particles[i]inertia := 0.5cognitive := 1.5 * rand.Float64() * (particle.bestPosition[0] - particle.position[0])social := 1.5 * rand.Float64() * (pso.globalBestPosition[0] - particle.position[0])for j := 0; j < pso.dimensions; j++ {particle.velocity[j] = inertia*particle.velocity[j] + cognitive + socialparticle.position[j] += particle.velocity[j]// Bound checkif particle.position[j] < pso.lowerBound {particle.position[j] = pso.lowerBound}if particle.position[j] > pso.upperBound {particle.position[j] = pso.upperBound}}}}
}func main() {rand.Seed(time.Now().UnixNano())pso := NewPSO(30, 2, -10, 10, 100)pso.Optimize()fmt.Printf("Best Position: %v\n", pso.globalBestPosition)fmt.Printf("Best Value: %v\n", pso.globalBestValue)
}

八、实际服务应用场景与代码框架

        实现一个供应链优化系统，使用粒子群优化算法来确定最优的货物分配策略。

系统架构

        问题定义：定义货物分配的优化目标和约束条件。

        粒子初始化：初始化粒子群，每个粒子代表一种可能的货物分配方案。

        评估与更新：评估每个粒子的适应度，并根据PSO算法更新粒子的位置和速度。

        最优解获取：经过多次迭代后，获取最优的货物分配方案。

代码框架

以下是使用Python实现的供应链优化系统的代码框架：

class SupplyChainOptimizer:def __init__(self, num_particles, dimensions, lower_bound, upper_bound):self.pso = PSO(num_particles, dimensions, lower_bound, upper_bound)def evaluate_fitness(self, particle):# 评估货物分配方案的适应度passdef optimize(self, iterations):for _ in range(iterations):self.pso.update_velocity_position()self.pso.evaluate()def get_best_solution(self):# 获取最优解pass# 使用示例
optimizer = SupplyChainOptimizer(num_particles=30, dimensions=5, lower_bound=-10, upper_bound=10)
optimizer.optimize(100)
best_solution = optimizer.get_best_solution()
print(f"Best solution: {best_solution}")

   数据准备

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score# Load dataset
data = load_iris()
X = data.data
y = data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

定义目标函数

def objective_function(params):C, gamma = paramsmodel = SVC(C=C, gamma=gamma)model.fit(X_train, y_train)predictions = model.predict(X_test)return -accuracy_score(y_test, predictions)  # Minimize negative accuracy

粒子群优化实现

class Particle:def __init__(self, bounds):self.position = np.random.uniform(bounds[0], bounds[1], size=(len(bounds)//2,))self.velocity = np.random.uniform(-1, 1, size=(len(bounds)//2,))self.best_position = self.position.copy()self.best_value = float('inf')class PSO:def __init__(self, func, bounds, num_particles, max_iter):self.func = funcself.bounds = boundsself.num_particles = num_particlesself.max_iter = max_iterself.particles = [Particle(bounds) for _ in range(num_particles)]self.global_best_position = Noneself.global_best_value = float('inf')def optimize(self):for _ in range(self.max_iter):for particle in self.particles:value = self.func(particle.position)if value < particle.best_value:particle.best_value = valueparticle.best_position = particle.position.copy()if value < self.global_best_value:self.global_best_value = valueself.global_best_position = particle.position.copy()for particle in self.particles:r1, r2 = np.random.rand(2)inertia = 0.5cognitive = 1.5 * r1 * (particle.best_position - particle.position)social = 1.5 * r2 * (self.global_best_position - particle.position)particle.velocity = inertia * particle.velocity + cognitive + socialparticle.position += particle.velocity# Bound checkparticle.position = np.clip(particle.position, self.bounds[0], self.bounds[1])return self.global_best_position, self.global_best_value

 执行优化

bounds = [[0.1, 100], [0.0001, 1]]  # C and gamma bounds
pso = PSO(objective_function, bounds, num_particles=30, max_iter=100)
best_params, best_value = pso.optimize()
print(f"Best Parameters: C={best_params[0]}, gamma={best_params[1]}, Best Value: {best_value}")

        过去与现在：PSO最初应用于函数优化问题，随着研究的深入，逐渐扩展到机器学习、数据挖掘、图像处理等多个领域。近年来，研究者对PSO进行了多种改进，如引入混沌理论、模糊逻辑等，以增强其全局搜索能力和收敛速度。

        优势：PSO具有简单易懂的结构和较少的参数设置，适用于多种优化问题。它能够有效地处理非线性、多峰值和高维问题，且收敛速度较快，适合实时优化。

        缺点：尽管PSO表现出色，但仍存在一些不足之处，如易陷入局部最优解、对参数设置敏感等。此外，在处理高维复杂问题时，可能会出现收敛速度减慢的问题。

        粒子群优化算法凭借其灵活性和有效性，已成为优化领域的重要工具，仍有广阔的发展空间。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/52354.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

qtcreator的vim模式下commit快捷键ctrl+g,ctrl+c没有反应的问题

qtcreator的vim模式下commit快捷键ctrl+g,ctrl+c没有反应的问题

首先开启vim后&#xff0c;CtrlG&#xff0c;CtrlC无法用 解决&#xff1a; 工具 -> 选项->FakeVim 转到Ex Command Mapping 搜索Commit 底栏Regular expression 输入commit &#xff08;理论上可以是随意的单词&#xff09; 设置好后&#xff0c;以后要运行&#x…
阅读更多...
ETF指数通行红绿灯对接自动交易框架！添加绿灯品种进交易池！股票量化分析工具QTYX-V2.8.9...

ETF指数通行红绿灯对接自动交易框架！添加绿灯品种进交易池！股票量化分析工具QTYX-V2.8.9...

前言 我们的股票量化系统QTYX在实战中不断迭代升级!!! 指数通行红绿灯作用就是识别出上升和下降趋势品种。对于上升趋势的品种&#xff0c;在红转绿时买入&#xff0c;绿转红时卖出&#xff0c;当识别出下降趋势后要果断离场&#xff01; 在QTYX的2.8.7版本我们推出了“ETF全自…
阅读更多...
【css】伪元素实现跟随鼠标移动的渐变效果

【css】伪元素实现跟随鼠标移动的渐变效果

主要功能是在按钮上实现鼠标跟随渐变效果。每当用户将鼠标移动到按钮上时&#xff0c;按钮会显示一个以鼠标位置为中心的渐变效果。 1. 核心部分: 监听鼠标在元素内移动 监听鼠标在元素内移动&#xff0c;并触发该事件。 const handleMouseMove (e: MouseEvent) > {if (…
阅读更多...
el-form中使用v-model和prop实现动态校验

el-form中使用v-model和prop实现动态校验

如何在Vue的el-form中使用v-model和prop实现动态校验&#xff0c;包括多个变量控制校验、数组循环校验和字段级条件显示。通过实例演示了如何配合rules和自定义验证函数来确保表单的完整性和有效性。 公式&#xff1a; 动态校验项的v-model的绑定值 el-form的属性 :model的值 …
阅读更多...
多系统萎缩不慌张，这些维生素是你的“守护神”✨

多系统萎缩不慌张，这些维生素是你的“守护神”✨

亲爱的朋友们&#xff0c;今天我们来聊聊一个可能不太为人熟知但至关重要的健康话题——多系统萎缩&#xff08;MSA&#xff09;。面对这样的挑战&#xff0c;除了医疗治疗&#xff0c;日常的营养补充也是不可或缺的一环。特别是维生素&#xff0c;它们在我们的身体中扮演着举足…
阅读更多...
FastGPT+ollama 搭建私有AI大模型智能体工作流-Mac

FastGPT+ollama 搭建私有AI大模型智能体工作流-Mac

一、大模型工作流的优势 1. 降低任务门槛&#xff1a;工作流可以将复杂任务分解成多个小任务&#xff0c;降低每个任务的复杂度&#xff0c;从而减少对提示词和大模型推理能力的依赖。这样可以提升大模型处理复杂任务的性能和容错能力。 2. 提升任务效率&#xff1a;工作流可以…
阅读更多...
【OpenHarmony】openharmony移植到RK3568------获取源码编译OpenHarmony源码

【OpenHarmony】openharmony移植到RK3568------获取源码编译OpenHarmony源码

一、源码获取 源码获取有好几种方式&#xff0c;在这里直接在镜像网站下载源码&#xff0c;点击下面连接下载全量版本的OpenHarmony4.1 https://repo.huaweicloud.com/openharmony/os/4.1-Release/code-v4.1-Release.tar.gz 将源码放到自己建立的目录下解压&#xff0c;我放…
阅读更多...
PHP轻创推客集淘客地推任务平台于一体的综合营销平台系统源码

PHP轻创推客集淘客地推任务平台于一体的综合营销平台系统源码

&#x1f680;轻创推客&#xff0c;营销新纪元 —— 集淘客与地推任务于一体的全能平台&#x1f310; &#x1f308;【开篇&#xff1a;营销新潮流&#xff0c;轻创推客引领未来】 在瞬息万变的营销世界里&#xff0c;你还在为寻找高效、全面的营销渠道而烦恼吗&#xff1f;&…
阅读更多...
[Meachines] [Easy] jerry Tomcat用户暴力破解+war包webshell上传

[Meachines] [Easy] jerry Tomcat用户暴力破解+war包webshell上传

信息收集 IP AddressOpening Ports10.10.10.95TCP:8080 $ sudo masscan -p1-65535 10.10.10.95 --rate1000 -e tun0 > /tmp/ports $ ports$(cat /tmp/ports | awk -F " " {print $4} | awk -F "/" {print $1} | sort -n | tr \n , | sed s/,$//) $ …
阅读更多...
微服务——远程调用

微服务——远程调用

为什么需要远程调用&#xff1f; 在微服务架构中&#xff0c;每个服务都是独立部署和运行的&#xff0c;它们之间需要相互协作以完成复杂的业务逻辑。因此&#xff0c;远程调用成为微服务之间通信的主要方式。通过远程调用&#xff0c;一个服务可以请求另一个服务执行某些操作或…
阅读更多...
【前端面试】操作系统

【前端面试】操作系统

进程与线程 进程线程定义是计算机中的程序关于某数据集合上的一次运行活动&#xff0c;是系统进行资源分配和调度的基本单位是进程中的一个实体&#xff0c;是CPU调度和分派的基本单位&#xff0c;共享进程的资源资源分配拥有独立的内存空间和系统资源共享进程的内存和资源开销…
阅读更多...
Educational Codeforces Round 169 (Rated for Div. 2)

Educational Codeforces Round 169 (Rated for Div. 2)

前言 电脑显示屏一闪一闪地感觉要拿去修了&#xff0c;比赛时重启了好几次。 手速场&#xff0c;E 题没学过 Sprague-Grundy 吃了亏&#xff0c;好在前四题都一发过才不至于掉分。 Standings&#xff1a;1214 题目链接&#xff1a;Dashboard - Educational Codeforces Round 16…
阅读更多...
【架构设计】-- aarch(ARM) and X86

【架构设计】-- aarch(ARM) and X86

1、aarch(ARM) 架构 &#xff08;1&#xff09;操作系统支持&#xff1a;早期为 32 位操作系统&#xff0c;目前大部分都是 64 位操作系统 &#xff08;2&#xff09;全称&#xff1a;Advanced RISC Machine&#xff0c;由英国ARM Holdings plc公司开发 这种架构主要⽤于智能…
阅读更多...
Android车载蓝牙音乐实例（附Demo源码）：实现手机播放音乐后车机应用显示音乐名称，歌手，专辑名。且可控制上一曲下一曲，暂停播放功能

Android车载蓝牙音乐实例（附Demo源码）：实现手机播放音乐后车机应用显示音乐名称，歌手，专辑名。且可控制上一曲下一曲，暂停播放功能

一、功能需求 功能需求是在Android10以上设备上实现蓝牙音乐功能&#xff0c;细分为两个功能点&#xff1a; 1、手机和车载设备实现蓝牙连接 &#xff08;本Demo文只做监听蓝牙连接状态&#xff0c;需手动到设置中连接蓝牙&#xff09; 2、连接蓝牙成功后手机播放音乐时车载…
阅读更多...
leetcode 递归（回溯）——java实现

leetcode 递归（回溯）——java实现

递归算法与DFS类似&#xff0c;也与二叉树的先序遍历类似 以下摘自 leetcode回溯算法入门级详解 回溯法 采用试错的思想&#xff0c;它尝试分步的去解决一个问题。在分步解决问题的过程中&#xff0c;当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候&#xff…
阅读更多...
MySQL笔记01: MySQL入门_1.2 MySQL下载安装与配置

MySQL笔记01: MySQL入门_1.2 MySQL下载安装与配置

2.2 MySQL下载安装与配置 2.2.1 MySQL下载 MySQL中文官网&#xff1a;https://www.mysql.com/cn/ MySQL英文官网&#xff1a;https://www.mysql.com/ MySQL官网下载地址&#xff1a;https://www.mysql.com/downloads/ &#xff08;1&#xff09;点击“MySQL Community (GPL) Do…
阅读更多...
TinaSDKV2.0 自定义系统开发

TinaSDKV2.0 自定义系统开发

TinaSDKV2.0 自定义系统开发 什么是自定义系统&#xff1f; TinaSDK Kconfig界面配置 Tina Linux采用 Kconfig 机制对 SDK 和内核进行配置。 Kconfig 是一种固定格式的配置文件。Linux 编译环境中的 menuconfig 程序可以识别这种格式的配置文件&#xff0c;并提取出有效信息…
阅读更多...
从力扣中等+困难题+表白HTML测试 -- 文心快码（Baidu Comate）

从力扣中等+困难题+表白HTML测试 -- 文心快码（Baidu Comate）

0 写在前面 &#xff08;通过如下链接/二维码进入官网注册&#xff0c;并在IDE使用三次及以上可以找我领计算机基础/ML/DL 面经/知识点一份~&#xff09; 官网地址&#xff1a;Baidu Comate Step1 打开文心快码&#xff08;Baidu Comate&#xff09;官网&#xff0c;点击「免…
阅读更多...
[Python可视化]空气污染物浓度地图可视化

[Python可视化]空气污染物浓度地图可视化

[Python可视化]空气污染物浓度地图可视化&#xff0c;果然是路边浓度最大 在本篇文章中&#xff0c;我将展示如何使用 Python 结合 OSMnx、NetworkX 和 GeoPandas 等库&#xff0c;计算给定路径的最短路线&#xff0c;并基于该路径穿过的网格单元计算总污染量。最终&#xff0c…
阅读更多...
k8s - Secret实践练习

k8s - Secret实践练习

参考文档&#xff1a;https://kubernetes.io/zh-cn/docs/concepts/configuration/secret/ 这个和ConfigMap很相似&#xff0c;这里选两个做下测试&#xff0c;就不过多赘述了 简介 Secret 类似于 ConfigMap 但专门用于保存机密数据。 Secret 是一种包含少量敏感信息例如密码…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023