def euclidean_Metric(N_x=np.zeros((1, 1)),N_y=np.zeros((1, 1))):
时间: 2023-04-01 21:02:19 浏览: 106
欧几里得距离公式是用来计算两个向量之间的距离的,其中 N_x 和 N_y 分别表示两个向量。具体的实现可以参考以下代码:
```python
import numpy as np
def euclidean_Metric(N_x=np.zeros((1, 1)), N_y=np.zeros((1, 1))):
"""
计算两个向量之间的欧几里得距离
:param N_x: 向量 x
:param N_y: 向量 y
:return: 两个向量之间的欧几里得距离
"""
return np.sqrt(np.sum(np.square(N_x - N_y)))
```
以上是我对于你的问题的回答,希望能够帮到你。
相关问题
代码改进:import numpy as np import pandas as pd import matplotlib as mpl import matplotlib.pyplot as plt from sklearn.datasets import make_blobs def distEclud(arrA,arrB): #欧氏距离 d = arrA - arrB dist = np.sum(np.power(d,2),axis=1) #差的平方的和 return dist def randCent(dataSet,k): #寻找质心 n = dataSet.shape[1] #列数 data_min = dataSet.min() data_max = dataSet.max() #生成k行n列处于data_min到data_max的质心 data_cent = np.random.uniform(data_min,data_max,(k,n)) return data_cent def kMeans(dataSet,k,distMeans = distEclud, createCent = randCent): x,y = make_blobs(centers=100)#生成k质心的数据 x = pd.DataFrame(x) m,n = dataSet.shape centroids = createCent(dataSet,k) #初始化质心,k即为初始化质心的总个数 clusterAssment = np.zeros((m,3)) #初始化容器 clusterAssment[:,0] = np.inf #第一列设置为无穷大 clusterAssment[:,1:3] = -1 #第二列放本次迭代点的簇编号,第三列存放上次迭代点的簇编号 result_set = pd.concat([pd.DataFrame(dataSet), pd.DataFrame(clusterAssment)],axis = 1,ignore_index = True) #将数据进行拼接,横向拼接,即将该容器放在数据集后面 clusterChanged = True while clusterChanged: clusterChanged = False for i in range(m): dist = distMeans(dataSet.iloc[i,:n].values,centroids) #计算点到质心的距离(即每个值到质心的差的平方和) result_set.iloc[i,n] = dist.min() #放入距离的最小值 result_set.iloc[i,n+1] = np.where(dist == dist.min())[0] #放入距离最小值的质心标号 clusterChanged = not (result_set.iloc[:,-1] == result_set.iloc[:,-2]).all() if clusterChanged: cent_df = result_set.groupby(n+1).mean() #按照当前迭代的数据集的分类,进行计算每一类中各个属性的平均值 centroids = cent_df.iloc[:,:n].values #当前质心 result_set.iloc[:,-1] = result_set.iloc[:,-2] #本次质心放到最后一列里 return centroids, result_set x = np.random.randint(0,100,size=100) y = np.random.randint(0,100,size=100) randintnum=pd.concat([pd.DataFrame(x), pd.DataFrame(y)],axis = 1,ignore_index = True) #randintnum_test, randintnum_test = kMeans(randintnum,3) #plt.scatter(randintnum_test.iloc[:,0],randintnum_test.iloc[:,1],c=randintnum_test.iloc[:,-1]) #result_test,cent_test = kMeans(data, 4) cent_test,result_test = kMeans(randintnum, 3) plt.scatter(result_test.iloc[:,0],result_test.iloc[:,1],c=result_test.iloc[:,-1]) plt.scatter(cent_test[:,0],cent_test[:,1],color = 'red',marker = 'x',s=100)
这段代码实现的是k-means聚类算法,但是有一些地方可以改进:
1. 函数kMeans中的createCent参数可以通过修改为直接传入质心的方式来更加灵活。
2. 函数kMeans中的distMeans参数可以修改为scipy库中的距离函数,如scipy.spatial.distance.cdist,来提高计算效率。
3. 函数kMeans中的clusterAssment可以使用pd.DataFrame来进行初始化,这样可以避免使用np.zeros和np.inf来进行初始化。
改进后的代码如下:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from scipy.spatial.distance import cdist
def randCent(dataSet, k):
"""
随机生成k个质心
"""
n = dataSet.shape[1] # 列数
data_min = dataSet.min()
data_max = dataSet.max()
# 生成k行n列处于data_min到data_max的质心
data_cent = np.random.uniform(data_min, data_max, (k, n))
return data_cent
def kMeans(dataSet, k, createCent=randCent, distMeans=cdist):
"""
k-means聚类算法
"""
centroids = createCent(dataSet, k) # 初始化质心,k即为初始化质心的总个数
result_set = pd.concat([pd.DataFrame(dataSet), pd.DataFrame()], axis=1, ignore_index=True)
# 将数据进行拼接,横向拼接,即将该容器放在数据集后面
clusterChanged = True
while clusterChanged:
clusterChanged = False
dist = distMeans(dataSet, centroids, metric='euclidean')
clusterAssment = np.argmin(dist, axis=1)
result_set.iloc[:, -1] = pd.Series(clusterAssment)
for i in range(k):
cent_df = result_set[result_set.iloc[:, -1] == i].mean() # 按照当前迭代的数据集的分类,进行计算每一类中各个属性的平均值
if not cent_df.empty:
centroids[i] = cent_df.iloc[:-1].values # 当前质心
clusterChanged = True
return centroids, result_set
x = np.random.randint(0, 100, size=100)
y = np.random.randint(0, 100, size=100)
randintnum = pd.concat([pd.DataFrame(x), pd.DataFrame(y)], axis=1, ignore_index=True)
cent_test, result_test = kMeans(randintnum, 3)
plt.scatter(result_test.iloc[:, 0], result_test.iloc[:, 1], c=result_test.iloc[:, -1])
plt.scatter(cent_test[:, 0], cent_test[:, 1], color='red', marker='x', s=100)
```
import pandas as pd import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.basemap import Basemap from scipy.spatial.distance import cdist from ant_colony import solve_tsp # 读取城市数据 df = pd.read_excel('world_coordinate.xlsx', index_col=0, dtype=str) # 提取城市和经纬度数据 countrys = df.index.values countrys_coords = np.array(df['[longitude, latitude]'].apply(eval).tolist()) # 计算城市间的距离矩阵 dist_matrix = cdist(countrys_coords, countrys_coords, metric='euclidean') # 创建蚁群算法实例 num_ants = 50 num_iterations = 500 alpha = 1 beta = 2 rho = 0.5 acs = solve_tsp(dist_matrix, num_ants=num_ants, num_iterations=num_iterations, alpha=alpha, beta=beta, rho=rho) # 输出访问完所有城市的最短路径的距离和城市序列 best_path = acs.get_best_path() best_distance = acs.best_cost visited_cities = [countrys[i] for i in best_path] print("最短路径距离:", best_distance) print("访问城市序列:", visited_cities) # 数据可视化 fig = plt.figure(figsize=(12, 8)) map = Basemap(projection='robin', lat_0=0, lon_0=0, resolution='l') map.drawcoastlines(color='gray') map.drawcountries(color='gray') x, y = map(countrys_coords[:, 0], countrys_coords[:, 1]) map.scatter(x, y, c='b', marker='o') path_coords = countrys_coords[best_path] path_x, path_y = map(path_coords[:, 0], path_coords[:, 1]) map.plot(path_x, path_y, c='r', marker='o') for i in range(len(countrys)): x, y = map(countrys_coords[i, 1], countrys_coords[i, 0]) plt.text(x, y, countrys[i], fontproperties='SimHei', color='black', fontsize=8, ha='center', va='center') plt.title("全球首都最短路径规划") plt.show()改成现在都有调用蚁群算法库的代码
好的,可以尝试使用蚁群算法库来计算最优路径。以下是修改后的代码:
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
from ant_colony import AntColonyOptimizer
# 读取城市数据
df = pd.read_excel('world_coordinate.xlsx', index_col=0, dtype=str)
# 提取城市和经纬度数据
countrys = df.index.values
countrys_coords = np.array(df['[longitude, latitude]'].apply(eval).tolist())
# 创建蚁群算法实例
num_ants = 50
num_iterations = 500
alpha = 1
beta = 2
rho = 0.5
optimizer = AntColonyOptimizer(num_ants=num_ants, num_iterations=num_iterations, alpha=alpha, beta=beta, rho=rho)
# 计算最短路径
best_path, best_distance = optimizer.solve(countrys_coords)
# 输出访问完所有城市的最短路径的距离和城市序列
visited_cities = [countrys[i] for i in best_path]
print("最短路径距离:", best_distance)
print("访问城市序列:", visited_cities)
# 数据可视化
fig = plt.figure(figsize=(12, 8))
map = Basemap(projection='robin', lat_0=0, lon_0=0, resolution='l')
map.drawcoastlines(color='gray')
map.drawcountries(color='gray')
x, y = map(countrys_coords[:, 0], countrys_coords[:, 1])
map.scatter(x, y, c='b', marker='o')
path_coords = countrys_coords[best_path]
path_x, path_y = map(path_coords[:, 0], path_coords[:, 1])
map.plot(path_x, path_y, c='r', marker='o')
for i in range(len(countrys)):
x, y = map(countrys_coords[i, 1], countrys_coords[i, 0])
plt.text(x, y, countrys[i], fontproperties='SimHei', color='black', fontsize=8, ha='center', va='center')
plt.title("全球首都最短路径规划")
plt.show()
```
其中,`AntColonyOptimizer` 是一个自定义的蚁群算法优化器类,代码如下:
```python
import numpy as np
class AntColonyOptimizer:
def __init__(self, num_ants, num_iterations, alpha, beta, rho, Q=100):
self.num_ants = num_ants
self.num_iterations = num_iterations
self.alpha = alpha
self.beta = beta
self.rho = rho
self.Q = Q
def solve(self, dist_matrix):
n = dist_matrix.shape[0]
# 初始化信息素矩阵
tau = np.ones((n, n))
# 创建蚂蚁
ants = np.zeros((self.num_ants, n), dtype=int)
# 记录最优路径和距离
best_path = None
best_distance = np.inf
# 迭代搜索
for iter in range(self.num_iterations):
# 初始化蚂蚁位置
ants[:, 0] = np.random.randint(0, n, size=self.num_ants)
# 蚂蚁移动
for k in range(1, n):
# 计算可选城市的概率
probs = np.zeros((self.num_ants, n))
for i in range(self.num_ants):
curr_city = ants[i, k-1]
visited = ants[i, :k]
unvisited = np.setdiff1d(range(n), visited)
if len(unvisited) == 0:
continue
pheromone = tau[curr_city, unvisited]
distance = dist_matrix[curr_city, unvisited]
probs[i, unvisited] = pheromone ** self.alpha * (1 / distance) ** self.beta
probs[i, visited] = 0
probs[i] /= probs[i].sum()
# 选择下一个城市
ants[:, k] = [np.random.choice(range(n), p=probs[i]) for i in range(self.num_ants)]
# 计算每只蚂蚁的路径长度
path_lengths = np.zeros(self.num_ants)
for i in range(self.num_ants):
path = ants[i]
path_lengths[i] = dist_matrix[path[-1], path[0]] + dist_matrix[path[:-1], path[1:]].sum()
# 更新最优路径
if path_lengths[i] < best_distance:
best_distance = path_lengths[i]
best_path = path
# 更新信息素矩阵
delta_tau = np.zeros((n, n))
for i in range(self.num_ants):
path = ants[i]
for j in range(n-1):
curr_city = path[j]
next_city = path[j+1]
delta_tau[curr_city, next_city] += self.Q / path_lengths[i]
delta_tau[path[-1], path[0]] += self.Q / path_lengths[i]
tau = (1 - self.rho) * tau + self.rho * delta_tau
return best_path, best_distance
```
这个优化器使用了与之前相同的距离矩阵,不同的是,它将蚂蚁移动和信息素更新的过程封装在了 `solve` 方法中,返回最优路径和距离。
阅读全文