明天写吧，受不了
先放这：
1、蚁群算法分析：
import pandas as pd
import numpy as np
import random
file_path = "berlin52.txt"
# 读取数据，使用空格作为分隔符，跳过前6行
data = pd.read_csv(file_path, sep=' ', header=None, skiprows=6, skipfooter=1, engine='python', names=["City", "X", "Y"])
data = data.dropna()
data = data.set_index('City')
print(data)
# 计算距离矩阵
def calculate_distance_matrix(data):
num_cities = len(data)
distance_matrix = np.zeros((num_cities, num_cities))
for i in range(num_cities):
for j in range(i, num_cities):
x1, y1 = data.iloc[i]["X"], data.iloc[i]["Y"]
x2, y2 = data.iloc[j]["X"], data.iloc[j]["Y"]
distance = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
distance_matrix[i][j] = distance
distance_matrix[j][i] = distance
return distance_matrix
distance_matrix = calculate_distance_matrix(data)
# 蚁群算法参数
num_ants = 5
num_iterations = 200
pheromone_evaporation = 0.1
pheromone_deposit = 1.0
# 初始化信息素矩阵
pheromones = np.ones((len(data), len(data)))
# 蚁群算法主循环
for iteration in range(num_iterations):
ant_tours = []
for ant in range(num_ants):
current_city = random.randint(0, len(data) - 1)
unvisited_cities = list(range(len(data)))
unvisited_cities.remove(current_city)
tour = [current_city]
while unvisited_cities:
probabilities = []
for city in unvisited_cities:
pheromone = pheromones[current_city][city]
distance = distance_matrix[current_city][city]
probability = pheromone**2 / distance
probabilities.append(probability)
probabilities = [p / sum(probabilities) for p in probabilities]
next_city = np.random.choice(unvisited_cities, p=probabilities)
tour.append(next_city)
unvisited_cities.remove(next_city)
current_city = next_city
ant_tours.append(tour)
# 计算每个蚂蚁的路径长度
tour_lengths = []
for tour in ant_tours:
length = sum(distance_matrix[tour[i]][tour[i+1]] for i in range(len(tour)-1))
tour_lengths.append(length)
# 更新信息素
for i in range(len(data)):
for j in range(len(data)):
pheromones[i][j] *= (1 - pheromone_evaporation)
for ant, tour in enumerate(ant_tours):
for i in range(len(tour)-1):
city1, city2 = tour[i], tour[i+1]
pheromones[city1][city2] += pheromone_deposit / tour_lengths[ant]
pheromones[city2][city1] += pheromone_deposit / tour_lengths[ant]
# 寻找最佳路径
best_tour = ant_tours[np.argmin(tour_lengths)]
best_distance = min(tour_lengths)
print("最佳路径:", best_tour)
print("最短距离:", best_distance)
from matplotlib.font_manager import FontProperties
from tkinter import font
plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置中文显示
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
import matplotlib.pyplot as plt
# 提取最佳路径的坐标
best_tour_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in best_tour]
# 提取所有城市的坐标
all_cities_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in range(len(data))]
# 绘制所有城市
plt.scatter(*zip(*all_cities_coordinates), marker='o', color='blue', label='Cities')
# 绘制最佳路径
tour_x, tour_y = zip(*best_tour_coordinates)
plt.plot(tour_x + (tour_x[0],), tour_y + (tour_y[0],), linestyle='-', color='red', label='Best Tour')
# 用索引注释每个城市
for city, (x, y) in enumerate(all_cities_coordinates):
plt.text(x, y, str(city), fontsize=8, ha='right')
# 设置标签和标题
plt.xlabel('X')
plt.ylabel('Y')
plt.title('蚁群算法 - 最佳路径可视化')
# 显示图例
plt.legend()
# 显示图表
plt.show()
2、遗传算法分析
import pandas as pd
import numpy as np
import random
import math
from scipy.optimize import minimize
from scipy.spatial.distance import cdist
# Read TSP file
data = pd.read_csv('berlin52.tsp', sep='\s+', skiprows=6, header=None, names=['X', 'Y'])
data = data.drop(data.index[-1])
# Extract x and y values
X = data['X'].values
Y = data['Y'].values
# Calculate distance matrix
dist_matrix = cdist(np.array([X, Y]).T, np.array([X, Y]).T)
# Genetic algorithm parameters
population_size = 100 # 种群大小
elite_size = 20 # 每代选择的父代数量
mutation_rate = 0.04 # 突变率
generations = 5000 # 迭代次数
def calculate_distance(coords, order):
total_distance = 0
for i in range(len(order)-1):
from_city = order[i]
to_city = order[i+1]
distance = dist_matrix[from_city, to_city]
total_distance += distance
return total_distance
def create_individual(order):
individual = order[:]
random.shuffle(individual)
return individual
def create_population(coords, size):
population = [create_individual(list(range(len(coords)))) for _ in range(size)]
return population
def rank_population(population, coords):
ranked_population = sorted(population, key=lambda x: calculate_distance(coords, x))
return ranked_population
def selection(population, elite_size):
return population[:elite_size]
def crossover(parent1, parent2):
start_index = random.randint(0, len(parent1)//2)
end_index = random.randint(start_index, len(parent1))
child = parent1[start_index:end_index]
child += [gene for gene in parent2 if gene not in child]
return child
def crossover_population(parents, elite_size):
pool = random.sample(parents, len(parents))
children = parents[:elite_size] + [crossover(pool[i], pool[len(parents)-i-1]) for i in range(len(parents)-elite_size)]
return children
def mutate(individual):
if random.random() < mutation_rate:
index1 = random.randint(0, len(individual)-1)
index2 = random.randint(0, len(individual)-1)
individual[index1], individual[index2] = individual[index2], individual[index1]
return individual
def mutate_population(population):
mutated_population = [mutate(individual) for individual in population]
return mutated_population
def local_search(coords, order):
best_order = order[:]
best_distance = calculate_distance(coords, best_order)
for i in range(len(best_order)-1):
for j in range(i+2, len(best_order)):
new_order = best_order[:i+1] + best_order[i+1:j][::-1] + best_order[j:]
new_distance = calculate_distance(coords, new_order)
if new_distance < best_distance:
best_order = new_order
best_distance = new_distance
return best_order
# Define city coordinates
city_coords = list(zip(X ,Y))
def genetic_algorithm(coords, population_size, elite_size, mutation_rate, generations):
population = create_population(coords, population_size)
for _ in range(generations):
population = rank_population(population, coords)
parents = selection(population, elite_size)
children = crossover_population(parents, elite_size)
population = mutate_population(children)
best_individual = rank_population(population, coords)[0]
best_individual = local_search(coords, best_individual)
best_distance = calculate_distance(coords, best_individual)
return best_individual, best_distance
best_tour, best_distance = genetic_algorithm(dist_matrix, population_size, elite_size, mutation_rate, generations)
print("Best distance:", best_distance)
print("Best path:", best_tour)
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from tkinter import font
plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置中文显示
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# 提取最佳路径的坐标
best_tour_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in best_tour]
# 提取所有城市的坐标
all_cities_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in range(len(data))]
# 绘制所有城市
plt.scatter(*zip(*all_cities_coordinates), marker='o', color='blue', label='Cities')
# 绘制最佳路径
tour_x, tour_y = zip(*best_tour_coordinates)
plt.plot(tour_x + (tour_x[0],), tour_y + (tour_y[0],), linestyle='-', color='red', label='Best Tour')
# 用索引注释每个城市
for city, (x, y) in enumerate(all_cities_coordinates):
plt.text(x, y, str(city), fontsize=8, ha='right')
# 设置标签和标题
plt.xlabel('X')
plt.ylabel('Y')
plt.title('遗传算法 - 最佳路径可视化')
# 显示图例
plt.legend()
# 显示图表
plt.show()
3、kroA100-21282.tsp蚁群和遗传算法实现
import pandas as pd
import numpy as np
import random
# 读取数据集
file_path = "data/kroA100-21282.tsp"
# 读取数据，使用空格作为分隔符，跳过前6行
data = pd.read_csv(file_path, sep=' ', header=None, skiprows=6, skipfooter=1, engine='python', names=["City", "X", "Y"])
data = data.dropna()
data = data.set_index('City')
import pandas as pd
import numpy as np
import random
# 计算距离矩阵
def calculate_distance_matrix(data):
num_cities = len(data)
distance_matrix = np.zeros((num_cities, num_cities))
for i in range(num_cities):
for j in range(i, num_cities):
x1, y1 = data.iloc[i]["X"], data.iloc[i]["Y"]
x2, y2 = data.iloc[j]["X"], data.iloc[j]["Y"]
distance = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
distance_matrix[i][j] = distance
distance_matrix[j][i] = distance
return distance_matrix
distance_matrix = calculate_distance_matrix(data)
# 蚁群算法参数
num_ants = 5
num_iterations = 200
pheromone_evaporation = 0.1
pheromone_deposit = 1.0
# 初始化信息素矩阵
pheromones = np.ones((len(data), len(data)))
# 蚁群算法主循环
for iteration in range(num_iterations):
ant_tours = []
for ant in range(num_ants):
current_city = random.randint(0, len(data) - 1)
unvisited_cities = list(range(len(data)))
unvisited_cities.remove(current_city)
tour = [current_city]
while unvisited_cities:
probabilities = []
for city in unvisited_cities:
pheromone = pheromones[current_city][city]
distance = distance_matrix[current_city][city]
probability = pheromone**2 / distance
probabilities.append(probability)
probabilities = [p / sum(probabilities) for p in probabilities]
next_city = np.random.choice(unvisited_cities, p=probabilities)
tour.append(next_city)
unvisited_cities.remove(next_city)
current_city = next_city
ant_tours.append(tour)
# 计算每个蚂蚁的路径长度
tour_lengths = []
for tour in ant_tours:
length = sum(distance_matrix[tour[i]][tour[i+1]] for i in range(len(tour)-1))
tour_lengths.append(length)
# 更新信息素
for i in range(len(data)):
for j in range(len(data)):
pheromones[i][j] *= (1 - pheromone_evaporation)
for ant, tour in enumerate(ant_tours):
for i in range(len(tour)-1):
city1, city2 = tour[i], tour[i+1]
pheromones[city1][city2] += pheromone_deposit / tour_lengths[ant]
pheromones[city2][city1] += pheromone_deposit / tour_lengths[ant]
# 寻找最佳路径
best_tour = ant_tours[np.argmin(tour_lengths)]
best_distance = min(tour_lengths)
print("最佳路径:", best_tour)
print("最短距离:", best_distance)
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from tkinter import font
plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置中文显示
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# 提取最佳路径的坐标
best_tour_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in best_tour]
# 提取所有城市的坐标
all_cities_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in range(len(data))]
# 绘制所有城市
plt.scatter(*zip(*all_cities_coordinates), marker='o', color='blue', label='Cities')
# 绘制最佳路径
tour_x, tour_y = zip(*best_tour_coordinates)
plt.plot(tour_x + (tour_x[0],), tour_y + (tour_y[0],), linestyle='-', color='red', label='Best Tour')
# 用索引注释每个城市
for city, (x, y) in enumerate(all_cities_coordinates):
plt.text(x, y, str(city), fontsize=8, ha='right')
# 设置标签和标题
plt.xlabel('X')
plt.ylabel('Y')
plt.title('蚁群算法 - 最佳路径可视化')
# 显示图例
plt.legend()
# 显示图表
plt.show()
import pandas as pd
import numpy as np
# 读取数据集
file_path = "data/kroA100-21282.tsp"
# 读取数据，使用空格作为分隔符，跳过前6行
data = pd.read_csv(file_path, sep=' ', header=None, skiprows=6, skipfooter=1, engine='python', names=["City", "X", "Y"])
data = data.dropna()
data = data.set_index('City')
# 获取坐标数据
coords = list(zip(data['X'], data['Y']))
num_cities = len(data)
def euclidean_distance(city1, city2):
return np.sqrt((city1[0] - city2[0])**2 + (city1[1] - city2[1])**2)
def total_distance(tour, coords):
return sum(euclidean_distance(coords[tour[i]], coords[tour[i+1]]) for i in range(len(tour)-1))
def initialize_population(num_individuals, num_cities):
return [np.random.permutation(num_cities) for _ in range(num_individuals)]
def genetic_algorithm(coords, num_generations, population_size):
num_cities = len(coords)
population = initialize_population(population_size, num_cities)
for generation in range(num_generations):
# Evaluate fitness
fitness = [1 / total_distance(tour, coords) if total_distance(tour, coords) > 0 else 1e-10 for tour in population]
# Selection
selected_indices = np.argsort(fitness)[-population_size//2*2:]
# Crossover
new_population = [population[i] for i in selected_indices]
for i in range(0, population_size, 2):
parent1, parent2 = population[selected_indices[i]], population[selected_indices[i+1]]
crossover_point = np.random.randint(1, num_cities-1)
child1 = np.concatenate((parent1[:crossover_point], [c for c in parent2 if c not in parent1[:crossover_point]]))
child2 = np.concatenate((parent2[:crossover_point], [c for c in parent1 if c not in parent2[:crossover_point]]))
new_population.extend([child1, child2])
# Mutation
mutation_rate = 0.02
for i in range(population_size):
if np.random.rand() < mutation_rate:
mutation_point1, mutation_point2 = np.random.choice(num_cities, size=2, replace=False)
new_population[i][mutation_point1], new_population[i][mutation_point2] = (
new_population[i][mutation_point2], new_population[i][mutation_point1])
# Update population
population = new_population
# Find the best tour
best_tour_index = np.argmax([total_distance(tour, coords) for tour in population])
best_tour = population[best_tour_index]
best_distance = total_distance(best_tour, coords)
return best_tour, best_distance
# Example usage
num_generations = 5000
population_size = 200
best_tour, best_distance = genetic_algorithm(coords, num_generations, population_size)
print("Best Tour:", best_tour)
print("Best Distance:", best_distance)
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
from tkinter import font
plt.rcParams['font.sans-serif'] = ['SimHei'] # 设置中文显示
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# 提取最佳路径的坐标
best_tour_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in best_tour]
# 提取所有城市的坐标
all_cities_coordinates = [(data.iloc[city]["X"], data.iloc[city]["Y"]) for city in range(len(data))]
# 绘制所有城市
plt.scatter(*zip(*all_cities_coordinates), marker='o', color='blue', label='Cities')
# 绘制最佳路径
tour_x, tour_y = zip(*best_tour_coordinates)
plt.plot(tour_x + (tour_x[0],), tour_y + (tour_y[0],), linestyle='-', color='red', label='Best Tour')
# 用索引注释每个城市
for city, (x, y) in enumerate(all_cities_coordinates):
plt.text(x, y, str(city), fontsize=8, ha='right')
# 设置标签和标题
plt.xlabel('X')
plt.ylabel('Y')
plt.title('遗传算法 - 最佳路径可视化')
# 显示图例
plt.legend()
# 显示图表
plt.show()
看着工作量有点小大啊！干吧！去值班了
3262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
