def solve(self, iterations, killing_rate=0.8): for i in range(iterations): if not i % 100: print('\t> Iteration {}/{}'.format(i, iterations)) city = self.__cities.sample(1)[['x', 'y']].values winner_idx = self.__reduction(self.__population, city) self.__mutation(city, winner_idx, killing_rate) killing_rate *= 0.99997 if not i % 1000: plot_population(self.__cities, self.__population, name='diagrams/{:05d}.png'.format(i)) # Проверка на корректность координат в TSP карте if self.__population_size < 1: print('Radius has completely decayed, finishing execution at {} iterations'.format(i)) break if killing_rate < 0.001: print('Killing rate has completely decayed, finishing execution at {} iterations'.format(i)) break else: print('Completed {} iterations.'.format(iterations)) route = self.__get_route(self.__cities, self.__population) plot_population(self.__cities, self.__population, name='diagrams/final.png') plot_route(self.__cities, route, 'diagrams/route.png') return route
def som(problem, iterations, learning_rate=0.8): """Solve the TSP using a Self-Organizing Map.""" # Obtain the normalized set of cities (w/ coord in [0,1]) cities = problem.copy() cities[['x', 'y']] = normalize(cities[['x', 'y']]) # 归一化 # The population size is 8 times the number of cities 神经元个数 n = cities.shape[0] * 3 #n = cities.shape[0] * 3 # 测试用,by EE526 # Generate an adequate network of neurons: network = generate_network(cities, n, c=4) print('Network of {} neurons created. Starting the iterations:'.format(n)) for i in range(iterations): # Check for plotting interval if i % 100 == 0: # 每隔100次画出神经元图像 plot_network(cities, network, name='out_files\process\city_network%d.png' % (i // 100)) if not i % 100: # if i%100==0 print('\t> Iteration {}/{}'.format(i, iterations), end="\r") # Choose a random city city = cities.sample(1)[['x', 'y']].values # 随机从cities中选取一组数,1*2数组 winner_idx = select_closest(network, city) # Generate a filter that applies changes to the winner's gaussian gaussian = get_neighborhood(winner_idx, n // 10, network.shape[0]) # 高斯核函数是算法的核心 # Update the network's weights (closer to the city) network += gaussian[:, np.newaxis] * learning_rate * ( city - network) # np.newaxis在该位置增加一维,变成神经元数*1维 # 实际上就是为了让对应的移动乘以对应的坐标 # Decay the variables learning_rate = learning_rate * 0.99997 n = n * 0.9994 # Check if any parameter has completely decayed. if n < 1: print('Radius has completely decayed, finishing execution', 'at {} iterations'.format(i)) break if learning_rate < 0.001: print('Learning rate has completely decayed, finishing execution', 'at {} iterations'.format(i)) break else: print('Completed {} iterations.'.format(iterations)) # plot 部分 plot_network(cities, network) route = get_route(cities, network) cities = problem.copy() citiesReal = cities[['x', 'y']] # 取实际坐标 plot_route(citiesReal, route) return route
def som(problem, iterations, learning_rate=0.8): ''' Solve the TSP using a Self-Organizing Map. :params problem(dataframe): 城市坐标 :params iterations(int): 最大迭代次数 :learning_rate(float): 学习率 :return route ''' cities = problem.copy() # Obtain the normalized set of cities (w/ coord in [0,1]) cities[['x', 'y']] = normalize(cities[['x', 'y']]) # The population size is 8 times the number of cities # <Hyperparameter:times> n = cities.shape[0] * 8 # Generate an adequate network of neurons: # (n,2) network = generate_network(n) print('Network of {} neurons created. Starting the iterations:'.format(n)) for i in range(iterations): if not i % 100: print('\t> Iteration {}/{}'.format(i, iterations), end="\r") # Choose a random city city = cities.sample(1)[['x', 'y']].values winner_idx = select_closest(network, city) # Generate a filter that applies changes to the winner's gaussian # <Hyperparameter:radius> gaussian = get_neighborhood(winner_idx, n // 10, network.shape[0]) # Update the network's weights (closer to the city) network += gaussian[:, np.newaxis] * learning_rate * (city - network) # Decay the variables # <Hyperparameter:decay rate> learning_rate = learning_rate * 0.99997 n = n * 0.9997 # Check for plotting interval if not i % 1000: plot_network(cities, network, name='diagrams/{:05d}.png'.format(i)) # Check if any parameter has completely decayed. if n < 1: print('Radius has completely decayed, finishing execution', 'at {} iterations'.format(i)) break if learning_rate < 0.001: print('Learning rate has completely decayed, finishing execution', 'at {} iterations'.format(i)) break else: print('Completed {} iterations.'.format(iterations)) plot_network(cities, network, name='diagrams/final.png') route = get_route(cities, network) plot_route(cities, route, 'diagrams/route.png') return route
def som(problem, iterations, learning_rate=0.8): """Solve the TSP using a Self-Organizing Map.""" # Obtain the normalized set of cities (w/ coord in [0,1]) dStep = 100 # 每隔100次保存一次数据 dSave = np.zeros(iterations // dStep) # 保存数据 cities = problem.copy() cities[['x', 'y']] = normalize(cities[['x', 'y']]) # 归一化 # The population size is 8 times the number of cities 神经元个数 n = cities.shape[0] * 4 # Generate an adequate network of neurons: network = generate_network(cities, n, c=2) print('Network of {} neurons created. Starting the iterations:'.format(n)) for i in range(iterations): # Check for plotting interval # if i % 100 == 0: # 每隔100次画出神经元图像 # plot_network(cities, network, name='out_files\process\city_network%d.png'%(i//100)) if not i % 100: # if i%100==0 print('\t> Iteration {}/{}'.format(i, iterations), end="\r") # Choose a random city city = cities.sample(1)[['x', 'y']].values # 随机从cities中选取一组数,1*2数组 winner_idx = select_closest(network, city) # print(winner_idx) # DEBUG # 改进方案, 获胜神经元距离小于阈值,则直接获胜 if np.linalg.norm(city - network[winner_idx, :], axis=1) < 0.005: # 求距离 network[winner_idx, :] = city # print(winner_idx) else: # Generate a filter that applies changes to the winner's gaussian gaussian = get_neighborhood(winner_idx, n // 10, network.shape[0]) # 高斯核函数是算法的核心 # Update the network's weights (closer to the city) network += gaussian[:, np.newaxis] * learning_rate * (city - network) # np.newaxis在该位置增加一维,变成神经元数*1维 # 实际上就是为了让对应的移动乘以对应的坐标 # Decay the variables learning_rate = learning_rate * 0.99999 n = n * 0.9995 # 较好的参数是0.9991-0.9997 if not i % 100: # 每隔100次, 求距离 route = get_route(cities, network) p = problem.reindex(route) dSave[i // dStep] = route_distance(p) else: print('Completed {} iterations.'.format(iterations)) # plot 部分 plot_network(cities, network) route = get_route(cities, network) cities = problem.copy() citiesReal = cities[['x', 'y']] # 取实际坐标 plot_route(citiesReal, route) return route, dSave
def som(instancia,problem, iterations, learning_rate,delta_learning_rate, delta_n,sensi_radio,sensi_learning_rate,factor_neuronas,plotear): """Solve the TSP using a Self-Organizing Map.""" # Obtenemos primero las ciudades normalizadas (con coordenadas en [0,1]) cities = problem.copy() cities[['x', 'y']] = normalize(cities[['x', 'y']]) #La población de neuronas se crea con factor_neuronas veces la cantidad de ciudades n = cities.shape[0] * factor_neuronas # Generamos una adecuada red de neuronas de la forma network = generate_network(n) if plotear: print('Red de {} neuronas creadas. Comenzando las iteraciones:'.format(n)) for i in range(iterations): if not i % 100: print('\t> Iteración {}/{}'.format(i, iterations), end="\r") # Se escoge una ciudad de forma aleatoria city = cities.sample(1)[['x', 'y']].values #Se busca la neurona más cercana a la ciudad, la winner neuron winner_idx = select_closest(network, city) #Genera un filtro que aplica los cambios al winner o BMU gaussian = get_neighborhood(winner_idx, n//10, network.shape[0]) # Actualizar los pesos de la red según una distribución gaussiana network += gaussian[:,np.newaxis] * learning_rate * (city - network) # actualizar las parametros learning_rate = learning_rate * delta_learning_rate n = n * delta_n # Chequear para plotear cada 1000 iteraciones if plotear: if not i % 1000: plot_network(cities, network, name='imagenes/'+instancia+'/{:05d}.png'.format(i)) # Chequear si algún parametro a caído por debajo de la sensibilidad if n < sensi_radio: print('Radio por debajo de sensibilidad, Se ha terminado la ejecución', 'a {} las iteraciones'.format(i)) break if learning_rate < sensi_learning_rate: print('Learning rate por debajo de sensibilidad, Se ha terminado la ejecución', 'a las {} iteraciones'.format(i)) break else: print('Se han completado las {} iteraciones.'.format(iterations)) if plotear: plot_network(cities, network, name='imagenes/'+instancia+'/final.png') route = get_route(cities, network) if plotear: plot_route(cities, route, 'imagenes/'+instancia+'/route.png') return route
def som(problem, iterations, learning_rate=0.8): """Solve the TSP using a Self-Organizing Map.""" # Obtain the normalized set of cities (w/ coord in [0,1]) cities = problem.copy() cities[['x', 'y']] = normalize(cities[['x', 'y']]) # The population size is 8 times the number of cities 神经元个数 n = cities.shape[0] * 8 network = generate_network(n) # Generate an adequate network of neurons: print('Network of {} neurons created. Starting the iterations:'.format(n)) for i in range(iterations): if i == 0 or (not i % 1000): plot_network(cities, network, name='out_files\process\city_network%d.png' % (i // 1000 + 1)) city = cities.sample(1)[['x', 'y']].values # 随机从cities中选取一组数,1*2数组 winner_idx = select_closest(network, city) # Generate a filter that applies changes to the winner's gaussian gaussian = get_neighborhood(winner_idx, n // 10, network.shape[0]) # Update the network's weights (closer to the city) network += gaussian[:, np.newaxis] * learning_rate * ( city - network) # np.newaxis在该位置增加一维,变成神经元数*1维 # 实际上就是为了让对应的移动乘以对应的坐标 # Decay the variables learning_rate = learning_rate * 0.99997 n = n * 0.9997 # Check for plotting interval # Check if any parameter has completely decayed. if n < 1: print('Radius has completely decayed, finishing execution', 'at {} iterations'.format(i)) break if learning_rate < 0.001: print('Learning rate has completely decayed, finishing execution', 'at {} iterations'.format(i)) break # if 神经元覆盖了城市 # print('在第{}次迭代,收敛'.format(i)) else: print('Completed {} iterations.'.format(iterations)) plot_network(cities, network) route = get_route(cities, network) plot_route(problem[['x', 'y']], route) return route
def som(problem, iterations, learning_rate=0.8): cities = problem.copy() cities[['x', 'y']] = normalize(cities[['x', 'y']]) n = cities.shape[0] * 8 network = generate_network(n) print('Network of {} neurons created. Starting the iterations:'.format(n)) for i in range(iterations): if not i % 100: print('\t> Iteration {}/{}'.format(i, iterations), end="\r") city = cities.sample(1)[['x', 'y']].values winner_idx = select_closest(network, city) gaussian = get_neighborhood(winner_idx, n // 10, network.shape[0]) network += gaussian[:, np.newaxis] * learning_rate * (city - network) learning_rate = learning_rate * 0.99997 n = n * 0.9997 if not i % 1000: plot_network(cities, network, name='diagrams/{:05d}.png'.format(i)) if n < 1: print('Radius has completely decayed, finishing execution', 'at {} iterations'.format(i)) break if learning_rate < 0.001: print('Learning rate has completely decayed, finishing execution', 'at {} iterations'.format(i)) break else: print('Completed {} iterations.'.format(iterations)) plot_network(cities, network, name='diagrams/final.png') route = get_route(cities, network) plot_route(cities, route, 'diagrams/route.png') return route
def main(): """ Reads in the city data, runs the som algorithm, and plots the topological 1-D mapping """ city_coords, city_names = generate_data.city_coords(verbose=True, feat_lim=None, examples_lim=None) params = { "epochs": 50, "step_size": 0.2, "num_nodes": [10], "neighborhood_type": 'circular' # ['circular', 'linear'] } som1 = Som(city_coords, **params) som1.train() pos = som1.apply(city_coords) sorted_coords, sorted_names = som1.order(pos, city_coords, city_names) print("city names in order: ") print(sorted_names) plot.plot_route(sorted_coords, sorted_names)
count[i] = _count print("mean time: {:.5f}".format(T.mean())) print("mean kaisuu: {}".format(count.mean())) elif wh == 'sa': T = np.arange(epoch, dtype=np.float64) count = np.arange(epoch) tf = [True] * len(test_order) route = [] if len(test_order) == 10: best_route, _count = dfs_best(test_order, dis, tf, route, len(test_order)) t = 1000 a = 0.999 truth = 0 for i in range(epoch): start = time.time() best_route_, _count = sa_2opt(test_order, dis, t, a) end = time.time() T[i] = end - start print(T[i]) count[i] = _count if len(test_order) == 10: if tru(best_route_, best_route): truth += 1 if len(test_order) == 10: print("precision: {:.4f}".format(truth / epoch)) print("mean time: {:.5f}".format(T.mean())) print("mean kaisuu: {}".format(count.mean())) plot_route(test_order, best_route_, point)
#!/usr/bin/python3 import calc as cl import database as db import plot as pl import view as vw if __name__ == "__main__": db.connect() start_addr = db.get_start_address() stops = db.get_stop_positions() pos = db.get_unique_positions() addrs = cl.order_addresses(db.get_all_addresses(), stops) tot_dist = cl.total_distance(pos) print("Total route distance:", round(tot_dist, 2), "km") pl.init() pl.plot_addresses(start_addr, addrs) pl.plot_route(pos) pl.save() vw.copy_kml_public("/home/hlilje/Dropbox/") vw.write_kml_url() vw.view() db.close()
from sys import argv import numpy as np #iner from neuron import generate_network, get_neighborhood, get_route from plot import plot_neuron_chain, plot_route, plot_loss from opts import OPT from dataloader import dataloader import pandas as pd from path import Path from som import SOM import matplotlib.pyplot as plt def main(): pass if __name__ == '__main__': args = OPT().args() SOM(args) plot_loss(input_dir=args.out_dir) plot_route(input_dir=args.out_dir) plot_neuron_chain(input_dir=args.out_dir)
def som(problem, iterations, learning_rate=0.8): ''' SOM解决TSP问题 ''' # 将城市数据归一化处理 cities = problem.copy() cities[['x', 'y']] = normalize(cities[['x', 'y']]) # 神经元数量设定为城市的8倍 n = cities.shape[0] * 8 # 建立神经网络 network = generate_network(n) print('创建{} 个神经元. 开始进行迭代:'.format(n)) for i in range(iterations): if not i % 100: print('\t> 迭代过程 {}/{}'.format(i, iterations), end='\r') # 随机选择一个城市 city = cities.sample(1)[['x', 'y']].values #优胜神经元(距离该城市最近的神经元) winner_idx = select_closest(network, city) # 以该神经元为中心建立高斯分布 gaussian = get_neighborhood(winner_idx, n // 10, network.shape[0]) # 更新神经元的权值,使神经元向被选中城市移动 network += gaussian[:, np.newaxis] * learning_rate * (city - network) # 学习率衰减,方差衰减 learning_rate = learning_rate * 0.99997 n = n * 0.9997 # 每迭代1000次时作图 if not i % 1000: plot_network(cities, network, name='som_diagrams/{:05d}.png'.format(i)) pass # 判断方差和学习率是否达到阈值 if n < 1: print('方差已经达到阈值,完成执行次数{}'.format(i)) break if learning_rate < 0.001: print('学习率已经达到阈值,完成执行次数{}'.format(i)) break else: print('完成迭代:{}次'.format(iterations)) plot_network(cities, network, name='som_diagrams/final.png') route = get_route(cities, network) cities = cities.reindex(route) plot_route(cities, route, 'som_diagrams/route.png') # 将多个png文件合成gif文件 path = os.chdir('.\som_diagrams') pic_list = os.listdir() create_gif(pic_list, 'result.gif', 0.3) return route