def read_out_file(file_path, verbose=False): """Read a graph from an out file.""" graph = Graph() edges = [] # Open file. if verbose: print "Opening file", file_path with open(file_path + '\\out.' + os.path.basename(file_path)) as f: for line in f: if line.startswith('%'): continue edges.append([int(x) for x in line.split()]) # Add all vertices if verbose: print "Adding all vertices" for edge in edges: graph.add_vertex(edge[0], Vertex()) graph.add_vertex(edge[1], Vertex()) # Add all edges for edge in edges: graph.add_edge(edge[0], edge[1]) return graph
def test_can_get_neighbors_of_node(self): G = Graph(self.sample_mappings) spinach = G.get_node_by_name("spinach") spinach_nbrs = G.get_neighbors_of(spinach) assert spinach_nbrs is not None spinach_nbrs_filtered = G.get_neighbors_of(spinach, IngredientType.BASE) assert spinach_nbrs_filtered is not None
def test_can_get_closest_neighbors_of_node(self): G = Graph(self.sample_mappings) spinach = G.get_node_by_name("spinach") spinach_nbrs = G.get_neighbors_of(spinach) # Sort neighbors of spinach from weakest to strongest so # we can then compare the first element of the array with # the array returned from the closest_neighbors() call. spinach_nbrs_weakest = sorted(spinach_nbrs, key=lambda node: node[1]["weight"]) spinach_nbrs_closest = G.closest_neighbors(spinach, 1) assert spinach_nbrs_weakest[0] != spinach_nbrs_closest[0]
def setup(max_outgoing, max_airports): graph = Graph() graph.init_with_data(False, max_outgoing, max_airports, silent=True) # select random start and finish airports src = random.choice(list(graph.airport_dict.values())) while len(src.outgoing_flights) == 0: src = random.choice(list(graph.airport_dict.values())) dest = random.choice(list(graph.airport_dict.values())) while dest.get_code() == src.get_code(): dest = random.choice(list(graph.airport_dict.values())) return src, dest, graph
def GFS(graph: Graph, starting_node_id, target_id, callback, steps_counter): _adjacency_dict = graph.get_adjacency_dict() visited_nodes = list() next = starting_node_id backtrack_index = -1 while next != target_id: steps_counter() # for each node traversal count the steps children = list() # TODO make it an actual list from the 2 conditions if next != None: # if it's not stuck callback(graph.nodes[next]) visited_nodes.append(next) children = [x[0] for x in _adjacency_dict[next]] else: # if it is stuck backtrack_index = -2 # start from the second to last one (the before the stuck) current = visited_nodes[backtrack_index] visited_nodes.append(visited_nodes[backtrack_index]) while not has_unvisited_child(_adjacency_dict, current, visited_nodes): # callback(graph.nodes[current]) backtrack_index -= 2 current = visited_nodes[backtrack_index] visited_nodes.append(visited_nodes[backtrack_index]) callback(graph.nodes[visited_nodes[backtrack_index]]) callback(graph.nodes[current]) children = [x[0] for x in _adjacency_dict[current]] next = get_the_closet_to_target_child(graph, children, target_id, visited_nodes) callback(graph.nodes[target_id])
class Graphene: def __init__(self, parser, renderer): self.parser = parser self.renderer = renderer self._graph = Graph() def load_graph(self): self.parser.parse() nodes = self.parser.nodes self._graph.insert_nodes(nodes) edges = self.parser.edges self._graph.insert_edges(edges) # destroy redudant memory copy of the data self.parser = None def render(self): self.renderer.draw(self._graph)
def _build_models(self): vocab_cutoff = self.dataset.cutoff_vocab( self.config['Trainer']['vocab_clusters']) self.g = Graph(self.config['Model'], self.logger) self._model = LM(self.dataset.vocab_sz, self.config['Model'], self.g, self.logger, vocab_cutoff, self.dataset.embd) self.criterion = ContextLMLoss( self.config['Model']['Feature']['context_sz'], self.logger) self.accuracy_fn = self.criterion.accuracy self._models = {'graph': self.g, 'model': self._model}
def __init__(self, graph: Graph, limits=None): self.graph = graph self.ingredients = graph.get_nodes() self.salad_composition = [] # Override standard limits if supplied. if limits: self.salad_composition_limits = limits self.start_traversal()
def construct_graph(hits, layer_pairs, phi_slope_max, z0_max, feature_names, feature_scale): """Construct one graph (e.g. from one event)""" # Loop over layer pairs and construct segments layer_groups = hits.groupby('layer') segments = [] for (layer1, layer2) in layer_pairs: # Find and join all hit pairs try: hits1 = layer_groups.get_group(layer1) hits2 = layer_groups.get_group(layer2) # If an event has no hits on a layer, we get a KeyError. # In that case we just skip to the next layer pair except KeyError as e: logging.info('skipping empty layer: %s' % e) continue # Construct the segments segments.append(select_segments(hits1, hits2, phi_slope_max, z0_max)) # Combine segments from all layer pairs segments = pd.concat(segments) # Prepare the graph matrices n_hits = hits.shape[0] n_edges = segments.shape[0] X = (hits[feature_names].values / feature_scale).astype(np.float32) Ri = np.zeros((n_hits, n_edges), dtype=np.uint8) Ro = np.zeros((n_hits, n_edges), dtype=np.uint8) y = np.zeros(n_edges, dtype=np.float32) a = np.zeros(n_edges, dtype=np.float32) # We have the segments' hits given by dataframe label, # so we need to translate into positional indices. # Use a series to map hit label-index onto positional-index. hit_idx = pd.Series(np.arange(n_hits), index=hits.index) seg_start = hit_idx.loc[segments.index_1].values seg_end = hit_idx.loc[segments.index_2].values # Now we can fill the association matrices. # Note that Ri maps hits onto their incoming edges, # which are actually segment endings. Ri[seg_end, np.arange(n_edges)] = 1 Ro[seg_start, np.arange(n_edges)] = 1 # Fill the segment labels pid1 = hits.particle_id.loc[segments.index_1].values pid2 = hits.particle_id.loc[segments.index_2].values y[:] = (pid1 == pid2) # Return a tuple of the results return Graph(X, Ri, Ro, y, a)
def __init__(self, in_channels, num_joints, num_frames, num_cls, config): super(AGC_LSTM, self).__init__() self.feat_dim = 256 hidden_size = 512 self.LAMBDA = 0.01 self.BETA = 0.001 self.drop_rate = 0.5 self.graph_layout = config['dataset'] self.graph_strategy = 'spatial' if 'graph_strategy' not in config.keys( ) else config['graph_strategy'] if self.graph_layout == 'ntu': self.parent = [ 1, 20, 20, 2, 20, 4, 5, 6, 20, 8, 9, 10, 0, 12, 13, 14, 0, 16, 17, 18, 22, 20, 7, 11, 11 ] # ntu else: self.parent = [ 0, 0, 0, 0, 0, 0, 1, 6, 7, 2, 9, 10, 3, 12, 13, 4, 15, 16, 5, 18, 19 ] #fpha device = config['device_ids'][0] self.graph = Graph(layout=self.graph_layout, strategy=self.graph_strategy) ADJ = torch.tensor(self.graph.A, dtype=torch.float32, requires_grad=False, device=device) self.register_buffer('ADJ', ADJ) self.pa = config['pa'] if 'pa' in config else 0 self.R_inv = config['rinv'] if 'rinv' in config else False if self.R_inv: self.fc = nn.Sequential( QPU(in_channels * (1 + self.pa), self.feat_dim * 4), AngleAxisMap(dim=-1, rinv=self.R_inv)) else: self.fc = nn.Sequential( QPU(in_channels * (1 + self.pa), self.feat_dim), AngleAxisMap(dim=-1, rinv=self.R_inv)) self.lstm = nn.LSTM(self.feat_dim * 2, hidden_size) self.tap1 = TAP(2, 2) self.agc_lstm1 = AGC_LSTM_layer(hidden_size, hidden_size, self.drop_rate, ADJ) self.tap2 = TAP(2, 2) self.agc_lstm2 = AGC_LSTM_layer(hidden_size, hidden_size, self.drop_rate, ADJ) self.tap3 = TAP(3, 2) self.agc_lstm3 = AGC_LSTM_layer(hidden_size, hidden_size, self.drop_rate, ADJ) self.classifier = nn.Linear(hidden_size, num_cls)
def __init__(self, bins, items, population, evaporation_rate, limit=10000, verbose=False): """Initialise the ACO object with the required parameters.""" self.bins = bins self.items = items self.ants = [Ant() for _ in range(population)] self.best_ant = None self.graph = Graph(len(bins), len(items), evaporation_rate) self.num_paths = 0 self.limit = limit self.verbose = verbose self.ran = False self.runtime = 0 self.avg_fits = []
def _build_models(self): # load frozen graph if not self.graph_ckpt and self.config['Model'].get('Graph') is None: raise Exception( "Must provide a trained graph for downstreaming task") if self.graph_ckpt is not None: graph_hparams = json.load( open('%s/config.json' % self.graph_ckpt, 'r')) self.config['Model']["Graph"] = utils.update_dict( self.config['Model'].get('Graph', {}), graph_hparams['Model']['Graph']) self.config['Model']["n_layers"] = graph_hparams["Model"][ 'n_layers'] self.logger.info("Complete hparams with graph:\n%s" % (json.dumps(self.config['Model'], indent=4))) self._graph = Graph(self.config['Model'], self.logger) if self.graph_ckpt is not None: logger.info("Loading graph from checkpoint %s" % self.graph_ckpt) if self._gpu is None: checkpoint = torch.load( "%s/exprt.ckpt" % self.graph_ckpt, map_location=lambda storage, loc: storage) else: checkpoint = torch.load("%s/exprt.ckpt" % self.graph_ckpt) try: self._graph.load_state_dict(checkpoint['graph']) except Exception as e: self.logger.error(e) self.logger.error("Failed to load graph") # build classifier model self._model = Classifier(self.dataset.vocab_sz, self.config['Model'], self.dataset.n_class, self._graph, self.logger, self.dataset.embd) self.criterion = nn.CrossEntropyLoss() self.accuracy_fn = self.calc_acc self._models = {'model': self._model}
def build(UF): serie_x = lista_dados_anos() title = "Imunização X Mortalidade Tardia" # TÃtulo do gráfico codigo_uf = dataextractionhelper.retorna_codigo_uf(UF) serie_y = processa_dados_imunizacao(codigo_uf, serie_x) serie_y2 = processa_dados_mortalidade_tardia(codigo_uf, serie_x) grafico = Graph(title, serie_x, serie_y, serie_y2, "Anos", "Imunização", "Mortalidade Tardia", uf=UF) return grafico
def build(UF): serie_x = lista_dados_anos() title = "IDH X Taxa de Cesáreos total" codigo_uf = dataextractionhelper.retorna_codigo_uf(UF) serie_y = processa_dados_idh(codigo_uf, serie_x) serie_y2 = processa_dados_cesareos(codigo_uf, serie_x) grafico = Graph(title, serie_x, serie_y, serie_y2, "Anos", "IDH", "Cesareos", uf=UF) return grafico
def build(UF): serie_x = lista_dados_anos() title = "IDH X Taxa de Mortalidade" # TÃtulo do gráfico codigo_uf = dataextractionhelper.retorna_codigo_uf(UF) # Retorna Código UF serie_y = processa_dados_idh(codigo_uf, serie_x) serie_y2 = processa_dados_mortalidade(codigo_uf, serie_x) grafico = Graph(title, serie_x, serie_y, serie_y2, "Anos", "IDH", "Mortalidade", uf=UF) return grafico # Retorna o gráfico
def run(): kaggelFaceDataSets = FaceDataSets(fp=data_fp) kaggelFaceDataSets.load(mode='train', fn=data_fn_train) # kaggelFaceDataSets.load(mode='test', fn=data_fn_train) x_train, x_test, y_train, y_test = train_test_split( kaggelFaceDataSets.x_train, kaggelFaceDataSets.y_train, test_size=0.3) x_test, x_val, y_test, y_val = train_test_split(x_test, y_test, test_size=0.5) data = { 'train': { 'x': x_train, 'y': y_train }, 'val': { 'x': x_val, 'y': y_val }, 'test': { 'x': x_test, 'y': y_test } } net = Net(dropout=True, num_output=num_keypoints, num_conv=3, num_fc=2) graph_model = Graph(input_shape=[image_size, image_size, num_channels], output_shape=[num_keypoints], net=net) loss_calculator = lossCalculator(mode=loss_mode) trainer = Trainer(graph_model=graph_model, epochs=epochs, batch_size=batch_size, logdir='%s/train' % data_fp, save_path='%s/save' % data_fp) trainer.train(data=data, loss_calculator=loss_calculator)
def BFS(graph: Graph, starting_node_id, callback, steps_counter): """ Do a BFS over a graph NOTE: callback is a function that gets called after each node being visited NOTE: callback is expected to take a Node object only as an argument """ visited_nodes = set() adjacency_dict = graph.get_adjacency_dict() nodes_queue = [starting_node_id] while len(nodes_queue): node = nodes_queue.pop(0) # remove the first element, FIFO if node not in visited_nodes: visited_nodes.add(node) connections = adjacency_dict.get(node) nodes_list = [node] nodes_list.extend(connections) callback(nodes_list) steps_counter() if connections: for connection in connections: # add the to index to nodes queue nodes_queue.append(connection[0])
class TestTraverser: mappings = create_mappings("./data") G = Graph(mappings) def test_init(self): t = Traverser(self.G) assert t is not None def test_default_and_custom_limits(self): t = Traverser(self.G) assert t.get_limits() == default_limits t = Traverser(self.G, custom_limits) assert t.get_limits() == custom_limits def test_limit_helpers(self): t = Traverser(self.G) # Check default limits are computed properly. assert t._can_add_more(IngredientType.BASE) is True assert t._needs_more(IngredientType.BASE) is True ing_base_pasta = self.G.get_node_by_name("pasta") ing_base_spinach = self.G.get_node_by_name("spinach") # Add one base to the composition. Default limits says we can have a # minimum of one base and a maximum of two, so _can_add_more() should # be True as we have not reached the maximum, but _needs_more() should # be False as we've reached the minimum. t.add_ingredient_to_composition(ing_base_pasta) assert t._can_add_more(IngredientType.BASE) is True assert t._needs_more(IngredientType.BASE) is False # Add another base to the composition. We now should have reached the # maximum allowed by the default limits. t.add_ingredient_to_composition(ing_base_spinach) assert t._can_add_more(IngredientType.BASE) is False assert t._needs_more(IngredientType.BASE) is False def test_composition_filtering(self): t = Traverser(self.G) assert t.get_composition() == [] # Add some ingredients to the salad ing_tomato = self.G.get_node_by_name("tomato") ing_chicken = self.G.get_node_by_name("chicken") t.add_ingredient_to_composition(ing_tomato) assert t.get_composition() == [ing_tomato] t.add_ingredient_to_composition(ing_chicken) assert t.get_composition() == [ing_tomato, ing_chicken] # See if filtering works properly filtered_composition = \ t._filter_composition_on_ingredient_type(IngredientType.TOPPING) assert filtered_composition == [ing_tomato] filtered_composition = \ t._filter_composition_on_ingredient_type(IngredientType.PROTEIN) assert filtered_composition == [ing_chicken] # The instance variable shouldn't be mutated through filtering. assert t.get_composition() == [ing_tomato, ing_chicken]
def build_graph(file_path): vertices_number = int(file_path.readline()) # Reading first line with a number of weights vertices = [] g = Graph() while vertices_number > 0: line = file_path.readline() distance = re.split('->|, |:|',line.strip('\n').replace(" ", "")) # Adding vertices if distance[0] not in vertices: vertices.append(distance[0]) g.set_vertex(distance[0]) if distance[1] not in vertices: vertices.append(distance[1]) g.set_vertex(distance[1]) g.set_edge(distance[0] ,distance[1], distance[2]) vertices_number -=1 # Reading start and destination point line = file_path.readline() route = re.split('->',line.strip('\n').replace('route', ' ').replace(" ", "")) if route[0] and route[1] in vertices: g.set_start(route[0]) g.set_finish(route[1]) line = file_path.readline() nearby = re.split(',',line.strip('\n').replace('nearby', ' ').replace(" ", "")) # Reading time to reach closest destiation points for start vertex g.set_nearby(nearby[0], nearby[1]) else: g.set_error("Not possible to find a route") return g
def __init__(self, parser, renderer): self.parser = parser self.renderer = renderer self._graph = Graph()
class ACO(object): """This class holds all relevant infomation for objects required for running the ACO algorithm. ... Attributes ---------- bins : Bin a bin object that holds items and a total weight. items : array(int) an array of integers representing the weights of items. ants : array(Ant) an array of Ant objects to be controlled during the algorithms run. best_ant : Ant an ant object - the best ant of the final generation of a algorithm run. graph : Graph a graph object to store the pheromone weights. num_paths : int the number of routes evaluated. limit : int the maximum number of evaluations allowed. verbose : boolean whether or not to print to the console when log() is called. ran : boolean has the ACO been run. runtime : float time duration of the last run. avg_fits : array(float) the timeseries of average fitnesses over each cycle. Methods ------- summary() prints a summary of the last run if there is one. stats() returns the best fitness and time elapsed over last run if there is one. run() runs the ACO algorithm. explore() runs one cycle of route creation and evaporation. ant_run(ant) reset the ant and recreate its route. create_route(ant) create a route through the graph of pheromones. route_step(prev_bin, item) return a step from the current bin to the next bin position. route_fitness() calculate the fitness for the current bin configuration. set_champion() set the best ant for the current generation. empty_bins() reset all bins. log(message) prints to the console if verbose is true. graph_averages() create a graph using the data from avg_fits. """ def __init__(self, bins, items, population, evaporation_rate, limit=10000, verbose=False): """Initialise the ACO object with the required parameters.""" self.bins = bins self.items = items self.ants = [Ant() for _ in range(population)] self.best_ant = None self.graph = Graph(len(bins), len(items), evaporation_rate) self.num_paths = 0 self.limit = limit self.verbose = verbose self.ran = False self.runtime = 0 self.avg_fits = [] def summary(self): """Print a summary of the last run if there is one.""" if hasattr(self, 'ran') and self.ran: print("Run was successful and took %d seconds." % int(self.runtime)) print("--- Best fitness: %d" % self.best_ant.fitness) print("--- Best bin config:") for i, b in enumerate(self.best_ant.bins): print("%4d. %s" % (i + 1, b)) def stats(self): """Return the best fitness achieved in the final generation and the time taken to run the ACO""" if hasattr(self, 'ran') and self.ran: return self.best_ant.fitness, self.runtime def run(self): """Runs a full ACO run.""" self.log("--- Starting ACO Run ---") self.ran = False self.best_fits = [] self.avg_fits = [] start_time = time() while self.num_paths < self.limit: self.explore() self.set_champion() self.ran = True self.runtime = time() - start_time def explore(self): """Create a route for all ants and evaporate the graph.""" self.ants = [*map(self.ant_run, self.ants)] best = None for ant in self.ants: ant.lay_pheromones(self.graph) fitnesses = [ant.fitness for ant in self.ants] self.best_fits.append(min(fitnesses) / sum(self.items)) self.avg_fits.append(sum(fitnesses) / len(fitnesses)) self.graph.evaporate() def ant_run(self, ant): """Reset the bins and create a route for the given ant.""" self.empty_bins() ant = self.create_route(ant) ant.bins = self.bins.copy() return ant def create_route(self, ant): """Calculate a route through the pheromone graph.""" prev_bin = 0 ant.route = [] for item in enumerate(self.items): prev_bin, item = self.route_step(prev_bin, item) ant.route.append((prev_bin, item)) ant.fitness = self.route_fitness() self.num_paths += 1 return ant def route_step(self, prev_bin, item): """Get the index of the next bin to place the item in.""" column = self.graph.graph[prev_bin][item[0]].tolist() total = sum(column) threshold = total * random() current = 0.0 for index, weight in enumerate(column): if current + weight >= threshold: self.bins[index].add_item(item[1]) return index, item[0] current += weight def route_fitness(self): """Calculate the fitness of the current bin configuration.""" max_weight = self.bins[0].total_weight min_weight = self.bins[0].total_weight for b in self.bins: if b.total_weight > max_weight: max_weight = b.total_weight if b.total_weight < min_weight: min_weight = b.total_weight return max_weight - min_weight def set_champion(self): """Allocate the best ant of the generation to the best_ant.""" for ant in self.ants: if self.best_ant and ant.fitness < self.best_ant.fitness: self.best_ant = ant.copy() elif not self.best_ant: self.best_ant = ant.copy() def empty_bins(self): """Resets the bin configuration.""" [b.empty() for b in self.bins] def log(self, message): """Prints a message to the console if verbose is true.""" if self.verbose: print(message) def graph_averages(self): """Output a graph to the user based on the values in avg_fits""" plt.plot(self.avg_fits) plt.show()
y0 = np.array(pid1 == pid2).astype(int) y = np.append(y, y0) dr_all.extend(dr) dphi_all.extend(dphi) dz_all.extend(dz) dR_all.extend(dR) #print(y) #print(segs_in) #print(segs_out) print(y[y > 0.5].shape[0] / n_truth_edges) print(y[y > 0.5].shape[0] / y.shape[0]) feature_scale = np.array([1000., np.pi, 1000.]) X = (hits[['r', 'phi', 'z']].values / feature_scale).astype(np.float32) n_hits, n_edges = X.shape[0], segs_out.shape[0] Ri = np.zeros([n_hits, n_edges], dtype=np.uint8) Ro = np.zeros([n_hits, n_edges], dtype=np.uint8) Ri[segs_in.astype(np.uint8), np.arange(n_edges)] = 1 Ro[segs_out.astype(np.uint8), np.arange(n_edges)] = 1 #Ra = np.zeros([4, n_edges], dtype=np.uint8) Ra = np.stack((dr_all / feature_scale[0], dphi_all / feature_scale[1], dz_all / feature_scale[2], dR_all)) filename = os.path.join(outdir, evt_id) graph = Graph(X, Ra, Ri, Ro, y) save_graph(graph, filename) print(filename)
import sys sys.path.append("..") from models.ingredient import Ingredient, IngredientType from models.graph import Graph from preprocessing.main import create_mappings from traversal.traverser import Traverser if __name__ == "__main__": mappings = create_mappings("../data") g = Graph(mappings) t = Traverser(g)
from models.graph import Graph import re edge_pattern = re.compile( r'Step (\w) must be finished before step (\w) can begin.') def get_first_star(graph): print("First star:", ''.join(map(str, graph.topsort()))) def get_second_star(graph): print("Second star:", graph.transporter(5)) def prepare_graph(data, graph): for edge in data: from_node, to_node = edge_pattern.search(edge).groups() graph.add_edge(from_node, to_node) if __name__ == "__main__": with open('data.txt', 'r') as f: data = f.read().split('\n') graph = Graph() prepare_graph(data, graph) get_first_star(graph) get_second_star(graph)
def DFS(graph: Graph, starting_node_id): """ Do a DFS over a graph """ target_node_ids = [node.id for node in graph.nodes if node.is_target()] adjacency_dict = graph.get_adjacency_dict() return lazyDFS_many(starting_node_id, target_node_ids, adjacency_dict)
for s in tEdges.students: # likewise, here. If already infected, does nothing infect(v[s]) teachers = collections.deque(sorted(teachers, key=lambda x: scounts[x])) """ """Simple utility to consolidate actions associated with adding an edge to the KA user graph""" def add_edge(graph, visual, edge_start, edge_end): graph.connect(edge_start, edge_end) visual.graph.add_edge(edge_start, edge_end) if __name__ == "__main__": names = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s"] ids = list(range(1,20)) g = Graph() visual = Infection_Visual() for i in range(len(names)): g.add_user(names[i], ids[i], i) visual.graph.add_node(names[i]) choice = int(raw_input("Input test case number: ")) if choice == 1: add_edge(g, visual, "a","b") add_edge(g, visual, "b","d") visual.draw() #total_infection(g, "b") pdb.set_trace() limited_infection(g, "b", 5) elif choice == 2:
def construct_graph(hits, layer_pairs, phi_slope_max, z0_max, feature_names, feature_scale, evtid="-1", remove_intersecting_edges = False): """Construct one graph (e.g. from one event)""" t0 = time.time() # Loop over layer pairs and construct segments layer_groups = hits.groupby('layer') segments = [] seg_dr, seg_dphi, seg_dz, seg_dR = [], [], [], [] for (layer1, layer2) in layer_pairs: # Find and join all hit pairs try: hits1 = layer_groups.get_group(layer1) hits2 = layer_groups.get_group(layer2) # If an event has no hits on a layer, we get a KeyError. # In that case we just skip to the next layer pair except KeyError as e: logging.info('skipping empty layer: %s' % e) continue # Construct the segments selected, dr, dphi, dz, dR = select_segments(hits1, hits2, phi_slope_max, z0_max, layer1, layer2, remove_intersecting_edges=remove_intersecting_edges) segments.append(selected) seg_dr.append(dr) seg_dphi.append(dphi) seg_dz.append(dz) seg_dR.append(dR) # Combine segments from all layer pairs segments = pd.concat(segments) seg_dr, seg_dphi = pd.concat(seg_dr), pd.concat(seg_dphi) seg_dz, seg_dR = pd.concat(seg_dz), pd.concat(seg_dR) # Prepare the graph matrices n_hits = hits.shape[0] n_edges = segments.shape[0] X = (hits[feature_names].values / feature_scale).astype(np.float32) Ra = np.stack((seg_dr/feature_scale[0], seg_dphi/feature_scale[1], seg_dz/feature_scale[2], seg_dR)) #Ra = np.zeros(n_edges) Ri = np.zeros((n_hits, n_edges), dtype=np.uint8) Ro = np.zeros((n_hits, n_edges), dtype=np.uint8) y = np.zeros(n_edges, dtype=np.float32) # We have the segments' hits given by dataframe label, # so we need to translate into positional indices. # Use a series to map hit label-index onto positional-index. hit_idx = pd.Series(np.arange(n_hits), index=hits.index) seg_start = hit_idx.loc[segments.index_1].values seg_end = hit_idx.loc[segments.index_2].values print(seg_start) print(seg_end) # Now we can fill the association matrices. # Note that Ri maps hits onto their incoming edges, # which are actually segment endings. Ri[seg_end, np.arange(n_edges)] = 1 Ro[seg_start, np.arange(n_edges)] = 1 # Fill the segment, particle labels pid = hits.particle_id unique_pid_map = {pid_old: pid_new for pid_new, pid_old in enumerate(np.unique(pid.values))} pid_mapped = pid.map(unique_pid_map) print(pid_mapped) pid1 = hits.particle_id.loc[segments.index_1].values pid2 = hits.particle_id.loc[segments.index_2].values y[:] = (pid1 == pid2) # Correct for multiple true barrel-endcap segments layer1 = hits.layer.loc[segments.index_1].values layer2 = hits.layer.loc[segments.index_2].values true_layer1 = layer1[y>0.5] true_layer2 = layer2[y>0.5] true_pid1 = pid1[y>0.5] true_pid2 = pid2[y>0.5] true_z1 = hits.z.loc[segments.index_1].values[y>0.5] true_z2 = hits.z.loc[segments.index_2].values[y>0.5] pid_lookup = {} for p, pid in enumerate(np.unique(true_pid1)): pid_lookup[pid] = [0, 0, -1, -1] l1, l2 = true_layer1[true_pid1==pid], true_layer2[true_pid2==pid] z1, z2 = true_z1[true_pid1==pid], true_z2[true_pid2==pid] for l in range(len(l1)): barrel_to_LEC = (l1[l] in [0,1,2,3] and l2[l]==4) barrel_to_REC = (l1[l] in [0,1,2,3] and l2[l]==11) if (barrel_to_LEC or barrel_to_REC): temp = pid_lookup[pid] temp[0] += 1 if abs(temp[1]) < abs(z1[l]): if (temp[0] > 1): print("adjusting y:", temp) print("new temp = (", temp[0], abs(z1[l]), l1[l], l2[l]) print("old y:", y[(pid1==pid2) & (pid1==pid) & (layer1==temp[2]) & (layer2==temp[3])]) y[(pid1==pid2) & (pid1==pid) & (layer1==temp[2]) & (layer2==temp[3])] = 0 print("new y:", y[(pid1==pid2) & (pid1==pid) & (layer1==temp[2]) & (layer2==temp[3])]) temp[1] = abs(z1[l]) temp[2] = l1[l] temp[3] = l2[l] #print("new temp=", temp) pid_lookup[pid] = temp print("took {0} seconds".format(time.time()-t0)) print("X.shape", X.shape) print("Ri.shape", Ri.shape) print("Ro.shape", Ro.shape) print("y.shape", y.shape) print("Ra.shape", Ra.shape) print("pid.shape", pid_mapped.shape) return Graph(X, Ra, Ri, Ro, y, pid_mapped)
from load_data import LoadData from models.graph import Graph prelim = input("\"load\" or \"open\"\n") graph = Graph() max_outgoing = int(input("Enter max # of outgoing flights per airport: ")) if prelim == 'load': graph.init_with_data(True, max_outgoing, max_airports=4) else: graph.init_with_data(False, max_outgoing, max_airports=4) while True: try: src_code = input("Src Airport Code: ") src_airport = graph.get_airport(src_code.upper()) src_airport.print_flights() dest_code = input("Dest Airport Code: ") dest_airport = graph.get_airport(dest_code.upper()) dest_airport.print_flights() start_time = int(input('Start Time (as a seconds timestamp): ')) from algorithm import FlightOptimizer, FlightNoptimizer print("\nBETTER") fo = FlightOptimizer(src_airport, dest_airport, start_time) fo.find_best_path(graph)
def construct_graph(hits, layer_pairs, phi_slope_max, z0_max, feature_names, feature_scale): """Construct one graph (e.g. from one event)""" # Loop over layer pairs and construct segments layer_groups = hits.groupby('layer') segments = [] for (layer1, layer2) in layer_pairs: try: hits1 = layer_groups.get_group(layer1) hits2 = layer_groups.get_group(layer2) except KeyError as e: logging.info('skipping empty layer: %s' % e) continue # Start with all possible pairs of hits keys = ['evtid', 'particle_id', 'r', 'phi', 'z'] hit_pairs = hits1[keys].reset_index().merge(hits2[keys].reset_index(), on='evtid', suffixes=('_1', '_2')) hit_pairs = hit_pairs[hit_pairs.index_1 != hit_pairs.index_2] #print("Adding hit_pairs:", hit_pairs[['index_1', 'index_2']].head(200)) # Compute line through the points dphi = calc_dphi(hit_pairs.phi_1, hit_pairs.phi_2) dz = hit_pairs.z_2 - hit_pairs.z_1 dr = hit_pairs.r_2 - hit_pairs.r_1 dR = np.sqrt(dr**2 + dz**2) phi_slope = dphi / dr z0 = hit_pairs.z_1 - hit_pairs.r_1 * dz / dr # Filter segments according to criteria good_seg_mask = (phi_slope.abs() < phi_slope_max) & (z0.abs() < z0_max) if (layer1 == layer2): good_seg_mask = (good_seg_mask & (dR < 24)) #good_seg_mask = (good_seg_mask & (dphi > 0)) hit_pairs = hit_pairs[['index_1', 'index_2']][good_seg_mask] if (layer1 == layer2): hit_pairs['adjacent'] = 0 else: hit_pairs['adjacent'] = 1 # Construct the segments segments.append(hit_pairs) # Combine segments from all layer pairs segments = pd.concat(segments) # Prepare the graph matrices n_hits = hits.shape[0] n_edges = segments.shape[0] X = (hits[feature_names].values / feature_scale).astype(np.float32) Ri = np.zeros((n_hits, n_edges), dtype=np.uint8) Ro = np.zeros((n_hits, n_edges), dtype=np.uint8) y = np.zeros(n_edges, dtype=np.float32) # We have the segments' hits given by dataframe label, # so we need to translate into positional indices. # Use a series to map hit label-index onto positional-index. hit_idx = pd.Series(np.arange(n_hits), index=hits.index) seg_start = hit_idx.loc[segments.index_1].values seg_end = hit_idx.loc[segments.index_2].values a = hit_idx.loc[segments.adjacent].values #print("seg_start", seg_start) #print("seg_end", seg_end) #print("adjacencies", a) # Now we can fill the association matrices. # Note that Ri maps hits onto their incoming edges, # which are actually segment endings. Ri[seg_end, np.arange(n_edges)] = 1 Ro[seg_start, np.arange(n_edges)] = 1 # Fill the segment labels pid1 = hits.particle_id.loc[segments.index_1].values pid2 = hits.particle_id.loc[segments.index_2].values y[:] = (pid1 == pid2) # Return a tuple of the results return Graph(X, Ri, Ro, y, a)
from models.graph import Graph from network_graph import app import networkx as nx with app.test_request_context(): g = Graph() g.graph.add_node('Joe') g.graph.add_node('Tim') g.graph.add_node('Lesley') g.graph.add_node('Tony') g.graph.add_node('Jack') g.graph.add_edge('Joe', 'Lesley', weight=15) g.graph.add_edge('Joe', 'Tony', weight=5) g.graph.add_edge('Tony', 'Tim', weight=10) g.graph.add_edge('Tim', 'Jack', weight=20) #print nx.to_numpy_matrix(g.graph) #print nx.adjacency_matrix(g.graph).todense() nodes = g.graph.nodes() header = '' for n in nodes: header += '\t{}\t'.format(n) print header for y in nodes: line = '' for i, x in enumerate(nodes): line += '{}\t\t{} '.format(y if i == 0 else '', nx.dijkstra_path_length(g.graph, x, y) ) print '{}\n'.format(line)
def create_control_flow_graph( program_lines: List[str], basic_block_leader_statements: List[Statement] ) -> Graph[BasicBlock]: basic_blocks: List[BasicBlock] = [] for block_id, (current_leader_statement, next_leader_statement) in enumerate( zip_longest(basic_block_leader_statements, basic_block_leader_statements[1:]), 1, ): if next_leader_statement: basic_block_statements = filter( lambda line_pair: ( line_pair[0] >= current_leader_statement.line_num and line_pair[0] < next_leader_statement.line_num ), enumerate(program_lines, 1), ) else: basic_block_statements = filter( lambda line_pair: (line_pair[0] >= current_leader_statement.line_num), enumerate(program_lines, 1), ) basic_blocks.append( BasicBlock( block_id=block_id, statements=[ Statement(line_num, text) for line_num, text in basic_block_statements ], ) ) graph: Graph[BasicBlock] = Graph() basic_block_by_label: Dict[str, BasicBlock] = dict() for basic_block in basic_blocks: graph.add_node(basic_block) if is_label_statement(basic_block.leader_statement.text): label = extract_label(basic_block.leader_statement.text) basic_block_by_label[label] = basic_block for current_basic_block, next_basic_block in zip_longest( basic_blocks, basic_blocks[1:] ): if is_branch_statement(current_basic_block.last_statement.text): branch_target = extract_branch_target( current_basic_block.last_statement.text ) graph.add_edge(current_basic_block, basic_block_by_label[branch_target]) elif is_goto_statement(current_basic_block.last_statement.text): goto_target = extract_goto_target(current_basic_block.last_statement.text) graph.add_edge(current_basic_block, basic_block_by_label[goto_target]) if next_basic_block: if not is_goto_statement(current_basic_block.last_statement.text): graph.add_edge(current_basic_block, next_basic_block) return graph
from os.path import dirname from flask import Flask, redirect, render_template, url_for from models.graph import Graph MYDIR = dirname(__file__) app = Flask(__name__) app.secret_key = 'dawoe90r2j3z8sd982jdsa' IMAGES_MAX_AGE = 0 graph = Graph.from_json('input/graph.json') @app.route('/') def index(): return render_template('index.html', num_vertices=graph.num_vertices(), num_edges=graph.num_edges(), num_vertex_pairs=graph.num_vertex_pairs(), num_adverbs=graph.num_adverbs()) @app.route('/choose-adjectives') def choose_adjectives(): return redirect(url_for('view_adjectives', src_adj='happy', size=100)) @app.route('/view-adjectives/<src_adj>/<size>') def view_adjectives(src_adj, size):
import pyodbc import os # Initializing app app = Flask(__name__) app.config.from_object(Configuration) cors = CORS(app) app.config['CORS_HEADERS'] = 'WeDeal' # Initializing data base conexion server = os.environ.get('DB_HOST') database = os.environ.get('DB_NAME') username = os.environ.get('DB_USER') password = os.environ.get('DB_PASS') url_conexion = 'DRIVER={ODBC Driver 17 for SQL Server};SERVER=' + server + ';DATABASE=' + database + ';UID=' + username + ';PWD=' + password + '' # Initializing Graph G = Graph('test', 'version1') # Initializing User List userslist = Users_list() # Routes @app.route('/', methods=['GET']) @cross_origin() def init(): return "Welcome to We deal, this api is only available to We Deal developers" @app.route('/user/<id_user>', methods=['GET']) @cross_origin() def predict_user(id_user): """ This route responses with a prediction based on user's work area