tspm.py

#!/usr/bin/python

import random
import sys
import getopt
from PIL import Image, ImageDraw, ImageFont
from math import sqrt
import itertools
import logging
logger = logging.getLogger(__name__)

def rand_seq(size):
    '''generates values in random order
    equivalent to using shuffle in random,
    without generating all values at once'''
    values=range(size)
    for i in xrange(size):
        # pick a random index into remaining values
        j=i+int(random.random()*(size-i))
        # swap the values
        values[j],values[i]=values[i],values[j]
        # return the swapped value
        yield values[i] 

def all_pairs(size):
    '''generates all i,j pairs for i,j from 0-size'''
    for i in rand_seq(size):
        for j in rand_seq(size):
            yield (i,j)

def reversed_sections(tour):  # i`m trying to fix start and finish 
    '''generator to return all possible variations where the section between two cities are swapped'''
    # my edit
    start_city = tour[0]
    finish_city = tour[-1]
    tour = tour[1:-1]
    all_pairs = [[pair[0]-1,pair[-1]-1] for pair in itertools.combinations(tour,2)]
    # my edit end
    for i,j in all_pairs:
    # for i,j in all_pairs(len(tour)):
        if i != j:
            copy=tour[:]
            if i < j:
                copy[i:j+1]=reversed(tour[i:j+1])
            else:
                copy[i+1:]=reversed(tour[:j])
                copy[:j]=reversed(tour[i+1:])
            if copy != tour: # no point returning the same tour
                yield [start_city]+copy+[finish_city] # my edit

def swapped_cities(tour): # i`m trying to fix start and finish 
    '''generator to create all possible variations where two cities have been swapped'''
    # my edit
    start_city = tour[0]
    finish_city = tour[-1]
    tour = tour[1:-1]
    all_pairs = [[pair[0]-1,pair[-1]-1] for pair in itertools.combinations(tour,2)]
    # my edit end
    for i,j in all_pairs:
    # for i,j in all_pairs(len(tour)):
        if i < j:
            copy=tour[:]
            try:
                copy[i],copy[j]=tour[j],tour[i]
            except Exception as e:
                print(e)
                print("i=%d,j=%d"%(i,j))
                print("tour=%s"% str(tour))
                raise
            yield [start_city]+copy+[finish_city] # my edit

def cartesian_matrix(coords):
    '''create a distance matrix for the city coords that uses straight line distance'''
    matrix={}
    for i,(x1,y1) in enumerate(coords):
        for j,(x2,y2) in enumerate(coords):
            dx,dy=x1-x2,y1-y2
            dist=sqrt(dx*dx + dy*dy)
            matrix[i,j]=dist
    return matrix

def read_coords(coord_file):
    '''
    read the coordinates from file and return the distance matrix.
    coords should be stored as comma separated floats, one x,y pair per line.
    '''
    coords=[]
    for line in coord_file:
        x,y=line.strip().split(',')
        coords.append((float(x),float(y)))
    return coords

def tour_length(matrix,tour):
    '''total up the total length of the tour based on the distance matrix'''
    total=0
    num_cities=len(tour)
    for i in range(num_cities):
        j=(i+1)%num_cities
        city_i=tour[i]
        city_j=tour[j]
        total+=matrix[city_i,city_j]
    return total

def write_tour_to_img(coords,tour,title,img_file_name):

    from bokeh.plotting import figure, output_file, show, save
    import numpy as np
    # from bokeh.models.mappers import LinearColorMapper
    # output to static HTML file
    output_file(img_file_name)

    p = figure(plot_width=400, plot_height=400)

    num_cities=len(tour)
    color_list = ["#%02x%02x%02x" % (r, g, 255./num_cities) for r, g in zip(np.arange(0,255,255./num_cities),  np.arange(0,255,255./num_cities))]
    # print(color_list)
    # color_list = ["#%02x%02x%02x" % (r, g, num_cities) for r, g in zip(np.floor(50+2*x), np.floor(30+2*y))]
    for i in range(num_cities):
        # print(color_list[i])
        j=(i+1)%num_cities
        city_i=tour[i]
        city_j=tour[j]
        x1,y1=coords[city_i]
        x2,y2=coords[city_j]
        p.line([x1,x2],[y1,y2],color=color_list[i])
        p.circle([x1,x2],[y1,y2],color=color_list[i])
    # show the results
    show(p)
    save(p)

def init_random_tour(tour_length):
   tour=range(1,tour_length-1)
   random.shuffle(tour)
   tour = [0]+tour+[tour_length-1]
   return tour

def create_tour_from_list(tour_list):
   return tour_list

def run_hillclimb(init_function,move_operator,objective_function,max_iterations):
    from hillclimb import hillclimb_and_restart
    iterations,score,best=hillclimb_and_restart(init_function,move_operator,objective_function,max_iterations)
    return iterations,score,best

def run_anneal(init_function,move_operator,objective_function,max_iterations,start_temp,alpha):
    if start_temp is None or alpha is None:
        usage();
        print "missing --cooling start_temp:alpha for annealing"
        sys.exit(1)
    from sa import anneal
    iterations,score,best=anneal(init_function,move_operator,objective_function,max_iterations,start_temp,alpha)
    return iterations,score,best

def usage():
    print "usage: python %s [-o <output image file>] [-v] [-m reversed_sections|swapped_cities] -n <max iterations> [-a hillclimb|anneal] [--cooling start_temp:alpha] <city file>" % sys.argv[0]

def main():
    logger.info("tsp main started")
    try:
        options, args = getopt.getopt(sys.argv[1:], "ho:vm:n:a:", ["cooling="])
    except getopt.GetoptError:
        usage()
        sys.exit(2)
    out_file_name=None
    max_iterations=None
    verbose=None
    move_operator=reversed_sections
    run_algorithm=run_hillclimb
    
    start_temp,alpha=None,None
    
    for option,arg in options:
        if option == '-v':
            verbose=True
        elif option == '-h':
            usage()
            sys.exit()
        elif option == '-o':
            out_file_name=arg
        elif option == '-n':
            max_iterations=int(arg)
        elif option == '-m':
            if arg == 'swapped_cities':
                move_operator=swapped_cities
            elif arg == 'reversed_sections':
                move_operator=reversed_sections
        elif option == '-a':
            if arg == 'hillclimb':
                run_algorithm=run_hillclimb
            elif arg == 'anneal':
                # do this to pass start_temp and alpha to run_anneal
                def run_anneal_with_temp(init_function,move_operator,objective_function,max_iterations):
                    return run_anneal(init_function,move_operator,objective_function,max_iterations,start_temp,alpha)
                run_algorithm=run_anneal_with_temp
        elif option == '--cooling':
            start_temp,alpha=arg.split(':')
            start_temp,alpha=float(start_temp),float(alpha)
    
    if max_iterations is None:
        usage();
        sys.exit(2)
    
    if out_file_name and not out_file_name.endswith(".html"):
    # if out_file_name and not out_file_name.endswith(".png"):
        usage()
        print "output image file name must end in .png"
        sys.exit(1)
    
    if len(args) != 1:
        usage()
        print "no city file specified"
        sys.exit(1)
    
    city_file=args[0]
    
    # enable more verbose logging (if required) so we can see workings
    # of the algorithms
    import logging
    format='%(asctime)s %(levelname)s %(message)s'
    if verbose:
        logging.basicConfig(level=logging.INFO,format=format)
        # rootLogger = logging.getLogger()
        # rootLogger.addHandler(logging.StreamHandler())
    else:
        logging.basicConfig(format=format)
    
    # setup the things tsp specific parts hillclimb needs
    coords=read_coords(file(city_file))
    init_function=lambda: init_random_tour(len(coords))
    matrix=cartesian_matrix(coords)
    objective_function=lambda tour: -tour_length(matrix,tour)
    
    logging.info('using move_operator: %s'%move_operator)
    
    iterations_done,score,best=run_algorithm(init_function,move_operator,objective_function,max_iterations)
    iterations_done = 0
    while iterations_done <= max_iterations:
        init_function=lambda: create_tour_from_list(best)
        this_run_iterations_done,score,best=run_algorithm(init_function,move_operator,objective_function,max_iterations-iterations_done)
        iterations_done += this_run_iterations_done
    # output results
    # print iterations,score,best
    
    if out_file_name:
        write_tour_to_img(coords,best,'%s: %f'%(city_file,score),out_file_name)
    
    logger.info("tsp main result: iterations_done %s ,score %s ,best %s" % tuple([str(el) for el in (iterations_done,score,best)]))
    return (iterations_done,score,best)

if __name__ == "__main__":
    main()