def __init__(self, bufferSize, epsilon, delta, vectorSize, historySize=0): self.epsilon = epsilon self.delta = delta self.buffer = CircularList(bufferSize) # moving average buffer self.models = ModelList(historySize) self.mask = None self.time = 0 self.movingAverage = 'No Moving Average' self.movingAverageDistance = -1 self.modelVectorsDistance = -1 self.winner = 'No Winner' self.newWinnerIndex = -1 self.previousWinnerIndex = -1 self.verbosity = 0 self.tolerance = delta self.addModels = 1 self.winnerCount = 0 self.printDistance = 0 self.newModelVector = (None, None) self.mapModelVector = (None, None) self.regions = [] #list of region objects self.prevVec = None self.eventState = False #keep track of start of events #Initialize region for state -1 self.regions.append( Region(vectorSize, vectorSize, [], len(self.models) - 1))
def __init__(self, bufferSize, epsilon, delta, vectorSize, historySize=0): self.epsilon = epsilon self.delta = delta self.buffer = CircularList(bufferSize) # moving average buffer self.models = ModelList(historySize) self.mask = None self.time = 0 self.movingAverage = 'No Moving Average' self.movingAverageDistance = -1 self.modelVectorsDistance = -1 self.winner = 'No Winner' self.newWinnerIndex = -1 self.previousWinnerIndex = -1 self.verbosity = 0 self.tolerance = delta self.addModels = 1 self.winnerCount = 0 self.printDistance = 0 self.newModelVector = (None, None) self.mapModelVector = (None, None) self.regions = [] #list of region objects self.prevVec = None self.eventState = False #keep track of start of events #Initialize region for state -1 self.regions.append(Region(vectorSize, vectorSize, [], len(self.models)-1))
def move_application(self, app): old_host = app.host_server cluster_list = self.manager.get_docker_cluster() circular_cluster_list = CircularList( self.manager.order_cluster_by_load(cluster_list)) if app.host_server in circular_cluster_list: index = circular_cluster_list.index(app.host_server) app.host_server = circular_cluster_list[index+1].hostname else: # Assign the first one in the list if not found above app.host_server = circular_cluster_list[0].hostname self.logger.info("Moving app {app_name} from {old_host} to {new_host}".format( app_name=app.hostname, old_host=old_host, new_host=app.host_server)) self.logger.info("Bootstrapping the application on the new host") self.start_application(app)
def move_application(self, app): old_host = app.host_server cluster_list = self.manager.get_docker_cluster() circular_cluster_list = CircularList( self.manager.order_cluster_by_load(cluster_list)) if app.host_server in circular_cluster_list: index = circular_cluster_list.index(app.host_server) app.host_server = circular_cluster_list[index + 1].hostname else: # Assign the first one in the list if not found above app.host_server = circular_cluster_list[0].hostname self.logger.info( "Moving app {app_name} from {old_host} to {new_host}".format( app_name=app.hostname, old_host=old_host, new_host=app.host_server)) self.logger.info("Bootstrapping the application on the new host") self.start_application(app)
def __init__(self, bufferSize, epsilon, delta, historySize=0): self.epsilon = epsilon self.delta = delta self.buffer = CircularList(bufferSize) # moving average buffer self.models = ModelList(historySize) self.mask = None self.time = 0 self.movingAverage = 'No Moving Average' self.movingAverageDistance = -1 self.modelVectorsDistance = -1 self.winner = 'No Winner' self.newWinnerIndex = -1 self.previousWinnerIndex = -1 self.verbosity = 0 self.tolerance = delta self.addModels = 1 self.winnerCount = 0 self.printDistance = 0 self.newModelVector = (None, None) self.mapModelVector = (None, None)
def __init__(self, bucketSize=5): CircularList.__init__(self) self.bucketSize = bucketSize
class RAVQ: """ Implements RAVQ algorithm as described in Linaker and Niklasson. """ def __init__(self, bufferSize, epsilon, delta, historySize=0): self.epsilon = epsilon self.delta = delta self.buffer = CircularList(bufferSize) # moving average buffer self.models = ModelList(historySize) self.mask = None self.time = 0 self.movingAverage = 'No Moving Average' self.movingAverageDistance = -1 self.modelVectorsDistance = -1 self.winner = 'No Winner' self.newWinnerIndex = -1 self.previousWinnerIndex = -1 self.verbosity = 0 self.tolerance = delta self.addModels = 1 self.winnerCount = 0 self.printDistance = 0 self.newModelVector = (None, None) self.mapModelVector = (None, None) # update the RAVQ def input(self, vec): """ Drives the ravq. For most uses, the vector categorization is as simple as calling ravq.input(vec) on all vec in the dataset. Accessing the winning model vector (after the buffer is full) can be done directly. Using the get commands after calling input will return any information necessary from the ravq. """ if self.verbosity > 1: print("Step:", self.time) if self.verbosity > 2: print(vec) array = Numeric.array(vec, 'd') if self.mask == None: self.mask = Numeric.ones(len(array), 'd') self.buffer.addItem(array) if self.time >= len(self.buffer): self.process() if self.verbosity > 2: print(self) self.time += 1 return (self.newWinnerIndex, self.winner) # attribute methods def getNewWinner(self): """ Returns boolean depending on whether or not there is a new winner after the last call to input. """ if self.winnerCount > 0: return 0 else: return 1 def setMask(self, mask): """ The mask serves to weight certain components of the inputs in the distance calculations. """ self.mask = Numeric.array(mask, 'd') def getWinnerCount(self): """ Returns the number of times the current winner has been the winner, ie. the number of consecutive calls to input where the current winner has been the winner. """ return self.winnerCount def setVerbosity(self, value): """ Determines which print statements to call. Debugging only. """ self.verbosity = value def setAddModels(self, value): """ Allows the RAVQ to dynamically add model vectors. """ self.addModels = value # process happens once the buffer is full def process(self): """ The RAVQ Algorithm: 1. Calculate the average vector of all inputs in the buffer. 2. Calculate the distance of the average from the set of inputs in the buffer. 3. Calculate the distance of the model vectors from the inputs in the buffer. 4. If distance in step 2 is small and distance in step 3 is large, add current average to list of model vectors. 5. Calculate the winning model vector based on distance between each model vector and the buffer list. 6. Update history. ---The metric used to calculate distance is described in "Sensory Flow Segmentation Using a Resource Allocating Vector Quantizer" by Fredrik Linaker and Lars Niklasson (2000).--- """ self.newModelVector = (None, None) self.setMovingAverage() self.setMovingAverageDistance() self.setModelVectorsDistance() if self.verbosity > 2: print("Moving average:", self.movingAverage) if self.verbosity > 1: print("Moving average distance: ", self.movingAverageDistance) print("Model vectors distance: ", self. modelVectorsDistance) if self.addModels: self.updateModelVectors() self.updateWinner() def setMovingAverage(self): """ Determine moving average. """ self.movingAverage = averageVector(self.buffer.contents) def setMovingAverageDistance(self): """ How close is the moving average to the current inputs? """ self.movingAverageDistance = getDistance([self.movingAverage], self.buffer.contents, self.mask) def setModelVectorsDistance(self): """ How close are the model vectors to the current inputs? """ if len(self.models) != 0: self.modelVectorsDistance = getDistance([v.vector for v in self.models], self.buffer.contents, self.mask) else: self.modelVectorsDistance = self.epsilon + self.delta def updateModelVectors(self): """ Update models vectors with moving average if the moving average is the best model of the inputs. """ if self.movingAverageDistance <= self.epsilon and \ self.movingAverageDistance <= self.modelVectorsDistance - self.delta: self.models.addItem(self.movingAverage) name = self.models.names[-1] self.newModelVector = (name, self.movingAverage) if self.verbosity > 1: print('***Adding model vector***') print('Unique name', name) print('Moving avg dist', self.movingAverageDistance) print('Model vec dist', self.modelVectorsDistance) if self.verbosity > 2: print('New model vector', self.movingAverage) def updateWinner(self): """ Calculate the current winner based on which model vector is closest to the moving average. """ min = [] for m in self.models: min.append(euclideanDistance(m.vector, self.movingAverage, self.mask)) if min == []: self.winner = 'No Winner' else: self.previousWinnerIndex= self.newWinnerIndex self.newWinnerIndex = Numeric.argmin(min) if self.previousWinnerIndex == self.newWinnerIndex: self.winnerCount += 1 else: self.winnerCount = 0 winner = self.models[self.newWinnerIndex] winner.counter += 1 #if winner.maxSize != -1: winner.addItem(self.buffer[0]) self.winner = winner.vector def distanceMap(self): """ Calculate distance map. """ map = [] for x, y in [(x.vector,y.vector) for x in self.models for y in self.models]: map.append(euclideanDistance(x,y,self.mask)) return map def __str__(self): """ To display ravq just call print <instance>. """ s = "" s += "Settings:\n" s += "Delta: " + str(self.delta) + " Epsilon: " + str(self.epsilon) + " Buffer Size: " + str(len(self.buffer)) + "\n" s += "Time: " + str(self.time) + "\n" if self.verbosity > 0: s += "Moving average distance: " + "%4.4f " % self.movingAverageDistance + "\n" s += "Model vectors distance: " + "%4.4f " % self.modelVectorsDistance + "\n" s += "Moving average:\n" s += " " + stringArray(self.movingAverage) s += "Last winning model vector:\n" s += " " + stringArray(self.winner) s += self.bufferString() s += self.modelString() if self.printDistance: s += "Distance map:\n" s += self.distanceMapAsString() if self.verbosity > 0: s += str(self.models) return s def distanceMapAsString(self): return stringArray(self.distanceMap(), 1, len(self.models), format="%4.2f ") def saveRAVQToFile(self, filename): import pickle fp = open(filename, 'w') pickle.dump(self, fp) fp.close() def loadRAVQFromFile(self, filename): import pickle fp = open(filename, 'r') self = pickle.load(fp) # helpful string methods, see __str__ method for use. def modelString(self): s = "" cnt = 0 totalCount = 0 totalIncompatibility = 0.0 for m in self.models: s += ("%4d Model: " % cnt) + stringArray(m.vector) sum = 0.0 for b in m.contents: sum += euclideanDistance(m.vector, b, self.mask) totalIncompatibility += sum s += " Count: %d Buffer size: %d Incompatibility: %f\n" % (m.counter, len(m.contents), sum) totalCount += m.counter cnt += 1 return ("%d Model vectors:\n" % cnt) + s + "Total model vectors : %d\nTotal mapped vectors : %d\nTotal incompatibility: %f\n" % \ (cnt, totalCount, totalIncompatibility) def bufferString(self): s = "Buffer:\n" for array in self.buffer: s += stringArray(array) return s
def addItem(self, vector): tmp = CircularList(self.bucketSize) tmp.vector = vector tmp.counter = 0 CircularList.addItem(self, tmp)
def create_containers(self, user, number, formation_name, cpu_shares, ram, port_list, hostname_scheme, volume_list, docker_image, force_host_server=None): f = Formation(user, formation_name) # Convert ram to bytes from MB ram = ram * 1024 * 1024 # Get the cluster machines on each creation cluster_list = self.get_docker_cluster() circular_cluster_list = CircularList( self.order_cluster_by_load(cluster_list)) # Loop for the requested amount of containers to be created for i in range(1, number + 1): # [{"host_port":ssh_host_port, "container_port":ssh_container_port}] ssh_host_port = 9022 + i ssh_container_port = 22 host_server = circular_cluster_list[i].hostname hostname = '{hostname}{number}'.format(hostname=hostname_scheme, number=str(i).zfill(3)) # First check if we can add this host to salt. If not exit with -1 if self.check_salt_key_used(hostname): self.logger.error( 'Salt key is already taken for {hostname}'.format( hostname=hostname)) sys.exit(-1) # We are being asked to overwrite this if force_host_server: host_server = force_host_server validated_ports = [] while self.check_port_used(host_server, ssh_host_port): ssh_host_port = ssh_host_port + 1 for port in port_list: self.logger.info( "Checking if port {port} on {host} is in use".format( port=port, host=host_server)) if ':' in port: ports = port.split(':') # Only check if the host port is free. The container port should be free while self.check_port_used(host_server, ports[0]): ports[0] = int(ports[0]) + 1 # Add this to the validated port list validated_ports.append( '{host_port}:{container_port}'.format( host_port=str(ports[0]), container_port=str(ports[1]))) else: while self.check_port_used(host_server, port): port = int(port) + 1 validated_ports.append(str(port)) self.logger.info( 'Adding app to formation {formation_name}: {hostname} cpu_shares={cpu} ' 'ram={ram} ports={ports} host_server={host_server} docker_image={docker_image}' .format(formation_name=formation_name, hostname=hostname, cpu=cpu_shares, ram=ram, ports=validated_ports, host_server=host_server, docker_image=docker_image)) f.add_app(None, '{hostname}'.format(hostname=hostname), cpu_shares, ram, validated_ports, ssh_host_port, ssh_container_port, host_server, docker_image, volume_list) # Lets get this party started for app in f.application_list: self.start_application(app) #self.logger.info("Sleeping 2 seconds while the container starts") #time.sleep(2) #self.bootstrap_application(app) self.logger.info("Saving the formation to ETCD") self.save_formation_to_etcd(f)
class RAVQ: """ Implements RAVQ algorithm as described in Linaker and Niklasson. """ def __init__(self, bufferSize, epsilon, delta, vectorSize, historySize=0): self.epsilon = epsilon self.delta = delta self.buffer = CircularList(bufferSize) # moving average buffer self.models = ModelList(historySize) self.mask = None self.time = 0 self.movingAverage = 'No Moving Average' self.movingAverageDistance = -1 self.modelVectorsDistance = -1 self.winner = 'No Winner' self.newWinnerIndex = -1 self.previousWinnerIndex = -1 self.verbosity = 0 self.tolerance = delta self.addModels = 1 self.winnerCount = 0 self.printDistance = 0 self.newModelVector = (None, None) self.mapModelVector = (None, None) self.regions = [] #list of region objects self.prevVec = None self.eventState = False #keep track of start of events #Initialize region for state -1 self.regions.append( Region(vectorSize, vectorSize, [], len(self.models) - 1)) # update the RAVQ def input(self, vec, prevVec=None): """ Drives the ravq. For most uses, the vector categorization is as simple as calling ravq.input(vec) on all vec in the dataset. Accessing the winning model vector (after the buffer is full) can be done directly. Using the get commands after calling input will return any information necessary from the ravq. """ procVec = [i.value for i in vec] for i in range(len(vec)): if math.isnan(vec[i].value): procVec[i] = 0 if self.verbosity > 1: print "Step:", self.time if self.verbosity > 2: print procVec array = Numeric.array(procVec, 'd') if self.mask == None: self.mask = Numeric.ones(len(array), 'd') self.buffer.addItem(array) if self.time >= len(self.buffer): self.process() if self.verbosity > 2: print self self.time += 1 errs = [] if self.prevVec == None: #Either curiosity is off or this is the first vector vec, errs = self.regions[self.newWinnerIndex + 1].inVec(procVec) else: #Process vector using neural net vec, errs = self.regions[self.newWinnerIndex + 1].inVecCuriosity( vec, self.prevVec) return (self.newWinnerIndex, self.winner, vec, errs) # attribute methods def getNewWinner(self): """ Returns boolean depending on whether or not there is a new winner after the last call to input. """ if self.winnerCount > 0: return 0 else: return 1 def setMask(self, mask): """ The mask serves to weight certain components of the inputs in the distance calculations. """ self.mask = Numeric.array(mask, 'd') def getWinnerCount(self): """ Returns the number of times the current winner has been the winner, ie. the number of consecutive calls to input where the current winner has been the winner. """ return self.winnerCount def setVerbosity(self, value): """ Determines which print statements to call. Debugging only. """ self.verbosity = value def setAddModels(self, value): """ Allows the RAVQ to dynamically add model vectors. """ self.addModels = value # process happens once the buffer is full def process(self): """ The RAVQ Algorithm: 1. Calculate the average vector of all inputs in the buffer. 2. Calculate the distance of the average from the set of inputs in the buffer. 3. Calculate the distance of the model vectors from the inputs in the buffer. 4. If distance in step 2 is small and distance in step 3 is large, add current average to list of model vectors. 5. Calculate the winning model vector based on distance between each model vector and the buffer list. 6. Update history. ---The metric used to calculate distance is described in "Sensory Flow Segmentation Using a Resource Allocating Vector Quantizer" by Fredrik Linaker and Lars Niklasson (2000).--- """ self.newModelVector = (None, None) self.setMovingAverage() self.setMovingAverageDistance() self.setModelVectorsDistance() if self.verbosity > 2: print "Moving average:", self.movingAverage if self.verbosity > 1: print "Moving average distance: ", self.movingAverageDistance print "Model vectors distance: ", self.modelVectorsDistance if self.addModels: self.updateModelVectors() self.updateWinner() def setMovingAverage(self): """ Determine moving average. """ self.movingAverage = averageVector(self.buffer.contents) def setMovingAverageDistance(self): """ How close is the moving average to the current inputs? """ self.movingAverageDistance = getDistance([self.movingAverage], self.buffer.contents, self.mask) def setModelVectorsDistance(self): """ How close are the model vectors to the current inputs? """ if len(self.models) != 0: self.modelVectorsDistance = getDistance( [v.vector for v in self.models], self.buffer.contents, self.mask) else: self.modelVectorsDistance = self.epsilon + self.delta def updateModelVectors(self): """ Update models vectors with moving average if the moving average is the best model of the inputs. """ if self.movingAverageDistance <= self.epsilon and \ self.movingAverageDistance <= self.modelVectorsDistance - self.delta: self.models.addItem(self.movingAverage) dims = len(self.models[0].vector) self.regions.append(Region(dims, dims, [], len(self.models) - 1)) name = self.models.names[-1] self.newModelVector = (name, self.movingAverage) if self.verbosity > 1: print '***Adding model vector***' print 'Unique name', name print 'Moving avg dist', self.movingAverageDistance print 'Model vec dist', self.modelVectorsDistance if self.verbosity > 2: print 'New model vector', self.movingAverage def updateWinner(self): """ Calculate the current winner based on which model vector is closest to the moving average. """ min = [] for m in self.models: min.append( euclideanDistance(m.vector, self.movingAverage, self.mask)) if min == []: self.winner = 'No Winner' else: self.previousWinnerIndex = self.newWinnerIndex self.newWinnerIndex = Numeric.argmin(min) if self.previousWinnerIndex == self.newWinnerIndex: self.winnerCount += 1 else: self.winnerCount = 0 winner = self.models[self.newWinnerIndex] winner.counter += 1 #if winner.maxSize != -1: winner.addItem(self.buffer[0]) self.winner = winner.vector def distanceMap(self): """ Calculate distance map. """ map = [] for x, y in [(x.vector, y.vector) for x in self.models for y in self.models]: map.append(euclideanDistance(x, y, self.mask)) return map def __str__(self): """ To display ravq just call print <instance>. """ s = "" s += "Settings:\n" s += "Delta: " + str(self.delta) + " Epsilon: " + str( self.epsilon) + " Buffer Size: " + str(len(self.buffer)) + "\n" s += "Time: " + str(self.time) + "\n" if self.verbosity > 0: s += "Moving average distance: " + "%4.4f " % self.movingAverageDistance + "\n" s += "Model vectors distance: " + "%4.4f " % self.modelVectorsDistance + "\n" s += "Moving average:\n" s += " " + stringArray(self.movingAverage) s += "Last winning model vector:\n" s += " " + stringArray(self.winner) s += self.bufferString() s += self.modelString() if self.printDistance: s += "Distance map:\n" s += self.distanceMapAsString() if self.verbosity > 0: s += str(self.models) return s def distanceMapAsString(self): return stringArray(self.distanceMap(), 1, len(self.models), format="%4.2f ") def saveModelsToFile(self, filename): fp = open(filename, 'w') pick = pickle.Pickler(fp) pick.dump(self.models) fp.close() def loadModelsFromFile(self, filename): fp = open(filename, 'r') unpick = pickle.Unpickler(fp) self.models = unpick.load() fp.close() # helpful string methods, see __str__ method for use. def modelString(self): s = "" cnt = 0 totalCount = 0 totalIncompatibility = 0.0 if self.mask == None: self.mask = Numeric.ones(len(self.models[0].vector), 'd') for m in self.models: s += ("%4d Model: " % cnt) + stringArray(m.vector) sum = 0.0 for b in m.contents: sum += euclideanDistance(m.vector, b, self.mask) totalIncompatibility += sum s += " Count: %d Buffer size: %d Incompatibility: %f\n" % ( m.counter, len(m.contents), sum) totalCount += m.counter cnt += 1 return ("%d Model vectors:\n" % cnt) + s + "Total model vectors : %d\nTotal mapped vectors : %d\nTotal incompatibility: %f\n" % \ (cnt, totalCount, totalIncompatibility) def bufferString(self): s = "Buffer:\n" for array in self.buffer: s += stringArray(array) return s
print('pick up: {}'.format(pick_up)) destination = get_destination(cup_list, pick_up, min_cup, max_cup) if debug: print('destination: {}'.format(destination)) cup_list.insert_at(destination, pick_up) cup_list.rotate() if debug: print() return cup_list puzzle_input = sys.stdin.read().strip() print(puzzle_input) cups = CircularList() for x in puzzle_input: cups.add(int(x)) min_cup = min(cups) max_cup = max(cups) move_number = 1 while move_number <= 100: cups = move(move_number, cups, min_cup, max_cup, False) move_number += 1 print('-- final --') print('cups: {}'.format(cups)) # For final answer, rotate head until 1 is first. while cups._head.data != 1: