def p_type(p): '''type : TYPENAME | typename''' if (isinstance(p[1], str)) : p[0] = c.Node('type', [], p[1]) else: p[0] = c.Node('type', [p[1]])
def p_term(p): '''term : identifier | LEFT_PARENS operation args RIGHT_PARENS''' if (len(p) == 2) : p[0] = c.Node('term', [p[1]]) else : p[0] = c.Node('term', [p[2], p[3]])
def p_rhs(p): '''rhs : BOOLEAN | uinteger_10 | identifier | LEFT_PARENS primitive rhs_args RIGHT_PARENS | LEFT_PARENS operation rhs_args RIGHT_PARENS''' if len(p) == 2: p[0] = c.Node('rhs', [p[1]]) else : p[0] = c.Node('rhs', [p[2], p[3]])
def make_tray_edges(): global tray_edges tray_edges = [] for tray in range(inputs.TRAYS): for hole in range(inputs.HOLES): for t in range(inputs.HORIZON): # WITHOUT DIAGONAL EDGES # node_from = classes.Node('hole', tray, hole, t) node_to = classes.Node('hole', tray, hole, t + 1) edge = Edge(node_from, node_to, get_bounds_per_edge(tray, t, plants_array.plants), get_sizes_per_edge(tray, t, plants_array.plants)) tray_edges.append(edge)
def make_tray_edges(): number_tray_edges = 0 global tray_edges tray_edges = [] for modules_type in range(inputs.NB_TYPE_MODULE): for t in range(inputs.HORIZON): node_from = classes.Node('modules', modules_type, t) node_to = classes.Node('modules', modules_type, t + 1) edge = Edge( node_from, node_to, get_bounds_per_edge(modules_type, t, plants_array.plants), get_sizes_per_edge(modules_type, t, plants_array.plants)) tray_edges.append(edge) number_tray_edges += 1 print("number_tray_edges:", number_tray_edges)
def p_equations(p): '''equations : equation equations | empty''' if (len(p) == 2) : p[0] = p[1] else : p[0] = c.Node('equations', [p[1], p[2]])
def p_primitive(p): '''primitive : NOT | SPECIAL_PRIMITIVE | STAR | PLUS | MINUS''' p[0] = c.Node('primitive', [], p[1])
def p_operation_spec2(p): '''operation_spec2 : ARROW type | arg_types ARROW type''' if len(p) == 3 : p[0] = p[2] else : p[0] = c.Node('operation-spec-args', [p[1], p[3]])
def p_args(p): '''args : term args | empty''' if (len(p) == 2) : p[0] = p[1] else : p[0] = c.Node('args', [p[1], p[2]])
def p_rhs_args(p): '''rhs_args : rhs rhs_args | empty''' if (len(p) == 2) : p[0] = p[1] else : p[0] = c.Node('rhs_args', [p[1], p[2]])
def get_nature(self): url = self.base_url + '[natural=*]' logging.info(url) root = self.get_data(url) #empty node dict nodes = {} natures = [] for child in root: if child.tag == 'node': #nodes should be at the top geo = ndb.GeoPt(child.attrib['lat'], child.attrib['lon']) node = classes.Node(geo_point=geo) nodes.update({child.attrib["id"]: node}) elif child.tag == 'way': way_nodes = [] subname = "" subtype = "" for way_child in child: # logging.info(child.tag) if way_child.tag == 'nd': #save node rederence in order way_nodes.append( copy.copy(nodes[way_child.attrib['ref']])) # logging.info(nodes[child.attrib['ref']]) #this covers coastline, wetland, beach, etc etc elif way_child.attrib['k'] == 'natural': subtype = way_child.attrib['v'] logging.info(subtype) #this covers parks (in-city) elif way_child.attrib['k'] == 'leisure': subtype = way_child.attrib['v'] logging.info(subtype) elif way_child.attrib['k'] == 'name': subname = way_child.attrib['v'] logging.info(subname) #grab the required nodes and create the entity for idx, way_node in enumerate(way_nodes): way_node.idx = idx #create the nature nature = classes.Nature(nodes=way_nodes, subtype=subtype, subname=subname, parent=self.ghash_entity.key, id=child.attrib["id"]) #push the nature onto the array natures.append(nature) #store the array in the db ndb.put_multi(natures) #return the count return len(natures)
def get_roads(self): url = self.base_url + '[highway=*]' logging.info(url) root = self.get_data(url) #empty node dict nodes = {} roads = [] for child in root: if child.tag == 'node': #nodes should be at the top geo = ndb.GeoPt(child.attrib['lat'], child.attrib['lon']) node = classes.Node(geo_point=geo) nodes.update({child.attrib["id"]: node}) elif child.tag == 'way': way_nodes = [] subtype = "" subname = "" for way_child in child: # logging.info(child.tag) if way_child.tag == 'nd': #save node rederence in order way_nodes.append( copy.copy(nodes[way_child.attrib['ref']])) # logging.info(nodes[child.attrib['ref']]) elif way_child.attrib['k'] == 'highway': subtype = way_child.attrib['v'] logging.info(subtype) elif way_child.attrib['k'] == 'name': subname = way_child.attrib['v'] logging.info(subname) #grab the required nodes and create the entity for idx, way_node in enumerate(way_nodes): way_node.idx = idx #create the road road = classes.Road(nodes=way_nodes, subtype=subtype, subname=subname, parent=self.ghash_entity.key, id=child.attrib["id"]) #push the road onto the array roads.append(road) #store the array in the db ndb.put_multi(roads) #return the count return len(roads)
def make_transfer_edges(): global transfer_edges transfer_edges = [] for plant in plants_array.plants: plant_type = plant[0] for i in range(len(plant_type.transfers) - 1): from_ = plant_type.transfers[i] to_ = plant_type.transfers[i + 1] t = plant_type.transfer_days[i][1] + plant[1] for hole in range(inputs.HOLES): node_from = classes.Node('hole', from_, hole, t) for hole_to in range(inputs.HOLES): node_to = classes.Node('hole', to_, hole_to, t + 1) edge = Edge( node_from, node_to, get_bounds_per_edge(to_, t, plants_array.plants), get_sizes_per_edge(to_, t, plants_array.plants)) transfer_edges.append(edge)
def make_transfer_edges(): number_transfer_edges = 0 global transfer_edges transfer_edges = [] for plant in plants_array.plants: plant_type = plant[0] for i in range(len(plant_type.transfers) - 1): from_ = plant_type.transfers[i] to_ = plant_type.transfers[i + 1] t = plant_type.transfer_days[i][1] + plant[1] node_from = classes.Node('module', from_, t) node_to = classes.Node('module', to_, t + 1) edge = Edge(node_from, node_to, get_bounds_per_edge(to_, t, plants_array.plants), get_sizes_per_edge(to_, t, plants_array.plants)) transfer_edges.append(edge) number_transfer_edges += 1
def make_source_edges(): number_source_edges = 0 global source_edges source_edges = [] for plant in plants_array.plants: plant_type = plant[0] tray = plant_type.transfers[0] bounds = {p: 1 * (p == plant) for p in plants_array.plants} source = meta_nodes[get_plant_type(plant_type)][0] node_to = classes.Node('module', tray, plant[1]) edge = Edge(source, node_to, bounds, 0) source_edges.append(edge) number_source_edges += 1
def make_source_edges(): global source_edges source_edges = [] for plant in plants_array.plants: plant_type = plant[0] tray = plant_type.transfers[0] bounds = {p: 1 * (p == plant) for p in plants_array.plants} source = meta_nodes[get_plant_type(plant_type)][0] for hole in range(inputs.HOLES): node_to = classes.Node('hole', tray, hole, plant[1]) edge = Edge(source, node_to, bounds, 0) source_edges.append(edge)
def generate_successors(node): print "\n\n\n" attr_list = list(node.attribute_list) if len(attr_list) == 0 or m.pure_check(node.data, class_attribute): leaf_label = m.pure_check(node.data, class_attribute) if not leaf_label: leaf_label = random.choice(attribute_label_set[class_attribute]) print "-------Leaf 노드입니다.-------" node.label = leaf_label # 데이터가 있는 경우와 없는 경우 구분 if len(node.data) != 0: for data in node.data: print data print "라벨은 " + leaf_label else: print "데이터가 없으므로 랜덤으로 배정합니다." print "라벨은 " + leaf_label print "---------------------------" return node else: # 최적의 attribute값을 찾는 로직 필요. selected_attribute = m.splitting_criteria_decision( node.data, attr_list, class_attribute) # selected_attribute = random.choice(attr_list) # 현재 노드의 분류 기준 세팅 node.set_current_node_criteria(selected_attribute) print "노드 분류 기준 " + node.classifying_attribute print "남은 분류 기준 " + str( attr_list) + "중에 " + selected_attribute + " 선택!" # 해당 attribute의 라벨 종류를 가져온다. labels_of_selected_attribute = attribute_label_set[selected_attribute] print '해당 attribtute의 라벨 종류 가져오기' print labels_of_selected_attribute for label in labels_of_selected_attribute: data = m.filter(node.data, selected_attribute, label) new_node = classes.Node(attr_list, selected_attribute, data) print "분류 기준이 " + selected_attribute + "이고 그 값이 " + label + "인 데이터 노드 생성" if generate_successors(new_node): node.children[label] = new_node print 'node.children' print node.children return node
def make_sink_edges(): global sink_edges sink_edges = [] for plant in plants_array.plants: plant_type = plant[0] size_tray = len(plant_type.transfers) tray = plant_type.transfers[size_tray - 1] bounds = {p: 1 * (p == plant) for p in plants_array.plants} sink = meta_nodes[get_plant_type(plant_type)][1] for hole in range(inputs.HOLES): node_from = classes.Node('hole', tray, hole, plant[1] + plant_type.total_days) edge = Edge(node_from, sink, bounds, 0) sink_edges.append(edge)
def make_sink_edges(): number_sink_edges = 0 global sink_edges sink_edges = [] for plant in plants_array.plants: plant_type = plant[0] size_tray = len(plant_type.transfers) tray = plant_type.transfers[size_tray - 1] bounds = {p: 1 * (p == plant) for p in plants_array.plants} sink = meta_nodes[get_plant_type(plant_type)][1] node_from = classes.Node('module', tray, plant[1] + plant_type.total_days) edge = Edge(node_from, sink, bounds, 0) sink_edges.append(edge) number_sink_edges += 1
def make_source_edges(): number_source_edges = 0 global source_edges source_edges = [] for plant in plants_array.plants: plant_type = plant[0] module_type = plant_type.transfers[0] bounds = {p: 1*(p == plant) for p in plants_array.plants} source = meta_nodes[get_plant_type(plant_type)][0] for module_number in range(inputs.MODULES[module_type]): node_to = classes.Node('module', module_type, module_number, plant[1]) edge = Edge(source, node_to, bounds, 0) source_edges.append(edge) number_source_edges +=1 print("number_source_edges:", number_source_edges)
def make_sink_edges(): number_sink_edges = 0 global sink_edges sink_edges = [] for plant in plants_array.plants: plant_type = plant[0] size_module_type = len(plant_type.transfers) module_type = plant_type.transfers[size_module_type - 1] bounds = {p: 1*(p == plant) for p in plants_array.plants} sink = meta_nodes[get_plant_type(plant_type)][1] for module_number in range(inputs.MODULES[module_type]): node_from = classes.Node('module', module_type, module_number, plant[1] + plant_type.total_days) edge = Edge(node_from, sink, bounds, 0) sink_edges.append(edge) number_sink_edges += 1 print("number_sink_edges:", number_sink_edges)
def create_AGDS(filename): [data, columns] = dataParser.read_xls_iris(filename) nr_samples = data.shape[0] nr_attributes = data.shape[1] # Create objects samples = [] for sample_nr in range(nr_samples): samples.append(classes.Sample(name=str(sample_nr), nodes=[])) # Create attributes and nodes attributes = [] for category in range(nr_attributes): nodes = [] unique_values = np.unique(data[:, category]) for node in range(len(unique_values)): # New node nodes.append( classes.Node(attribute=None, value=unique_values[node], samples=[])) # Indexes of objects whose value matches this node sample_indexes = np.where(data[:, category] == unique_values[node])[0] for sample in range(len(sample_indexes)): # Adding the objects to the node nodes[-1].add_objects(samples[sample_indexes[sample]]) # Adding the node to the object samples[sample_indexes[sample]].add_nodes(nodes[-1]) # New attribute attributes.append( classes.Attribute(name=columns[category], nodes=nodes)) for i in range(len(nodes)): nodes[i].attribute = attributes[-1] return classes.Tree(tree_type='AGDS', attributes=attributes, samples=samples)
def create_node(ws, data): node = classes.Node(ws, data["payload"]["name"]) nodes[node.id] = node return node
def beFGS(problem): """Searches the nodes with the lowest f scores first. The function f(node) is the heuristic estimate to the goal in this case """ node = cla.Node(problem.initialState, None, None) frontier = [] frontier.append(node) #explored set is an unordered collection with no duplicate elements. explored = set() while frontier: node = frontier.pop() if problem.checkGoal( node.state): # return the end state if goal is reached return node explored.add(node.stringBoard) # otherwise add it to the explored set for child in node.expand(problem): #if child.stringBoard not in explored and child not in frontier: # add child to frontier if not there or in explored if child.stringBoard not in explored: #here we loop through frontier and look for the board foundState = False #this will stop iterating through the frontier currentState = None #this is a copy of the current node iterFrontier = 0 #this saves where the node is in the frontier so it can be deleted later for frontNode in frontier: if (frontNode.stringBoard == child.stringBoard): #print("Found the board in frontier") #print("frontNode.stringboard:", frontNode.stringBoard) #print("iterFrontier:", iterFrontier) foundState = True currentState = frontNode break iterFrontier += 1 #if the board is not in the frontier if foundState == False: #f applies the heuristic + pathcost and adds this value to the node class. f(x) = g(x) + h(x) problem.f(child) frontier.append(child) frontier.sort( key=lambda x: x.fValue, reverse=True ) #this should sort the list in order of small to large heuristic value else: # if the state was already in the frontier, then check the heuristic value #print("Already in the frontier, looking to change val") if child.fValue < currentState.fValue: #print('better option found') #del frontier[currentState] #? does not delete this node. need to iterate through frontier del frontier[ iterFrontier] #proper way of deleting the node from the frontier frontier.append(child) frontier.sort( key=lambda x: x.fValue, reverse=True ) #this should sort the list in order of small to large heuristic value # if already explored do nothing return None
def p_arg_types(p): '''arg_types : type arg_types2''' p[0] = c.Node('arg-types', [p[1], p[2]])
def p_operation(p): 'operation : identifier' p[0] = c.Node('operation', [p[1]])
def p_operation_spec(p): '''operation_spec : operation COLON operation_spec2''' p[0] = c.Node('operation-spec', [p[1], p[3]])
def p_operation_specs(p): '''operation_specs : operation_spec operation_specs2''' p[0] = c.Node('operation-specs', [p[1], p[2]])
def p_signature(p): 'signature : ADT typename operation_specs' p[0] = c.Node('signature', [p[2], p[3]])
def p_signatures(p): '''signatures : signature signatures2''' p[0] = c.Node('signatures', [p[1], p[2]])