def __init__(self,amap):
self.running = True
self.OnInit()
g = Graph(amap)
#self.search = Search(g,'A','T')
self.search = RandomSearch(g,'L','N')
self.search.reset()
def randomRetries(inputFile, m, k):
bestM = 1
bestS = 100000000000
bestR = 1
for i in range(5):
for m in range(m, m + 1):
startTime = time.time()
jobs = JobManager.JobManager(k, inputFile, m)
machines = MachineBoss.MachineBoss(m)
RandomSearch.RandomSearch(machines, jobs)
makeSpan = machines.maxMachine().makeSpan
OPT = max(jobs.MAXJOB, jobs.sumJobTime / float(m))
bestS, bestM = "", ""
if makeSpan < bestS:
bestS = makeSpan
bestM = m
bestR = OPT
exTime = time.time() - startTime
#print "Max Machine Run time: "+ str(makeSpan) + " OPT for " + str(m) + " machines is " + str(ratio)
#print "ratio: " + str(makeSpan/ratio)
print "Random Search: \t\t " + str(bestS) + "|| Ratio: " + str(
bestS / OPT) + " run time: " + str(exTime)
def rand_search():
for j in range(20):
RandomSearch((-5.12, 5.12))
#rand_search()
def searchImage(self, imageData, idealMaskData, parameters, plot=False):
# Requires: -image and idealMask is an RGB based image
# -parameters is of type Parameters
# Modifies: parameters
# Effects: - Searches the parameter space using simulated annealing
# to find an optimal solution, returns most optimal parameter found
# -plots fitness vs. generation of search if plot set to True
print "Running Anneal Search"
# runs random search to find best from initial population
# note, random search sets initial upper limit
print "Calling random search for initial random guess"
randSearch = RandomSearch.randomSearch(self.segmenter, self.fitness)
parameters = randSearch.searchImage(imageData, idealMaskData,
parameters)
# set no upper limit (infinity) for fitness function
parameters.setUpperLimit(float("inf"))
# hold references to image data and ideal mask data
# to conform with scipy's need for a simple fitness function (not using multiple arguments)
self.imageData = imageData
self.idealMaskData = idealMaskData
# if color based segmenter, run anneal accordingkly
if type(self.segmenter) == type(segmentation.colorSegmenter()):
# make initial guess based off random search
initialGuess = numpy.array(sum(parameters.colorRanges, []))
# runs scipy's anneal
results = optimize.anneal(self.segmentAndFitnessColor,
x0=initialGuess,
args=(parameters, ),
schedule='cauchy',
full_output=True,
dwell=50,
lower=0.0,
upper=1.0,
disp=True,
T0=.005)
# prints anneal's final fitness
print "Final Fitness " + str(results[1])
# for color segmenters
colorRanges = results[0]
colorRanges = [
colorRanges[0:2], colorRanges[2:4], colorRanges[4:6]
]
parameters.setColorRanges(colorRanges)
# if other kind of segmenter, add below
return parameters
class App:
def __init__(self,amap):
self.running = True
self.OnInit()
g = Graph(amap)
#self.search = Search(g,'A','T')
self.search = RandomSearch(g,'L','N')
self.search.reset()
def OnInit(self):
pygame.init()
resolution = 640,480
self.screen = pygame.display.set_mode(resolution)
self.screen.fill(bgcolor)
self.clock = pygame.time.Clock()
def onEvent(self,event):
if event.type == pygame.QUIT or event.type==pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.running = False
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.search.step()
if event.key == pygame.K_r:
self.search.reset()
if event.key == pygame.K_RETURN:
print 'return Pressed'
self.search.run()
def cleanUp(self):
pygame.quit()
def render(self,seconds):
#self.screen.fill(bgcolor)
self.search.draw(self.screen)
pygame.display.flip()
def mainloop(self):
fps = 60
while self.running:
seconds = self.clock.tick(fps)
for event in pygame.event.get():
self.onEvent(event)
self.render(seconds)
self.cleanUp()
def searchImage(self, imageData, idealMaskData, parameters, plot=False):
# Requires: -image and idealMask is an RGB based image
# -parameters is of type Parameters
# Modifies: parameters
# Effects: - Searches the parameter space using selective mutations
# to find an optimal solution, returns most optimal parameter found
# -plots fitness vs. generation of search if plot set to True
print "Running genetic search"
mutatedPopSize = int(raw_input("Size of mutated populations: "))
numGenerations = int(raw_input("Number of generations: "))
# runs random search to find best from initial population
# note, random search sets initial upper limit
print "Calling random search for initial population"
print "Initial population size = Number of Iterations"
randSearch = RandomSearch.randomSearch(self.segmenter, self.fitness)
parameters = randSearch.searchImage(imageData, idealMaskData,
parameters)
newBestParameters = deepcopy(parameters)
# outter loop, number of generations
for i in range(numGenerations):
print "Generation " + str(i + 1)
curBestParameters = deepcopy(newBestParameters)
newMask = self.segmenter.segmentImage(imageData, curBestParameters)
curBestFit = self.fitness.findFitness(newMask, idealMaskData,
curBestParameters)
# inner loop, number of pop per generations
for j in range(mutatedPopSize):
self.mutateParameters(parameters)
newMask = self.segmenter.segmentImage(imageData, parameters)
newFit = self.fitness.findFitness(newMask, idealMaskData,
parameters)
if newFit < curBestFit:
curBestFit = newFit
newBestParameters = deepcopy(parameters)
newBestParameters.setUpperLimit(curBestFit)
parameters = deepcopy(curBestParameters)
print "Gen " + str(i + 1) + " Iter " + str(j + 1) + ", " + str(
curBestFit)
parameters = deepcopy(curBestParameters)
return parameters
def searchImage(self, imageData, idealMaskData, parameters, plot = False):
# Requires: -image and idealMask is an RGB based image
# -parameters is of type Parameters
# Modifies: parameters
# Effects: - Searches the parameter space using selective mutations
# to find an optimal solution, returns most optimal parameter found
# -plots fitness vs. generation of search if plot set to True
print "Running genetic search"
mutatedPopSize = int(raw_input("Size of mutated populations: "))
numGenerations = int(raw_input("Number of generations: "))
# runs random search to find best from initial population
# note, random search sets initial upper limit
print "Calling random search for initial population"
print "Initial population size = Number of Iterations"
randSearch = RandomSearch.randomSearch(self.segmenter, self.fitness)
parameters = randSearch.searchImage(imageData, idealMaskData, parameters)
newBestParameters = deepcopy(parameters)
# outter loop, number of generations
for i in range(numGenerations):
print "Generation " + str(i + 1)
curBestParameters = deepcopy(newBestParameters)
newMask = self.segmenter.segmentImage(imageData, curBestParameters)
curBestFit = self.fitness.findFitness(newMask, idealMaskData, curBestParameters)
# inner loop, number of pop per generations
for j in range(mutatedPopSize):
self.mutateParameters(parameters)
newMask = self.segmenter.segmentImage(imageData, parameters)
newFit = self.fitness.findFitness(newMask, idealMaskData, parameters)
if newFit < curBestFit:
curBestFit = newFit
newBestParameters = deepcopy(parameters)
newBestParameters.setUpperLimit(curBestFit)
parameters = deepcopy(curBestParameters)
print "Gen " + str(i + 1) + " Iter " + str(j + 1) + ", " + str(curBestFit)
parameters = deepcopy(curBestParameters)
return parameters
def searchImage(self, imageData, idealMaskData, parameters, plot = False):
# Requires: -image and idealMask is an RGB based image
# -parameters is of type Parameters
# Modifies: parameters
# Effects: - Searches the parameter space using simulated annealing
# to find an optimal solution, returns most optimal parameter found
# -plots fitness vs. generation of search if plot set to True
print "Running Anneal Search"
# runs random search to find best from initial population
# note, random search sets initial upper limit
print "Calling random search for initial random guess"
randSearch = RandomSearch.randomSearch(self.segmenter, self.fitness)
parameters = randSearch.searchImage(imageData, idealMaskData, parameters)
# set no upper limit (infinity) for fitness function
parameters.setUpperLimit(float("inf"))
# hold references to image data and ideal mask data
# to conform with scipy's need for a simple fitness function (not using multiple arguments)
self.imageData = imageData
self.idealMaskData = idealMaskData
# if color based segmenter, run anneal accordingkly
if type(self.segmenter) == type(segmentation.colorSegmenter()):
# make initial guess based off random search
initialGuess = numpy.array(sum(parameters.colorRanges, []))
# runs scipy's anneal
results = optimize.anneal(self.segmentAndFitnessColor, x0 = initialGuess, args=(parameters,),
schedule='cauchy', full_output=True, dwell=50,
lower=0.0, upper=1.0, disp=True, T0 = .005)
# prints anneal's final fitness
print "Final Fitness " + str(results[1])
# for color segmenters
colorRanges = results[0]
colorRanges = [colorRanges[0:2], colorRanges[2:4], colorRanges[4:6]]
parameters.setColorRanges(colorRanges)
# if other kind of segmenter, add below
return parameters
def simpleTest(writeFile, inputFile, m, k):
line = ""
bestM = 1
bestS = 100000000000
bestR = 0
for m in range(m, m + 1):
startTime = time.time()
jobs = JobManager.JobManager(k, inputFile, m)
machines = MachineBoss.MachineBoss(m)
SortedGreedyScheduler.SortedGreedyScheduler(machines, jobs)
makeSpan = machines.maxMachine().makeSpan
OPT = max(jobs.MAXJOB, jobs.sumJobTime / float(m))
bestS, bestM = "", ""
if makeSpan < bestS:
bestS = makeSpan
bestM = m
bestR = OPT
exTime = time.time() - startTime
line = line + str(m) + "," + str(k) + "," + str(bestS / OPT) + ","
print "SG"
bestM = 1
bestS = 100000000000
bestR = 1
for i in range(5):
for m in range(m, m + 1):
startTime = time.time()
jobs = JobManager.JobManager(k, inputFile, m)
machines = MachineBoss.MachineBoss(m)
RandomSearch.RandomSearch(machines, jobs)
makeSpan = machines.maxMachine().makeSpan
OPT = max(jobs.MAXJOB, jobs.sumJobTime / float(m))
bestS, bestM = "", ""
if makeSpan < bestS:
bestS = makeSpan
bestM = m
bestR = OPT
exTime = time.time() - startTime
#print "Max Machine Run time: "+ str(makeSpan) + " OPT for " + str(m) + " machines is " + str(ratio)
#print "ratio: " + str(makeSpan/ratio)
line = line + str(bestS / OPT) + ","
print "RS"
bestM = 1
bestS = 100000000000
bestR = 1
for i in range(5):
for m in range(m, m + 1):
startTime = time.time()
jobs = JobManager.JobManager(k, inputFile, m)
machines = MachineBoss.MachineBoss(m)
RandomSearchStatistics.RandomSearchStatistics(machines, jobs)
makeSpan = machines.maxMachine().makeSpan
OPT = max(jobs.MAXJOB, jobs.sumJobTime / float(m))
bestS, bestM = "", ""
if makeSpan < bestS:
bestS = makeSpan
bestM = m
bestR = OPT
exTime = time.time() - startTime
#print "Max Machine Run time: "+ str(makeSpan) + " OPT for " + str(m) + " machines is " + str(ratio)
#print "ratio: " + str(makeSpan/ratio)
line = line + str(bestS / OPT) + "\n"
writeFile.write(line)
print "RSH"
def main():
# commented out try for debugging purposes
#try:
shortOpts = "d:f:s:i:m:hepc:r:"
longOpts = ["segment=", "fitness=", "search=", "image=",
"mask=", "help", "export", "plot", "close=", "predict="]
try:
options, remainder = getopt.getopt(sys.argv[1:], shortOpts, longOpts)
except:
print "\nERROR: Invalid option argument\n"
exit(1)
export = False
plot = False
close = False
predictImages = False
# sets relevant variables based on command line input
for opt, arg in options:
if opt in ("-d", "--segment"):
segmenterName = arg
elif opt in ("-f", "--fitness"):
fitnessName = arg
elif opt in ("-s", "--search"):
searchName = arg
elif opt in ("-i", "--image"):
imageName = arg
elif opt in ("-m", "--mask"):
idealMaskName = arg
elif opt in ("-e", "--export"):
export = True
elif opt in ("-p", "--plot"):
plot = True
elif opt in ("-c", "--close"):
close = True
closeType = arg
elif opt in ("-r", "--predict"):
predictImages = True
predictFolderName = arg
elif opt in ("-h", "--help"):
print __doc__
exit(0)
else:
pass
# quit if extraneous input provided
if remainder != []:
print "\nERROR: Extraneous input\n"
exit(1)
# initialize segmenter algorithm
if segmenterName.lower() in ("rgb", "hsv", "hls"):
segmenter = segmentation.colorSegmenter()
else:
print "\nERROR: Invalid or no segmenter name\n"
exit(1)
# initialize fitness function
if fitnessName.lower() == "diff":
fitnessFunc = fitness.absDiffFitness()
else:
print "\nERROR: Invalid or no fitness name\n"
exit(1)
# initialize search space algorithm
if searchName.lower() == "random":
searchFunc = RandomSearch.randomSearch(segmenter, fitnessFunc)
elif searchName.lower() == "genetic":
searchFunc = GeneticSearch.geneticSearch(segmenter, fitnessFunc)
elif searchName.lower() == "anneal":
searchFunc = AnnealSearch.annealSearch(segmenter, fitnessFunc)
else:
print "\nERROR: Invalid or no search name\n"
exit(1)
# try to open image, and convert image data from a [0, 255] RGB space
# to a [0, 1] normalized RGB, HSV, or HLS space, depending on the segmenter selected
# (chooses HSV or HLS if their respective segmenter is selected, else selects RGB)
# if opening image fails, quit with error
try:
image = Image.open(imageName)
# initialize parameters object, init's image size and color space used
parameter = parameters.Parameters()
parameter.setImageSize(image.size)
# use hsv or hls if segmenter specified, else use rgb by default
if segmenterName.lower() in ("hsv", "hls"):
parameter.setColorSpace(segmenterName.lower())
else:
parameter.setColorSpace("rgb")
imageData = colorSpaceConvert(list(image.getdata()), parameter.colorSpace)
except:
print "\nERROR: Invalid or no image name\n"
exit(1)
# try to open ideal mask, if it fails, quit with error
try:
mask = Image.open(idealMaskName)
idealMaskData = list(mask.getdata())
except:
print "\nERROR: Invalid or no mask name\n"
exit(1)
# run search on image parameter space for segmentation
# returns optimal paramaters found upon search completion
# and saves a plot of fitness vs. search extent if plot set to true
optimalParameters = searchFunc.searchImage(imageData, idealMaskData, parameter, plot)
# reset upper limit
optimalParameters.setUpperLimit(float("inf"))
# if export enabled, saves mask using optimal parameters found to output.png
if (export == True):
segmenter.segmentImage(imageData, optimalParameters, True)
# if export enabled, saves a 'closed' mask using optimal parameters found to output.png
if (close == True):
whiteArg = 1 if closeType.lower() == "white" else 0
mask = segmenter.segmentImage(imageData, optimalParameters)
close = closure.closure()
close.segmentRegions(mask, optimalParameters, saveImage = export, clearWhite = whiteArg)
if predictImages == True:
predict.predict(predictFolderName, optimalParameters, segmenter, fitnessFunc,
plot = True, exportImages = export)
print('\n\n##################### \t N: \t' + str(d[0].shape[0]) +
'\t\t########################')
start = time.time()
test = Qap(flow=d[0],
distance=d[1],
pop_size=100,
gen=100,
p_x=0.7,
p_m=0.01,
tour=tour)
buff = 0
for i in range(10):
test.main()
test.result()
buff += test.best_unit[1]
print('AVG: ' + str(buff / 10))
stop = time.time()
duration = int(round((stop - start) * 1000))
print('Duration: ' + str(duration) + ' ms')
pass
f, d = (np.loadtxt('data/flow_12.txt').astype(int),
np.loadtxt('data/distance_12.txt').astype(int))
start = time.time()
test = RandomSearch(f, d, 1000)
test.run_random()
stop = time.time()
duration = int(round((stop - start) * 1000))
print('Duration: ' + str(duration) + ' ms')
