Algoritma Perisikan Swarm: Tiga Pelaksanaan Python

Bayangkan menonton kawanan burung dalam penerbangan. Tidak ada pemimpin, tiada siapa yang memberi arahan, namun mereka meluncur dan meluncur bersama dalam keharmonian yang sempurna. Ia mungkin kelihatan seperti kekacauan, tetapi ada perintah tersembunyi. Anda dapat melihat corak yang sama di sekolah -sekolah ikan yang mengelakkan pemangsa atau semut mencari jalan terpendek untuk makanan. Makhluk -makhluk ini bergantung pada peraturan mudah dan komunikasi tempatan untuk menangani tugas -tugas yang mengejutkan tanpa kawalan pusat.

Itulah keajaiban kecerdasan kawanan. 

kita boleh meniru tingkah laku ini menggunakan algoritma yang menyelesaikan masalah yang sukar dengan meniru kecerdasan kawanan.

Pengoptimuman Swarm Partikel (PSO)

Pengoptimuman Swarm Partikel (PSO) menarik inspirasi dari tingkah laku kawanan burung dan sekolah ikan. Dalam sistem semulajadi ini, individu bergerak berdasarkan pengalaman mereka sendiri dan kedudukan jiran mereka, secara beransur -ansur menyesuaikan diri untuk mengikuti ahli kumpulan yang paling berjaya. PSO menggunakan konsep ini untuk masalah pengoptimuman, di mana zarah, dipanggil ejen, bergerak melalui ruang carian untuk mencari penyelesaian yang optimum.

Berbanding dengan ACO, PSO beroperasi di ruang yang berterusan dan bukan diskret. Di ACO, tumpuannya adalah pada pilihan jalan dan diskret, sementara PSO lebih sesuai untuk masalah yang melibatkan pembolehubah berterusan, seperti penalaan parameter. 

Di PSO, zarah meneroka ruang carian. Mereka menyesuaikan kedudukan mereka berdasarkan dua faktor utama: kedudukan peribadi mereka yang terkenal dan kedudukan paling terkenal dari seluruh kawanan. Mekanisme maklum balas dua ini membolehkan mereka berkumpul ke arah optimum global.

bagaimana pengoptimuman swarm zarah berfungsi

Proses bermula dengan sekumpulan zarah yang dimulakan secara rawak di seluruh ruang penyelesaian. Setiap zarah mewakili penyelesaian yang mungkin untuk masalah pengoptimuman. Apabila zarah bergerak, mereka mengingati kedudukan terbaik mereka (penyelesaian terbaik yang mereka hadapi setakat ini) dan tertarik ke arah kedudukan terbaik global (penyelesaian terbaik mana -mana zarah telah dijumpai).

Pergerakan ini didorong oleh dua faktor: eksploitasi dan penerokaan. Eksploitasi melibatkan penapisan pencarian di sekitar penyelesaian terbaik semasa, sementara penerokaan menggalakkan zarah untuk mencari bahagian lain dari ruang penyelesaian untuk mengelakkan terjebak dalam optima tempatan. Dengan mengimbangi kedua -dua dinamik ini, PSO cekap menumpukan pada penyelesaian terbaik.

Pelaksanaan Python Pengoptimuman Partikel

Dalam pengurusan portfolio kewangan, mencari cara terbaik untuk memperuntukkan aset untuk mendapatkan pulangan yang paling banyak sambil mengekalkan risiko yang rendah boleh menjadi rumit. Mari kita gunakan PSO untuk mencari campuran aset mana yang akan memberi kita pulangan tertinggi ke atas pelaburan.

Kod di bawah menunjukkan bagaimana PSO berfungsi untuk mengoptimumkan portfolio kewangan fiksyen. Ia bermula dengan peruntukan aset rawak, kemudian tweak mereka atas beberapa lelaran berdasarkan apa yang paling baik, secara beransur -ansur mencari campuran aset optimum untuk pulangan tertinggi dengan risiko terendah.

import numpy as np
import matplotlib.pyplot as plt

# Define the PSO parameters
class Particle:
    def __init__(self, n_assets):
        # Initialize a particle with random weights and velocities
        self.position = np.random.rand(n_assets)
        self.position /= np.sum(self.position)  # Normalize weights so they sum to 1
        self.velocity = np.random.rand(n_assets)
        self.best_position = np.copy(self.position)
        self.best_score = float('inf')  # Start with a very high score

def objective_function(weights, returns, covariance):
    """
    Calculate the portfolio's performance.
    - weights: Asset weights in the portfolio.
    - returns: Expected returns of the assets.
    - covariance: Covariance matrix representing risk.
    """
    portfolio_return = np.dot(weights, returns)  # Calculate the portfolio return
    portfolio_risk = np.sqrt(np.dot(weights.T, np.dot(covariance, weights)))  # Calculate portfolio risk (standard deviation)
    return -portfolio_return / portfolio_risk  # We want to maximize return and minimize risk

def update_particles(particles, global_best_position, returns, covariance, w, c1, c2):
    """
    Update the position and velocity of each particle.
    - particles: List of particle objects.
    - global_best_position: Best position found by all particles.
    - returns: Expected returns of the assets.
    - covariance: Covariance matrix representing risk.
    - w: Inertia weight to control particle's previous velocity effect.
    - c1: Cognitive coefficient to pull particles towards their own best position.
    - c2: Social coefficient to pull particles towards the global best position.
    """
    for particle in particles:
        # Random coefficients for velocity update
        r1, r2 = np.random.rand(len(particle.position)), np.random.rand(len(particle.position))
        # Update velocity
        particle.velocity = (w * particle.velocity +
                             c1 * r1 * (particle.best_position - particle.position) +
                             c2 * r2 * (global_best_position - particle.position))
        # Update position
        particle.position += particle.velocity
        particle.position = np.clip(particle.position, 0, 1)  # Ensure weights are between 0 and 1
        particle.position /= np.sum(particle.position)  # Normalize weights to sum to 1
        # Evaluate the new position
        score = objective_function(particle.position, returns, covariance)
        if score < particle.best_score:
            # Update the particle's best known position and score
            particle.best_position = np.copy(particle.position)
            particle.best_score = score

def pso_portfolio_optimization(n_particles, n_iterations, returns, covariance):
    """
    Perform Particle Swarm Optimization to find the optimal asset weights.
    - n_particles: Number of particles in the swarm.
    - n_iterations: Number of iterations for the optimization.
    - returns: Expected returns of the assets.
    - covariance: Covariance matrix representing risk.
    """
    # Initialize particles
    particles = [Particle(len(returns)) for _ in range(n_particles)]
    # Initialize global best position
    global_best_position = np.random.rand(len(returns))
    global_best_position /= np.sum(global_best_position)
    global_best_score = float('inf')
    
    # PSO parameters
    w = 0.5  # Inertia weight: how much particles are influenced by their own direction
    c1 = 1.5  # Cognitive coefficient: how well particles learn from their own best solutions
    c2 = 0.5  # Social coefficient: how well particles learn from global best solutions
    history = []  # To store the best score at each iteration
    
    for _ in range(n_iterations):
        update_particles(particles, global_best_position, returns, covariance, w, c1, c2)
        for particle in particles:
            score = objective_function(particle.position, returns, covariance)
            if score < global_best_score:
                # Update the global best position and score
                global_best_position = np.copy(particle.position)
                global_best_score = score
        # Store the best score (negative return/risk ratio) for plotting
        history.append(-global_best_score)
    
    return global_best_position, history

# Example data for 3 assets
returns = np.array([0.02, 0.28, 0.15])  # Expected returns for each asset
covariance = np.array([[0.1, 0.02, 0.03],  # Covariance matrix for asset risks
                       [0.02, 0.08, 0.04],
                       [0.03, 0.04, 0.07]])

# Run the PSO algorithm
n_particles = 10  # Number of particles
n_iterations = 10  # Number of iterations
best_weights, optimization_history = pso_portfolio_optimization(n_particles, n_iterations, returns, covariance)

# Plotting the optimization process
plt.figure(figsize=(12, 6))
plt.plot(optimization_history, marker='o')
plt.title('Portfolio Optimization Using PSO')
plt.xlabel('Iteration')
plt.ylabel('Objective Function Value (Negative of Return/Risk Ratio)')
plt.grid(False)  # Turn off gridlines
plt.show()

# Display the optimal asset weights
print(f"Optimal Asset Weights: {best_weights}")

Graf ini menunjukkan berapa algoritma PSO meningkatkan campuran aset portfolio dengan setiap lelaran.

Aplikasi Pengoptimuman Swarm Zarah

PSO digunakan untuk kesederhanaan dan keberkesanannya dalam menyelesaikan pelbagai masalah pengoptimuman, terutamanya dalam domain berterusan. Fleksibiliti menjadikannya berguna untuk banyak senario dunia nyata di mana penyelesaian yang tepat diperlukan.

Aplikasi ini termasuk:

Pembelajaran Mesin: PSO boleh digunakan untuk menyesuaikan hiperparameter dalam algoritma pembelajaran mesin, membantu mencari konfigurasi model terbaik.
Reka bentuk kejuruteraan: PSO berguna untuk mengoptimumkan parameter reka bentuk untuk sistem seperti komponen aeroangkasa atau litar elektrik.
Pemodelan Kewangan: Dalam Kewangan, PSO boleh membantu dalam pengoptimuman portfolio, meminimumkan risiko semasa memaksimumkan pulangan.

keupayaan PSO untuk meneroka ruang penyelesaian dengan cekap menjadikannya terpakai di seluruh bidang, dari robotik ke pengurusan tenaga ke logistik.

Colony Bee Buatan (ABC)

algoritma Bee Colony (ABC) buatan dimodelkan pada tingkah laku makan madu.

Secara semula jadi, lebah madu dengan cekap mencari sumber nektar dan berkongsi maklumat ini dengan ahli -ahli Hive yang lain. ABC menangkap proses carian kolaboratif ini dan menggunakannya untuk masalah pengoptimuman, terutama yang melibatkan ruang yang kompleks, tinggi dimensi.

Apa yang membezakan ABC selain daripada algoritma kecerdasan kawanan lain adalah keupayaannya untuk mengimbangi eksploitasi, memberi tumpuan kepada penyelesaian penapisan semasa, dan penerokaan, mencari penyelesaian baru dan berpotensi lebih baik. Ini menjadikan ABC sangat berguna untuk masalah berskala besar di mana pengoptimuman global adalah kunci.

bagaimana koloni lebah buatan berfungsi

Dalam algoritma ABC, kawanan lebah dibahagikan kepada tiga peranan khusus: lebah yang digunakan, penonton, dan pengakap. Setiap peranan ini meniru aspek yang berbeza tentang bagaimana lebah mencari dan mengeksploitasi sumber makanan dalam alam semula jadi.

• Lebah yang digunakan: Lebah ini bertanggungjawab untuk meneroka sumber makanan yang diketahui, yang mewakili penyelesaian semasa dalam masalah pengoptimuman. Mereka menilai kualiti (kecergasan) sumber -sumber ini dan berkongsi maklumat dengan seluruh sarang.
• Lebah lebah: Setelah mengumpulkan maklumat dari lebah yang bekerja, penonton memilih sumber makanan mana yang hendak diterokai. Mereka mendasarkan pilihan mereka mengenai kualiti penyelesaian yang dikongsi oleh lebah yang bekerja, lebih memberi tumpuan kepada pilihan yang lebih baik, dengan itu menyempurnakan pencarian penyelesaian yang optimum.
• Bees Scout: Apabila sumber makanan lebah yang digunakan (penyelesaian) menjadi letih atau tidak stabil (apabila tiada penambahbaikan ditemui selepas beberapa lelaran tertentu), lebah menjadi pengakap. Pengakap meneroka kawasan baru ruang penyelesaian, mencari sumber makanan yang tidak diterokai, dengan itu menyuntik kepelbagaian ke dalam proses carian.

Dinamik ini membolehkan ABC mengimbangi pencarian antara secara intensif meneroka kawasan yang menjanjikan dan secara meluas meneroka kawasan baru ruang carian. Ini membantu algoritma mengelakkan terperangkap dalam optima tempatan dan meningkatkan peluangnya untuk mencari optimum global.

Pelaksanaan Python Bee Colony Bee Buatan

Fungsi Rastrigin adalah masalah yang popular dalam pengoptimuman, yang terkenal dengan banyak minima tempatan, menjadikannya cabaran yang sukar untuk banyak algoritma. Matlamatnya adalah mudah: cari minimum global.

Dalam contoh ini, kami akan menggunakan algoritma Bee Colony Buatan untuk menangani masalah ini. Setiap lebah dalam algoritma ABC meneroka ruang carian, mencari penyelesaian yang lebih baik untuk meminimumkan fungsi. Kod ini meniru lebah yang meneroka, mengeksploitasi, dan pengakap untuk kawasan baru, memastikan keseimbangan antara penerokaan dan eksploitasi.

import numpy as np
import matplotlib.pyplot as plt

# Define the PSO parameters
class Particle:
    def __init__(self, n_assets):
        # Initialize a particle with random weights and velocities
        self.position = np.random.rand(n_assets)
        self.position /= np.sum(self.position)  # Normalize weights so they sum to 1
        self.velocity = np.random.rand(n_assets)
        self.best_position = np.copy(self.position)
        self.best_score = float('inf')  # Start with a very high score

def objective_function(weights, returns, covariance):
    """
    Calculate the portfolio's performance.
    - weights: Asset weights in the portfolio.
    - returns: Expected returns of the assets.
    - covariance: Covariance matrix representing risk.
    """
    portfolio_return = np.dot(weights, returns)  # Calculate the portfolio return
    portfolio_risk = np.sqrt(np.dot(weights.T, np.dot(covariance, weights)))  # Calculate portfolio risk (standard deviation)
    return -portfolio_return / portfolio_risk  # We want to maximize return and minimize risk

def update_particles(particles, global_best_position, returns, covariance, w, c1, c2):
    """
    Update the position and velocity of each particle.
    - particles: List of particle objects.
    - global_best_position: Best position found by all particles.
    - returns: Expected returns of the assets.
    - covariance: Covariance matrix representing risk.
    - w: Inertia weight to control particle's previous velocity effect.
    - c1: Cognitive coefficient to pull particles towards their own best position.
    - c2: Social coefficient to pull particles towards the global best position.
    """
    for particle in particles:
        # Random coefficients for velocity update
        r1, r2 = np.random.rand(len(particle.position)), np.random.rand(len(particle.position))
        # Update velocity
        particle.velocity = (w * particle.velocity +
                             c1 * r1 * (particle.best_position - particle.position) +
                             c2 * r2 * (global_best_position - particle.position))
        # Update position
        particle.position += particle.velocity
        particle.position = np.clip(particle.position, 0, 1)  # Ensure weights are between 0 and 1
        particle.position /= np.sum(particle.position)  # Normalize weights to sum to 1
        # Evaluate the new position
        score = objective_function(particle.position, returns, covariance)
        if score < particle.best_score:
            # Update the particle's best known position and score
            particle.best_position = np.copy(particle.position)
            particle.best_score = score

def pso_portfolio_optimization(n_particles, n_iterations, returns, covariance):
    """
    Perform Particle Swarm Optimization to find the optimal asset weights.
    - n_particles: Number of particles in the swarm.
    - n_iterations: Number of iterations for the optimization.
    - returns: Expected returns of the assets.
    - covariance: Covariance matrix representing risk.
    """
    # Initialize particles
    particles = [Particle(len(returns)) for _ in range(n_particles)]
    # Initialize global best position
    global_best_position = np.random.rand(len(returns))
    global_best_position /= np.sum(global_best_position)
    global_best_score = float('inf')
    
    # PSO parameters
    w = 0.5  # Inertia weight: how much particles are influenced by their own direction
    c1 = 1.5  # Cognitive coefficient: how well particles learn from their own best solutions
    c2 = 0.5  # Social coefficient: how well particles learn from global best solutions
    history = []  # To store the best score at each iteration
    
    for _ in range(n_iterations):
        update_particles(particles, global_best_position, returns, covariance, w, c1, c2)
        for particle in particles:
            score = objective_function(particle.position, returns, covariance)
            if score < global_best_score:
                # Update the global best position and score
                global_best_position = np.copy(particle.position)
                global_best_score = score
        # Store the best score (negative return/risk ratio) for plotting
        history.append(-global_best_score)
    
    return global_best_position, history

# Example data for 3 assets
returns = np.array([0.02, 0.28, 0.15])  # Expected returns for each asset
covariance = np.array([[0.1, 0.02, 0.03],  # Covariance matrix for asset risks
                       [0.02, 0.08, 0.04],
                       [0.03, 0.04, 0.07]])

# Run the PSO algorithm
n_particles = 10  # Number of particles
n_iterations = 10  # Number of iterations
best_weights, optimization_history = pso_portfolio_optimization(n_particles, n_iterations, returns, covariance)

# Plotting the optimization process
plt.figure(figsize=(12, 6))
plt.plot(optimization_history, marker='o')
plt.title('Portfolio Optimization Using PSO')
plt.xlabel('Iteration')
plt.ylabel('Objective Function Value (Negative of Return/Risk Ratio)')
plt.grid(False)  # Turn off gridlines
plt.show()

# Display the optimal asset weights
print(f"Optimal Asset Weights: {best_weights}")

Graf ini menunjukkan kecergasan penyelesaian terbaik yang terdapat oleh algoritma ABC dengan setiap lelaran. Dalam jangka masa ini, ia mencapai kecergasan optimum sekitar lelaran ke -64.

Di sini anda dapat melihat fungsi Rastrigin yang diplot pada plot kontur, dengan banyak minima tempatan. Titik merah adalah minima global yang ditemui oleh algoritma ABC yang kami lari.

Aplikasi Colony Bee Buatan

Algoritma ABC adalah alat yang mantap untuk menyelesaikan masalah pengoptimuman. Keupayaannya untuk meneroka ruang carian yang besar dan kompleks menjadikannya pilihan untuk industri di mana kebolehsuaian dan skalabiliti adalah kritikal.

Aplikasi ini termasuk:

• Telekomunikasi: ABC boleh digunakan untuk mengoptimumkan penempatan sumber dan antena rangkaian, memaksimumkan liputan dan kekuatan isyarat sambil meminimumkan kos.
• Kejuruteraan: ABC boleh menyesuaikan parameter dalam pengoptimuman reka bentuk struktur.
• Sains Data: ABC boleh digunakan untuk pemilihan ciri, untuk mengenal pasti pembolehubah yang paling penting dalam dataset untuk pembelajaran mesin.

ABC adalah algoritma yang fleksibel yang sesuai untuk sebarang masalah di mana penyelesaian optimum perlu ditemui dalam persekitaran yang dinamik, tinggi dimensi. Sifatnya yang terdesentralisasi menjadikannya sesuai untuk situasi di mana algoritma lain mungkin berjuang untuk mengimbangi penerokaan dan eksploitasi dengan cekap.

Membandingkan Algoritma Perisikan Swarm

Terdapat pelbagai algoritma kecerdasan kawanan, masing -masing dengan atribut yang berbeza. Apabila memutuskan yang hendak digunakan, penting untuk menimbang kekuatan dan kelemahan mereka untuk menentukan yang paling sesuai dengan keperluan anda.

ACO berkesan untuk masalah kombinatorial seperti penghalaan dan penjadualan tetapi mungkin memerlukan sumber pengiraan yang signifikan. PSO lebih mudah dan cemerlang dalam pengoptimuman berterusan, seperti penalaan hiperparameter, tetapi boleh berjuang dengan optima tempatan. ABC berjaya mengimbangi penjelajahan dan eksploitasi, walaupun memerlukan penalaan yang berhati -hati.

Algoritma Perisikan Swarm Lain, seperti Algoritma Firefly dan Pengoptimuman Cari Cuckoo, juga menawarkan kelebihan yang unik untuk jenis masalah pengoptimuman tertentu.

3

Algoritma Kekuatan pengoptimuman koloni ant (ACO) berkesan untuk masalah kombinatorial dan mengendalikan ruang diskret yang kompleks dengan baik Pengoptimuman Swarm Partikel (PSO) baik untuk pengoptimuman berterusan dan mudah dan mudah dilaksanakan Colony Bee Buatan (ABC) disesuaikan dengan masalah besar, dinamik dan eksplorasi dan eksploitasi seimbang Algoritma Firefly (FA) cso Penjadualan, Pemilihan Ciri, dan Aplikasi Kejuruteraan

Cabaran dan batasan

algoritma kecerdasan kawanan, seperti banyak teknik pembelajaran mesin, menghadapi cabaran yang dapat mempengaruhi prestasi mereka. Ini termasuk:

1. Konvergensi Pramatang: Swarm boleh menyelesaikan penyelesaian suboptimal terlalu cepat.
2. Penalaan parameter: Mencapai hasil yang optimum sering memerlukan pelarasan tetapan algoritma yang teliti.
3. Sumber Komputasi & Skalabiliti: Algoritma ini boleh dikira secara intensif, terutamanya dengan masalah yang lebih besar dan lebih kompleks, dan prestasi mereka mungkin merendahkan sebagai peningkatan kerumitan masalah.
4. sifat stokastik: Rawak yang wujud dalam algoritma ini boleh membawa kepada kebolehubahan dalam hasil.

Penyelidikan dan Kemajuan terkini

Trend yang ketara ialah integrasi kecerdasan kawanan dengan teknik pembelajaran mesin lain. Penyelidik sedang meneroka bagaimana algoritma swarm dapat meningkatkan tugas seperti pemilihan ciri dan pengoptimuman hiperparameter. Semak algoritma pengoptimuman swarm zarah hibrid untuk menyelesaikan masalah kejuruteraan.

Kemajuan baru -baru ini juga memberi tumpuan kepada menangani beberapa cabaran tradisional yang berkaitan dengan kecerdasan kawanan, seperti penumpuan pramatang. Algoritma dan teknik baru sedang dibangunkan untuk mengurangkan risiko menumpu pada penyelesaian suboptimal. Untuk maklumat lanjut, lihat pendekatan berasaskan memori untuk menghapuskan penumpuan pramatang dalam pengoptimuman swarm zarah

Skalabiliti adalah satu lagi bidang penyelidikan yang penting. Oleh kerana masalah menjadi semakin kompleks dan jumlah data berkembang, para penyelidik sedang berusaha untuk membuat algoritma kecerdasan kawanan lebih berskala dan cekap. Ini termasuk membangunkan algoritma yang boleh mengendalikan dataset besar dan ruang dimensi tinggi dengan lebih berkesan, sambil mengoptimumkan sumber pengiraan untuk mengurangkan masa dan kos yang berkaitan dengan menjalankan algoritma ini. Untuk lebih lanjut mengenai ini, periksa perkembangan terkini dalam teori dan kebolehgunaan carian swarm.

algoritma swarm sedang digunakan untuk masalah dari robotik, kepada model bahasa yang besar (LLM), kepada diagnosis perubatan. Terdapat penyelidikan yang berterusan mengenai sama ada algoritma ini boleh berguna untuk membantu LLM secara strategik melupakan maklumat untuk mematuhi hak untuk dilupakan peraturan. Dan, tentu saja, algoritma kawanan mempunyai banyak aplikasi dalam sains data.

Kesimpulan

Kecerdasan Swarm menawarkan penyelesaian yang kuat untuk masalah pengoptimuman di pelbagai industri. Prinsip -prinsip desentralisasi, maklum balas positif, dan penyesuaian membolehkannya menangani tugas -tugas yang kompleks dan dinamik yang algoritma tradisional mungkin berjuang. 

Semak kajian ini mengenai algoritma swarm semasa, "Kecerdasan Swarm: Kajian Klasifikasi dan Aplikasi Model".

Untuk menyelam lebih mendalam ke dalam aplikasi perniagaan AI, periksa strategi kecerdasan buatan (AI) atau kecerdasan buatan untuk pemimpin perniagaan. Untuk mengetahui tentang algoritma lain yang meniru alam semula jadi, lihat Algoritma Genetik: Panduan Lengkap dengan Pelaksanaan Python.

Kelemahan	perpustakaan pilihan	Aplikasi Terbaik
komputasi intensif dan memerlukan penalaan halus	pyaco	Masalah penghalaan, penjadualan, dan peruntukan sumber
boleh menumpu ke optima tempatan dan kurang berkesan untuk masalah diskret	pyswarms	penalaan hyperparameter, reka bentuk kejuruteraan, pemodelan kewangan
komputasi intensif dan memerlukan penalaan parameter yang teliti	beecolpy	telekomunikasi, pengoptimuman berskala besar, dan ruang dimensi tinggi			cemerlang dalam pengoptimuman multimodal dan mempunyai keupayaan carian global yang kuat	sensitif terhadap tetapan parameter dan penumpuan yang lebih perlahan	fireflyalgorithm	pemprosesan imej, reka bentuk kejuruteraan, dan pengoptimuman multimodal
cuckoo carian (CS)	cekap untuk menyelesaikan masalah pengoptimuman dan mempunyai keupayaan penerokaan yang kuat	boleh berkumpul secara awal dan prestasi bergantung pada penalaan

Atas ialah kandungan terperinci Algoritma Perisikan Swarm: Tiga Pelaksanaan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!