def test_average_distance_path_calculation(self): cities = [[1, 1], [1, 3], [3, 3], [3, 1]] algorithm = Algorithm(cities) population = [[1, 2, 3, 4], [1, 3, 2, 4], [1, 4, 2, 3]] #distance [8, 9,65... , 9,65...] average = algorithm.get_average_distance_path(population) self.assertEqual(average, 9)
def run(): time_series = defaultdict(list) algoInstance = Algorithm() # Everyday job base = datetime.datetime(2019, 1, 1) date_list = [ base + datetime.timedelta(hours=x) for x in range((24 * 30 * 5) + 13) ] di = collections.defaultdict(int) # time_series = {} for t in date_list: start = t.strftime("%Y-%m-%d %H:%M:%S") end = (t + datetime.timedelta(hours=1)).strftime("%Y-%m-%d %H:%M:%S") dictionary = getEdges(start, end) counter = 0 # print(dictionary) for key, row in dictionary.items(): counter = counter + 1 key = row[0] + '---' + row[1] time_series_expected[key].append(row[2]) #for plotting: time serie # print('Processing (#', counter, ') - ', start, ' ', key, '---', row[2]) algoInstance.feed(key, row[2]) print('*************************** Analysis Done')
def __init__(self, cities, scale_x, scale_y, algorithm_type): """ initializes objects :param cities: cities :param scale_x: scale x to draw cities with scale :param scale_y: scale y to draw cities with scale :param algorithm_type: algorithm type, if 1 - Genetic, if 2 - Greedy """ #RESOLUTION# self.res = (1400, 800) #SCREEN# self.screen = '' #ALGORITHM# self.algorithm = Algorithm(cities) #SCALES# self.scale_x = scale_x self.scale_y = scale_y #CITY SIZE# self.size = 8 #BACKGROUND# self.bg = '' #PathDistances# self.path_distances = [] #Type of Algorithm# self.algorithm_type = algorithm_type #AVG distance of population in generations# self.avg_distance = [] #distance and number of population self.ver = ""
def main(size, popsize): """ Make a horse happy by guiding it to a path on the chessboard in such a way that it moves to every single square once and only once. The little horsie can jump obviously only in the classic L shape (the chess’ horse move). Generate random permutations of chess board squares Find best individual Show statistics :param size: Size of the chess board :param popsize: Size of population """ print("Running") tuples = [] popl = [] for i in range(size): for j in range(size): tuples.append((i, j)) for i in range(popsize): random.shuffle(tuples) individ = Individual(size, deepcopy(tuples)) popl.append(deepcopy(individ)) finpop = population(popsize, popl, size) algo = Algorithm(size, finpop) evaluation, fitness, iter = algo.run() #statistics plt.plot(range(iter), fitness, label='BestFitness vs iteration') plt.xlabel('Iteration') plt.ylabel('BestFitness') plt.title("BestFitness evolution") plt.legend() plt.show()
def __init__(self, grids, sep='\n'): """ Constructor of the class Keyword arguments: grids -- string whit grid of the sudoku to resolve, 81 non-blank chars e.g "00302060.. sep -- each file of 9 should be sep for '\n' """ self.digits = '123456789' # Valid digits of sudoku grid will contain. self.rows = 'ABCDEFGHI' # Each row of the sudoku grid will contain. self.cols = self.digits # Each col of sudoku grid will contain. # Each square of sudoku grid, 9 squares per sudoku e.g 'A3' self.squares = self.crossProduct(self.rows, self.cols) # List of units in the sudoku e.g. ['A1','B1','C1','D1','E1','F1','G1','H1','I1'] self.unitlist = ([self.crossProduct(self.rows, c) for c in self.cols] + [self.crossProduct(r, self.cols) for r in self.rows] + [self.crossProduct(rs, cs) for rs in ('ABC','DEF','GHI')\ for cs in ('123','456','789')]) # Each unit of sudoku into a dictionary e.g ['A1','B1',...,'I1'] self.units = dict((s, [u for u in self.unitlist if s in u])\ for s in self.squares) # Each square has 20 peers self.peers = dict((s, set(sum(self.units[s],[]))-set([s]))\ for s in self.squares) self.resultString = " " # Constructor of the class algorithm Algorithm.__init__(self, grids.strip().split(sep))
def __init__(self, grids, sep='\n'): """ Constructor of the class Keyword arguments: grids -- the string data of the sudoku without resoved.e.g "00302060...." sep -- each file of 9 should be sep for '\n' """ self.digits = '123456789' # Valid digits of sudoku grid will contain. self.rows = 'ABCDEFGHI' # Each row of the sudoku grid will contain. self.cols = self.digits # Each col of sudoku grid will contain. # Each square of sudoku grid, 9 squares per sudoku e.g 'A3' self.squares = self.crossProduct(self.rows, self.cols) # List of units in the sudoku self.unitlist = ([self.crossProduct(self.rows, col) for col in self.cols] + [self.crossProduct(row, self.cols) for row in self.rows] + [self.crossProduct(rs, cs) for rs in ('ABC', 'DEF', 'GHI')\ for cs in ('123', '456', '789')]) # Each unit of sudoku into a dictionary e.g ['A1','B1',...,'I1'] self.units = dict((square, [unit for unit in self.unitlist if square in unit])\ for square in self.squares) # Each square has 20 peers self.peers = dict((square, set(sum(self.units[square], []))\ -set([square])) for square in self.squares) # Constructor of the class algorithm Algorithm.__init__(self, grids.strip().split(sep))
def genDatapointsLabels(self, filepath): algo_obj = Algorithm(self.num_machines) for i in range(self.num_data_points): # randomly pick the probability of edge formation for this particular graph prob_edge = random.uniform(self.min_prob_edge, self.max_prob_edge) # generate a dag and get the topologically sorted list of nodes mat, topo_sorted_list = self.genAdjMatrix(prob_edge, self.num_jobs_arr[i]) # find the best algorithm for this particular dag best_alg = algo_obj.findBestAlgo(mat, self.job_time_arr[i]) # generate feature vector - min., max., avg. in degree; min, max, avg. out degree; min path length, max path length, max. job time, min. job time, avg. job time features = self.genFeatVector(mat, self.num_jobs_arr[i], self.job_time_arr[i], topo_sorted_list) # append the newly created feature vector and the best alg. index to the training data self.training_data.append(features + [self.num_jobs_arr[i]] + [prob_edge] + [best_alg]) writeCSV(self.training_data, [ 'min. in deg', 'max. in deg', 'min. out deg', 'max. out deg', 'avg. deg', 'min job time', 'max job time', 'avg. job time', 'min path', 'max path', 'num_jobs', 'prob_edge', 'label' ], filepath)
def __init__(self): Algorithm.__init__(self) self.MLAlgorithmService = MLAlgorithmService(self) self.image=Image(self.baseURL() + "services/kMeansPictures/lenna.png",Width="320px", Height="360px") self.resultImage=Image("",Width="320px", Height="360px") self.loadingImage = Image(self.baseURL() + "images/blanksearching.gif") self.calculateButton = Button("RUN", self.onButtonClick) self.log = Button("SHOW LOG", self.openLogFile) self.log.setEnabled(False) self.image.addLoadListener(self) topPanel = DockPanel() topPanel.setVerticalAlignment(HasAlignment.ALIGN_MIDDLE) topPanel.add(self.calculateButton, DockPanel.WEST) topPanel.add(self.loadingImage, DockPanel.CENTER) topPanel.add(self.log, DockPanel.EAST) panel = DockPanel() panel.setHorizontalAlignment(HasAlignment.ALIGN_CENTER) panel.setVerticalAlignment(HasAlignment.ALIGN_MIDDLE) #panel.add(HTML("<h2>Image compression</h2>", True)) panel.add(topPanel, DockPanel.NORTH) panel.add(self.image, DockPanel.WEST) panel.add(self.resultImage, DockPanel.EAST) panel.setWidth("100%") self.initWidget(panel) self.image.setStyleName("ks-images-Image") self.calculateButton.setStyleName("ks-images-Button") self.loadImage("picturem.png")
def __init__(self): Algorithm.__init__(self) self.MLAlgorithmService = MLAlgorithmService(self) self.image = Image(self.baseURL() + "services/kMeansPictures/lenna.png", Width="320px", Height="360px") self.resultImage = Image("", Width="320px", Height="360px") self.loadingImage = Image(self.baseURL() + "images/blanksearching.gif") self.calculateButton = Button("RUN", self.onButtonClick) self.log = Button("SHOW LOG", self.openLogFile) self.log.setEnabled(False) self.image.addLoadListener(self) topPanel = DockPanel() topPanel.setVerticalAlignment(HasAlignment.ALIGN_MIDDLE) topPanel.add(self.calculateButton, DockPanel.WEST) topPanel.add(self.loadingImage, DockPanel.CENTER) topPanel.add(self.log, DockPanel.EAST) panel = DockPanel() panel.setHorizontalAlignment(HasAlignment.ALIGN_CENTER) panel.setVerticalAlignment(HasAlignment.ALIGN_MIDDLE) #panel.add(HTML("<h2>Image compression</h2>", True)) panel.add(topPanel, DockPanel.NORTH) panel.add(self.image, DockPanel.WEST) panel.add(self.resultImage, DockPanel.EAST) panel.setWidth("100%") self.initWidget(panel) self.image.setStyleName("ks-images-Image") self.calculateButton.setStyleName("ks-images-Button") self.loadImage("picturem.png")
def __init__(self, objective_fun=None, start_pop=None, population_filename=None, plot_data=False, time_eval=False, sigma=DEFAULT_SIGMA, lbd=None, mean=None): Algorithm.__init__(self, objective_fun, start_pop, population_filename, plot_data, time_eval) self.sigma = sigma self.m = mean self.lbd = lbd self.mu = None self.weights = None self.mu_w = None self.cc = None self.cs = None self.c1 = None self.cmu = None self.d_s = None self.chiN = None if self.population and self.point_dim: self.init_default_parameters()
def __init__(self, objective_fun=None, start_pop=None, population_filename=None, plot_data=False, time_eval=False, mean=None, lbd=None, hist_size=None, path_len=None): Algorithm.__init__(self, objective_fun, start_pop, population_filename, plot_data, time_eval) self.m = mean self.lbd = lbd self.mu = None self.weights = None self.weights_pop = None self.mu_eff = None self.cc = None self.cp = None self.Ft = None self.c_Ft = None self.path_len = path_len self.path_ratio = None self.hist_size = hist_size if self.population and self.point_dim: self.init_default_parameters()
def test2(self): x = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) algo = Algorithm(x) count_islands = algo.RunSearch() assert count_islands == 0
def test10(self): x = None algo = Algorithm(x) try: algo.ValidateInputs() except Exception as e: assert str(e) == "Incorrect inputs. 2 dimensional matrix required"
def main(): print("\nTesting: \n") tests() print( "\nThe tests are finished. This is a bigger example and here is the input:\n" ) algo = Algorithm("data.txt", "param.in", True) algo.run()
def run_statistics(self): results = [] for _ in range(30): algorithm = Algorithm(self.problem) results.append(algorithm.run().fitness) print("Average fitness: {}".format(statistics.mean(results))) print("Standard deviation of fitness: {}".format( statistics.stdev(results)))
def __init__(self): Algorithm.__init__(self) text = "<div class='infoProse'>This is the Machine Learning Algorithms page. " text += "It demonstrates ... ." text += "<p>This sample also demonstrates ta-ta-ta: </p></div>" self.initWidget(HTML(text, True))
def __init__(self): Algorithm.__init__(self) text="<div class='infoProse'>This is the Machine Learning Algorithms page. " text+="It demonstrates ... ." text+="<p>This sample also demonstrates ta-ta-ta: </p></div>" self.initWidget(HTML(text, True))
def test8(self): x = np.array([[1, 1, 1, 0, 0], [1, 1, 0, "a", 0], [0, 0, 1, "bcd", 0], [0, 0, 0, 1, 1]]) algo = Algorithm(x) try: algo.ValidateInputs() except Exception as e: assert str(e) == "Incorrect inputs. Only 0s and 1s required!"
def test_algorithm_process(): """geomag.Algorithmtest.test_algorithm_process() confirms that algorithm.process returns an obspy.core.stream object """ algorithm = Algorithm() timeseries = Stream() outputstream = algorithm.process(timeseries) assert_is_instance(outputstream, Stream)
def configure(self, arguments): """Configure algorithm using comand line arguments. Parameters ---------- arguments: Namespace parsed command line arguments """ Algorithm.configure(self, arguments) self.statefile = arguments.adjusted_statefile self.load_state()
def test_algorithm_channels(): """geomag.Algorithmtest.test_algorithm_channels() confirms that algorithm.get_input_channels returns the correct channels confirms that algorithm.get_output_channels returns the correct channels """ inchannels = ['H', 'E', 'Z', 'F'] outchannels = ['H', 'D', 'Z', 'F'] algorithm = Algorithm(inchannels=inchannels, outchannels=outchannels) assert_equals(algorithm.get_input_channels(), inchannels) assert_equals(algorithm.get_output_channels(), outchannels)
def __init__(self): self.algorithm = Algorithm() self.conn = lite.connect(os.path.join(main_dir,'Quora.db')) self.cur = self.conn.cursor() self.cur.execute('''select id,question1,question2 from test''') rows = self.cur.fetchall() for row in rows: answer = self.algorithm.apply(row[1],row[2]) self.ApplyChangeInDatabase(row[0],answer) self.conn.commit() self.conn.close()
def Main(): try: matrix = ReadInputs() algo = Algorithm(matrix) algo.ValidateInputs() except Exception as e: print("Error in inputs:" + str(e)) sys.exit(1) count_islands = algo.RunSearch() print("Number of islands is: " + str(count_islands)) sys.exit(0)
class Scheduler(): def __init__(self): self.tickNo = 1 self.dbm = DataManager() self.algo = Algorithm(self.dbm) self.rCon = redis.Redis(host='localhost', port=6379, db=0) def run(self): while True: self.algo.execute(self.tickNo) time.sleep(5) self.tickNo = self.tickNo + 1
def __init__(self, matrix=None, pier_correction=None, statefile=None, data_type=None, location=None): Algorithm.__init__(self, inchannels=('H', 'E', 'Z', 'F'), outchannels=('X', 'Y', 'Z', 'F')) # state variables self.matrix = matrix self.pier_correction = pier_correction self.statefile = statefile self.data_type = data_type self.location = location if (matrix is None): self.load_state()
def usa_90(): print( "Problem minimalizacji kosztu dla sieci amerykanskiej z 2 sieczkami predefiniowanymi i 90 demand na kazdym" ) print("Chromosomy: " + str(Parameters.amount_of_chromosomes_usa)) print("Przepustowosc: " + str(OpticalFibersCapacity.L96.value)) network = Network.Network.generate_network_with_admissible_paths( 'Resources/net-us.xml') chromosome_creator = ChromosomeCreator() chromosome_utils = ChromosomeUtils() chromosomes = chromosome_creator.generate_chromosomes_usa_90( network, Parameters.amount_of_chromosomes_usa) # algorithm = Algorithm(chromosomes, network) # chromosomes = algorithm.pick_bests(chromosomes, chromosome_utils.get_network_transponders_cost, # Parameters.amount_of_chromosomes_usa, Parameters.optical_fiber_capacity_usa) algorithm = Algorithm(chromosomes, network) chromosomes = algorithm.algorithm_usa_90( Parameters.optical_fiber_capacity_usa) print(algorithm.results) plot_gen = PlotGenerator([[algorithm.results, 'g--']]) plot_gen.show_plot() best_chromosome = algorithm.pick_bests_sorted( chromosomes, chromosome_utils.get_network_transponders_configuration_cost, 1, Parameters.optical_fiber_capacity_usa)[0] for key in sorted(best_chromosome.paths_dict): print("{} -> ".format(key)) for demand, path, transponders in zip( best_chromosome.paths_demand[key], best_chromosome.paths_dict[key], best_chromosome.transponders_used[key]): print("{} {}".format( demand, chromosome_utils.get_transponders_configuration_cost( transponders)), end="") print("{} {} ".format(path, transponders)) print() t1, t2, t3 = 0, 0, 0 for key in sorted(best_chromosome.paths_dict): for transponders in best_chromosome.transponders_used[key]: t1 += transponders[0] t2 += transponders[1] t3 += transponders[2] print("10:{} 40:{} 100:{}".format(t1 * 2, t2 * 2, t3 * 2)) return algorithm.results, algorithm.time_elapsed, best_chromosome
def __init__(self, grids): """ Constructor method for the BacktrackingAlgorithm child class. Keyword arguments: grids -- String which contains the unsolved game, it should have 81 characters, all of them digits 0-9, for example: "008009320000080040900500007000040090000708000060020000600001008050030000072900100" """ Algorithm.__init__(self, grids) self.puzzle = [] self.blanks = [] self.runningTime = 0
def main(): algorithm = Algorithm() optimalIndividual = algorithm.run() print('Result: The detected minimum cost is ' + str(optimalIndividual.getFitness())) print("For:" + str(optimalIndividual.getChromosome())) mean, standardDeviation = algorithm.statistics(30) print("Mean:%3.9f " % mean) print("Standard deviation:%3.9f " % standardDeviation) bestFitnessList = algorithm.statisticsForPlot() plt.plot(bestFitnessList) plt.show()
def __init__( self, ID = 'Reader', filelist = list(), **kwargs ): ''' Initialize with an ID, a list of the files to be read and, optionally, other keyword arguments that will be used by other methods. ''' Algorithm.__init__( self, ID ) self.Files = list(filelist) if hasattr( filelist, '__iter__' ) else [filelist] self.Nfiles = len(self.Files) self.Ifile = 0 self.Ievt = 0 self.Nread = 0 self.File = None self.EOF = '__EOF__' self.kwargs = kwargs
def run_algorithm(): # empty the Descriptors, Keypoints and Results folders first for f in os.listdir(app.config['DESCRIPTORS_FOLDER']): os.remove(os.path.join(app.config['DESCRIPTORS_FOLDER'], f)) for f in os.listdir(app.config['KEYPOINTS_FOLDER']): os.remove(os.path.join(app.config['KEYPOINTS_FOLDER'], f)) for f in os.listdir(app.config['RESULTS_FOLDER']): os.remove(os.path.join(app.config['RESULTS_FOLDER'], f)) algorithm = Algorithm() result = algorithm.run_algorithm() if result == "success": resp = jsonify({'message': 'Algorithm successfully run'}) resp.status_code = 200 return resp
def run(self): self.iterations = 0 if not self.is_initialized() and self.lbd: self.gen_random_population(size=self.lbd) elif not self.is_initialized(): self.gen_random_population() prev_best = self.sel_best() mean_time = 0 if self.time_eval else None # MAIN LOOP while not self.check_end_cond(prev_best): if self.time_eval: payload = self.evaluate_single_iteration_with_time() prev_best = payload['data'] mean_time += payload['time'] else: prev_best = self.single_iteration() if mean_time is not None: mean_time = mean_time / self.iterations return Algorithm.Result(best_point=self.sel_best(), end_reason=self.end_reason, mean_iteration_time=mean_time, iteration_num=self.iterations)
def __init__(self, objective_fun=None, start_pop=None, population_filename=None, plot_data=False, time_eval=False, f=DEFAULT_F, cr=DEFAULT_CR, lbd=None): Algorithm.__init__(self, objective_fun, start_pop, population_filename, plot_data, time_eval) self.H = start_pop # NUMPY ARRAY OF VECTORS self.cr = cr # FLOAT - parameter for crossover self.f = f # FLOAT self.lbd = None
def __init__(self): super().__init__() timer = QTimer(self) timer.setInterval(20) # interval in ms timer.timeout.connect(self.update) timer.start(0) self.title= "Emergency Response System" self.top=100 self.left=100 self.width=500 self.height=500 #button = QPushButton('button', self) #button.move(0,0) #button.clicked.connect(self.on_click) CarMaintainer() Algorithm() self.InitWindow()
def __init__(self): print("Main start") # set a candidate snake FitnessFunction.setKey( self, "1111000000000000000000000000000000000000000000000000000000001111") # create initial Nest myPop = Nest(50, True) # evolve out Nest until we reach an optimum gencount = 0 while myPop.getFittest().get_fitness() < FitnessFunction.getMaxFitness( self): gencount += 1 print("#" * 128) print("generation: ", gencount, " Fittest: ", myPop.getFittest().get_fitness()) self.print_snake(myPop) print("_" * 128) myPop = Algorithm.evolve_pop(myPop) print("*" * 128) print("Snake found") print("generation: ", gencount) self.print_snake(myPop) print("*" * 128)
def explore(self): start = time.time() while True: # Only update the UPDATED GRIDS, based on the sensor reading updatedGrids = self.robot.readSensors(self.completeMap) for n in updatedGrids: x, y = n[0], n[1] self.ui.drawGrid(x, y) # This checking must be done here because if not, there will be one extra ROBOT drawing (including one moveForward()) # If the checking is done in ui.drawRobot(), the moveForward() cannot be prevented although the robot should have stopped already before moving forward if self.ui.checkTimeout() == False or self.ui.setMapPercentage() == False: break initialState = State(copy.deepcopy(self.robot)) actions = Algorithm.A_star(initialState) for action in actions: r = self.robot.do(action) if r == False: break self.ui.drawRobot() # Only update the UPDATED GRIDS, based on the sensor reading updatedGrids = self.robot.readSensors(self.completeMap) for n in updatedGrids: x, y = n[0], n[1] self.ui.drawGrid(x, y) end = time.time() print("RUNNING TIME:", end - start)
def configure(self, arguments): """Configure algorithm using comand line arguments. Parameters ---------- arguments: Namespace parsed command line arguments """ Algorithm.configure(self, arguments) self.alpha = arguments.sqdist_alpha self.beta = arguments.sqdist_beta self.gamma = arguments.sqdist_gamma self.m = arguments.sqdist_m self.mag = arguments.sqdist_mag self.statefile = arguments.sqdist_statefile self.load_state()
def start_algorithm(scheduleInfoId): conn = _mssql.connect(server=Constants.SERVER_IP, user=Constants.USER, password=Constants.PASSWORD, database=Constants.DATABASE) conn.execute_query('SELECT * FROM Edu_Semesters_ScheduleInfo WHERE ID = %d', scheduleInfoId) semesterId = 0 isBachelor = True yearOfAdmission = '' for row in conn: j = json.loads(row['Settings']) semesterId = j['semesterId'] isBachelor = j['isBachelor'] yearOfAdmission = j['yearsOfAdmission'] helper = DatabaseHelper(semesterId, yearOfAdmission, isBachelor, scheduleInfoId) times = helper.getTimes() days = helper.getDays() [c, ad_options] = helper.readSettings() # c.set_voenka_day(3) # c.set_bekturova_day(4) print c.toString() rooms = helper.getRooms() teachers = helper.getTeachers() students = helper.getStudents() courses = helper.getCourses() courseClasses = helper.getCourseClasses() # print 'Length1: ', len(courseClasses) courseClasses = helper.createCourseClasses() # print 'Length2: ', len(courseClasses) if len(courseClasses) > 0: roomReservations = helper.getRoomReservations() conf = Configuration(rooms, teachers, courses, courseClasses, roomReservations, ad_options, times, days) conn.execute_non_query( 'UPDATE Edu_Semesters_ScheduleInfo SET StatusID = 2 WHERE ID = %d', scheduleInfoId) s = Schedule(10, 3, 70, 10, c, conf) a = Algorithm(100, 10, 5, s, scheduleInfoId) a.Start() else: conn.execute_non_query( 'UPDATE Edu_Semesters_ScheduleInfo SET StatusID = 3 WHERE ID = %d', scheduleInfoId)
def __init__(self,codes): self.fitness = 0 self.active = True self.positionx = 20 self.positiony = 300 self.speed=0 self.direction=0 self.algo = Algorithm(codes)
def loadAlgorithms(self,filename): listalg = open(filename,'r') if os.path.dirname(os.path.abspath(self.ConfigPath['DB']))+'/AlgorithmsDB': os.remove(self.ConfigPath['prefix']+self.ConfigPath['DB']+'/AlgorithmsDB') self.algorithm= shelve.open(self.ConfigPath['prefix']+self.ConfigPath['DB']+'/AlgorithmsDB') alg=None self.algorithm = shelve.open(self.ConfigPath['prefix']+self.ConfigPath['DB']+'/AlgorithmsDB') for line in listalg: line= line.strip() line= line.strip('\n') line= line.strip(' ') line= line.replace('"','') line= line.replace(' ','') data=line.split(':')[0] if (data=='algorithms'): flag=True continue if line == '': continue if (line == (data+':')): if (flag): flag=False alg=Algorithm(data) continue self.algorithm[alg.Name]=alg alg = Algorithm(data) continue else: if(data=='keys'): for keys in line.split(':')[1].split(','): alg.properties[data].append(keys) else: alg.properties[data] = str(line.split(':')[1]) self.algorithm[alg.Name]=alg self.algorithm.close()
class car: accelmult = 1 dirmult = 0.1 def __init__(self,codes): self.fitness = 0 self.active = True self.positionx = 20 self.positiony = 300 self.speed=0 self.direction=0 self.algo = Algorithm(codes) def draw(self): pass def update(self,obstacles): x = 0 y = 0 min = 2000 for z in obstacles: temp = z.distance() if temp<min: x = z.horizontal y = z.vertical min = temp inputs = [] inputs.append(self.positionx) inputs.append(self.positiony) inputs.append(self.direction) inputs.append(self.speed) inputs.append(x) inputs.append(y) self.algo.update(inputs) self.speed += accelmult * self.algo.getAccel() self.direction += dirmult * self.algo.getDir() self.positionx += self.speed * math.sin(self.direction) self.positiony += self.speed * math.cos(self.direction) def checkcollision(self,obs): return obs.distance(self.positionx,self.positiony) < obs.radius def getCodes(self): return self.algo.getCodes()
def __init__(self, alpha=None, beta=None, gamma=None, phi=1, m=1, yhat0=None, s0=None, l0=None, b0=None, sigma0=None, zthresh=6, fc=0, hstep=0, statefile=None, mag=False): Algorithm.__init__(self, inchannels=None, outchannels=None) self.alpha = alpha self.beta = beta self.gamma = gamma self.phi = phi self.m = m self.zthresh = zthresh self.fc = fc self.hstep = hstep self.statefile = statefile self.mag = mag # state variables self.yhat0 = yhat0 self.s0 = s0 self.l0 = l0 self.b0 = b0 self.sigma0 = sigma0 self.last_observatory = None self.last_channel = None self.next_starttime = None self.load_state()
def main(): d = Data(computeSamples = False) trainIndices, testIndices = d.splitData() algo = Algorithm(d.getTrainSample(), d.getTestSample()) # algo.computeRegressionInput() # algo.predictXGboost() algo.predictNN() # algo.predict() algo.writeSubmission() print(algo.evalPrecision())
def __init__(self, input, weight, relax, sort='+', name="PushRight-RelaxLeft"): Algorithm.__init__(self, input, weight, relax, sort, name)
# Create the initial random population my_pop = Population(10000, True) # Loop until number of generations is complete generation_count = 0 while my_pop.fitness_of_the_fittest() < FitnessCalc.get_max_fitness(): generation_count += 1 # Output the best solution every 100 generations if generation_count % 100 == 0: print("Outputting Current Status") my_pop.OutputFittest() # Quit after a set number of generations if generation_count == 500: break # Output current generation data and produce next generation print("Average Fitness : %s" % my_pop.get_average_fitness()) print("Generation : %s Fittest : %s " % (generation_count, my_pop.fitness_of_the_fittest())) my_pop = Algorithm.evolve_population(my_pop) print("******************************************************") # Output algorithm run time finish = time() print ("Time elapsed : %s " % (finish - start)) # Output the best solution found my_pop.OutputFittest()
def __init__(self, informat=None, outformat=None): Algorithm.__init__(self, inchannels=CHANNELS[informat], outchannels=CHANNELS[outformat]) self.informat = informat self.outformat = outformat
def __init__(self,codes): self.positionx = 20 self.positiony = 300 self.speed=0 self.direction=0 self.algo = Algorithm(codes)
def __init__(self, input, weight, relax, sort='+', name="RelaxLeft-OnUsage"): Algorithm.__init__(self, input, weight, relax, sort, name)
def __init__(self, input, weight, sort="+", name="PushRight"): Algorithm.__init__(self, input, weight, 0, sort, name)
'MAX_FEATURES' : 20, # Number of features to use; or factors 'DEFAULT_FEATURE_VALUE': 0.1, # Initialization value for features 'SQR_INIT' : 0.01, # DEFAULT_FEATURE_VALUE * DEFAULT_FEATURE_VALUE 'MAX_EPOCHS' : 50, # Max epochs per feature 'MIN_EPOCHS' : 1, 'MAX_MOVIES' : 1683, # Movies in entire training set (+1) 'MAX_USERS' : 944, # Users in entire training set (+1) 'MAX_RATINGS' : 100001, # Ratings in entire training set (+1) 'TRAINING_DATASET' : 'dataset/u1.base', 'TEST_DATASET' : 'dataset/u1.test', 'RECORD_RESULTS_TO_SQL': True, } ] if __name__ == "__main__": print 'Machine Details:' print ' Platform ID: %s' % platform.platform() print ' Executable: %s' % sys.executable print ' Python: %s' % platform.python_version() print ' Compiler: %s' % platform.python_compiler() for i, params in enumerate(params_suite): print "-----------------------------------------------------------------------------------------" print " Running training ", i print "-----------------------------------------------------------------------------------------" train = Algorithm(params) train.run()
def __init__(self, informat='obs'): Algorithm.__init__(self, inchannels=CHANNELS[informat], outchannels=['G']) self._informat = informat
def tsbtnPlay_click(self, sender, event_args): self._treeView1.Nodes.Clear() del self._list_of_files[0:] #delete all files in list of files self._find_files(self._directory_path,self._list_of_files) #finds all files recursively in the given path if len(self._list_of_files) == 0: #although doesn't work, but was meant to give an error message if no path selected MessageBox.Show("No files were found in the specified directory","Empty Dataset",MessageBoxButtons.OK,MessageBoxIcon.Exclamation) else: data_type = '' #to pass as an argument, to tell what type of data is in file listing #extracting features from the files can be based on #frequent two word phrases #only words #noun and verbs feature_extraction = FeatureExtraction(self._list_of_files) if self._rbFrequentPhrases.Checked: self._file_listing = feature_extraction.get_bag_of_frequent_phrases() data_type = 'frequent_phrases' elif self._rbCommonWordsRepeat.Checked: self._file_listing = feature_extraction.get_bag_of_words() data_type = 'bag_of_words' elif self._rbNounVerbs.Checked: self._file_listing = feature_extraction.get_bag_of_nouns_verbs() data_type = 'noun_verb' #for key in self._file_listing: # MessageBox.Show(str(self._file_listing[key])) document_representation = DocumentRepresentation(self._file_listing) if self._rbDefault.Checked: self._similarity_table = document_representation.get_similarity_matrix(representation = 'bow', data=data_type) elif self._rbVectorSpaceModel.Checked: self._similarity_table = document_representation.get_similarity_matrix(representation = 'vsm', data=data_type) for key in self._file_listing: self._unordered_filelist.append(key) algorithm = Algorithm(self._similarity_table,self._unordered_filelist, self._list_of_files) if self._rbHAC.Checked: self._cluster_set = algorithm.hierarchical_agglomerative_clustering() lst = algorithm.get_clusters_by_max_purity() #MessageBox.Show(str(self._cluster_set)) #MessageBox.Show(str(lst)) self._all_clusters = algorithm.get_clusters_at_all_levels() try: EvaluationMainObject = Evaluation() EvaluationMainObject.SetCluterList(lst) EvaluationMainObject.SetValueOfR() EvaluationMainObject.SetDocumentDictionary(self._list_of_files) EvaluationMainObject.CalculateIndividualPurity() purity = EvaluationMainObject.GetTotalPurity() EvaluationMainObject.CalculateEntropy() entropy = EvaluationMainObject.GetTotalEntropy() self._add_list_items(str(purity),str(entropy)) except DivideByZeroException: MessageBox.Show("Division By Zero") self._populate_tree(lst)
def __init__(self, input, weight, name="PushLeft"): Algorithm.__init__(self, input, weight, 0, '-', name)
def __init__(self, informat='obs', outformat='geo'): Algorithm.__init__(self, inchannels=CHANNELS[informat], outchannels=CHANNELS[outformat]) self._informat = informat self._outformat = outformat