def add_states_toQ(states, Q_table) : array = [ms.Multiset(states["hands"]), ms.Multiset(states["fields"]), ms.Multiset(states["cemetary"])] array += [0]*(Q_table.shape[1]-3) s = pd.Series(array, index=Q_table.columns) Q_table = Q_table.append(s, ignore_index=True) return(Q_table)
def evaluate_reconstruction_accuracy(padded_true_batch_first, padded_suggestions_seq_first, tb_write=None): total_elems = 0 total_bags = padded_true_batch_first.shape[0] matched_elems = 0 matched_bags = 0 table_rows = ['| True | Predicted | '] for true_elems, suggested_elems in zip( padded_true_batch_first.cpu().numpy(), padded_suggestions_seq_first.cpu().numpy().T): true_elems = multiset.Multiset( true_elems[true_elems != mchef_config.PAD_VALUE].tolist()) suggested_elems = multiset.Multiset(suggested_elems[ suggested_elems != mchef_config.PAD_VALUE].tolist()) table_rows.append('| ' + ' | '.join([ ','.join(map(str, true_elems)), ','.join(map(str, suggested_elems)) ]) + '| ') total_elems += len(true_elems) matched_bags += int(true_elems == suggested_elems) matched_elems += len(true_elems.intersection(suggested_elems)) if tb_write is not None: tb_write.add_text('Reconstruction Results', '\n'.join(table_rows)) return float(matched_bags) / total_bags, float(matched_elems) / total_elems
def _rst_parseval(preds, golds): """ :type preds: list of list of (int, int, str, str) :type golds: list of list of (int, int, str, str) :rtype: {str: {str: Any}} """ assert len(preds) == len(golds) scores = {} # {str: {str: Any}} total_ok_dict = {} total_pred_dict = {} total_gold_dict = {} for key in ["S", "S+N", "S+R", "S+N+R"]: total_ok_dict[key] = 0.0 total_pred_dict[key] = 0.0 total_gold_dict[key] = 0.0 for pred_spans, gold_spans in zip(preds, golds): pred_spans_dict = {} gold_spans_dict = {} pred_spans_dict["S"] = [(b, e) for b, e, r, n in pred_spans] gold_spans_dict["S"] = [(b, e) for b, e, r, n in gold_spans] pred_spans_dict["S+N"] = [(b, e, n) for b, e, r, n in pred_spans] gold_spans_dict["S+N"] = [(b, e, n) for b, e, r, n in gold_spans] pred_spans_dict["S+R"] = [(b, e, r) for b, e, r, n in pred_spans] gold_spans_dict["S+R"] = [(b, e, r) for b, e, r, n in gold_spans] pred_spans_dict["S+N+R"] = pred_spans gold_spans_dict["S+N+R"] = gold_spans for key in ["S", "S+N", "S+R", "S+N+R"]: a = multiset.Multiset(pred_spans_dict[key]) b = multiset.Multiset(gold_spans_dict[key]) n_ok = float(len(a & b)) n_pred = float(len(a)) n_gold = float(len(b)) total_ok_dict[key] += n_ok total_pred_dict[key] += n_pred total_gold_dict[key] += n_gold for key in ["S", "S+N", "S+R", "S+N+R"]: precision = float(total_ok_dict[key]) / float(total_pred_dict[key]) recall = float(total_ok_dict[key]) / float(total_gold_dict[key]) f1 = (2 * precision * recall) / (precision + recall) precision_info = "%d/%d" % (total_ok_dict[key], total_pred_dict[key]) recall_info = "%d/%d" % (total_ok_dict[key], total_gold_dict[key]) scores[key] = { "Precision": precision, "Recall": recall, "Micro F1": f1, "Precision_info": precision_info, "Recall_info": recall_info } return scores
def computeOperonDifferences(operon1, operon2): set1 = multiset.Multiset() set2 = multiset.Multiset() for op in operon1: set1.add(op.split('_')[0].strip()) for op in operon2: set2.add(op.split('_')[0].strip()) set3 = set1.symmetric_difference(set2) return len(set3)
def extract_distributions(data, max_imgs=conf.MAX_LOADED_IMAGES): log = section_logger(1) log('Extracting distributions ') global_objects = ms.Multiset() occurrences = ms.Multiset() images = [] for i, image in enumerate(data['objects']): if i > max_imgs: break if not check_image_exists(image['image_id']): print('Skipping unexistent image: {}.jpg'.format( image['image_id'])) if i % 25 == 0: log("Processing image {}".format(i)) image_objs = {} image_objs['id'] = image['image_id'] objs = ms.Multiset() objs_pd = {} total = 0 appeared = set() for j, obj in enumerate(image['objects']): if len(obj['names']) > 0: obj_name = obj['names'][0] obj_name = simplify(obj_name) if len(obj_name.strip()) == 0: continue total += 1 appeared.add(obj_name) global_objects.add(obj_name) objs.add(obj_name) for obj in appeared: occurrences.add(obj) for key in objs.distinct_elements(): objs_pd[key] = objs.get(key, 0) / total image_objs['pds'] = objs_pd images.append(image_objs) return global_objects, occurrences, images
def generateMutliProcessorConfigDFS(prevMultiConfig, prevProcessorIdx, L1Epsilon, VEpsilon): configsToReturn = [] if multiset.Multiset( tuple(prevMultiConfig)) in testedMultiProcessorConfigs: # print('here ', prevMultiConfig) return configsToReturn # return if we have reached the max length of the multiprocessor config if prevProcessorIdx == NUM_PROCESSORS - 1: # print('here 2 ', prevMultiConfig) return configsToReturn for i in range(len(L1Epsilon)): currentMultiConfig = prevMultiConfig.copy() currentIdx = prevProcessorIdx + 1 currentMultiConfig[currentIdx] = i # print(currentMultiConfig) configs = None currentUtilization = getMultiProcessorUtilization( currentMultiConfig, L1Epsilon, VEpsilon) if currentUtilization < NUM_PROCESSORS: if currentMultiConfig[-1] != -1: testedMultiProcessorConfigs.append( multiset.Multiset(tuple(currentMultiConfig))) configsToReturn.append(currentMultiConfig) else: configs = generateMutliProcessorConfigDFS( currentMultiConfig, currentIdx, L1Epsilon, VEpsilon) if len(configs) == 0: configsToReturn.append(currentMultiConfig) continue for i in range(len(configs)): # if getSingleProcessorUtilization(configs[i], VEpsilon) > 1 - EPSILON: if -1 not in configs[i]: configsToReturn.append(configs[i]) # configsToReturn.append(configs[i]) elif currentUtilization == NUM_PROCESSORS: configsToReturn.append(currentMultiConfig) testedMultiProcessorConfigs.append( multiset.Multiset(tuple(prevMultiConfig))) return configsToReturn
def existed_state(states, Q_table) : hands = ms.Multiset(states["hands"]) fields = ms.Multiset(states["fields"]) cemetary = ms.Multiset(states["cemetary"]) cond = f"hands=='{hands}'" cond += f" & fields=='{fields}'" cond += f" & cemetary=='{cemetary}'" tf = (Q_table.hands == hands) * (Q_table.fields == fields) * (Q_table.cemetary == cemetary) if tf.sum() == 0 : return(False) else : ind = Q_table.index[tf.values][0] return(ind)
def test_score_all(self): cases = { '111111': (8000, ''), '234662': (0, '662234'), '222221': (900, ''), '444235': (450, '32'), '111222': (1200, ''), '115234': (250, '234'), '111554': (1100, '4'), '152346': (150, '2346') } for score in cases.keys(): mset = ms.Multiset(score) self.assertEqual(game.score_all(mset), (cases[score][0], ms.Multiset(cases[score][1])))
def __init__(self, spiel): pos = self.leadenPos() waren = multiset.Multiset(['honig', 'mandeln', 'orangen']) self.oase = Laden.Laden("oase", waren, 2, pos[0]) waren = multiset.Multiset(['feigen', 'datteln', 'minze']) self.garten = Laden.Laden("garten", waren, 2, pos[1]) waren = multiset.Multiset(['ring', 'halskette', 'ohrringe']) self.juwelier = Laden.Laden("juwelier", waren, 3, pos[2]) waren = multiset.Multiset(['wolle', 'seide', 'leder']) self.faerberei = Laden.Laden("faerberei", waren, 3, pos[3]) self.leaden = [self.oase, self.garten, self.juwelier, self.faerberei] pos = self.stadtPos() stadt0 = Stadt.Stadt(pos[0], spiel) stadt1 = Stadt.Stadt(pos[1], spiel) stadt2 = Stadt.Stadt(pos[2], spiel) stadt3 = Stadt.Stadt(pos[3], spiel) self.staedte = [stadt0, stadt1, stadt2, stadt3] self.gebirge = [] positionenKategorieA = [(2, 0), (7, 0), (2, 3)] random.shuffle(positionenKategorieA) for i in range(0, 3): self.gebirge.append( Gebirge.Gebirge(i + 1, self.offset_to_cube(positionenKategorieA[i]))) positionenKategorieB = [(1, 7), (6, 7), (6, 4)] random.shuffle(positionenKategorieB) for i in range(0, 3): self.gebirge.append( Gebirge.Gebirge(i + 4, self.offset_to_cube(positionenKategorieB[i]))) positionenKategorieC = [(3, 0), (4, 3), (7, 4), (4, 5), (2, 7)] random.shuffle(positionenKategorieC) for i in range(0, 5): self.gebirge.append( Gebirge.Gebirge(i + 7, self.offset_to_cube(positionenKategorieC[i]))) positionenKategorieD = [(5, 1), (3, 3), (1, 4), (3, 5), (5, 8)] random.shuffle(positionenKategorieD) for i in range(0, 5): self.gebirge.append( Gebirge.Gebirge(i + 12, self.offset_to_cube(positionenKategorieD[i])))
def intersection(self, other): ''' (SkipList Object, SkipList Object) --> (SkipList Object) Given a SkipList (self) and another SkipList object (other), return a third SkipList Object that resembles the insersection of self and other. ''' import multiset #create an empty skiplist temp = multiset.Multiset() #record start values of each skiplist node = self.start node2 = other.start #check None cases if (node or node2) == None: return (temp) #move both nodes to the last row while (node.bot_link != None): node = node.bot_link while (node2.bot_link != None): node2 = node2.bot_link #loop through the values in the row of the first node while ((node.next_link.data) != None): val = node.next_link.data #count the amount of the values which are shared count = node.find_val(val) count2 = node2.find_val(val) if count > count2: for i in range(0, count2): temp.inserter(val) elif ((count < count2) and (count2 != 0)): for i in range(0, count): temp.inserter(val) return temp
def get_console_bag_for_dir(directory: Optional[str]) -> multiset.Multiset: bag = multiset.Multiset() for graph in graphs_in_dir(directory): try: node_types = nx.get_node_attributes(graph, "node type") console_node_candidates = [ k for k, v in node_types.items() if v == "web API" and graph.nodes[k].get("method") == "console.log" ] if console_node_candidates: cln = console_node_candidates[0] for u, v, eid, args in graph.in_edges(cln, data="args", keys=True): if args: jargs = json.loads(args) url = jargs.get("location", {}).get("url") if url: bits = urlparse(url) hostname = bits.hostname upath = bits.path else: hostname = upath = None bag.add( ConsoleTuple( jargs.get("source"), jargs.get("level"), get_sld(hostname) if hostname else None, upath, )) except: logger.exception( f"error processing graph in {directory} (skipping)") return bag
def update_multisets(self): multiset = {} for node in self.graph.nodes: multiset[node] = m.Multiset() for neighbor in nx.all_neighbors(self.graph, node): multiset[node].add(self.graph.nodes[neighbor]["wl_colour"]) pass nx.set_node_attributes(self.graph, multiset, "neighbour_multiset")
def __init__(self, freq, period): self.frequency = freq self.period = period self.next_scan_time_by_iface = {} self.next_scan_time = 0 self.do_not_retry_before = {} self.interfaces = multiset.Multiset() self.last_hit = 0
def set_initial_multiset(self, g): multiset = {} for node in g.nodes: multiset[node] = m.Multiset() for neighbor in nx.all_neighbors(g, node): multiset[node].add(g.nodes[neighbor]["wl_colour"]) pass nx.set_node_attributes(g, multiset, "neighbour_multiset") return g
def compute_tree_distance(spans1, spans2, coef): """ :type spans1: list of (int, int) :type spans2: list of (int, int) :type coef: float :rtype: float """ assert len(spans1) == len(spans2) spans1 = multiset.Multiset(spans1) spans2 = multiset.Multiset(spans2) assert len(spans1) == len(spans2) dist = len(spans1) - len(spans1 & spans2) dist = float(dist) dist = coef * dist return dist
def get_request_bag_for_dir(dirname: Optional[str]) -> multiset.Multiset: bag_map = multiset.Multiset() for graph in find_3p_nonad_graphs(dirname): resource_nodes = [k for k, v in nx.get_node_attributes(graph, "node type").items() if v == "resource"] for k, v in nx.get_node_attributes(graph, "node type").items(): if v == 'resource': url_fields = urlparse(graph.nodes[k]["url"]) etld1 = get_sld(url_fields.hostname) bag_map.update((etld1, rt) for n1, n2, eid, rt in graph.in_edges(k, data="request type", keys=True)) return bag_map
def get_node_bag_for_dir(dirname: Optional[str]) -> multiset.Multiset: bag_map = multiset.Multiset() for graph in find_3p_nonad_graphs(dirname): node_types = nx.get_node_attributes(graph, "node type") html_nodes = [ graph.nodes[k].get("tag name") for k, v in node_types.items() if v == "HTML element" ] bag_map.update(Counter(html_nodes)) return bag_map
def fitness(lst): masked = list(itr.compress(wts, lst)) msum = sum(masked) lstms = ms.Multiset(masked) for m in ans: if m.issubset(lstms): return msum return (maxsum + 1)
def __init__(self, name, position, spiel): self.name = name self.bedarfe = [] self.position = position self.spiel = spiel self.weitenWuerfel = Wuerfel.Wuerfel("W6") self.hoehenWuerfel = Wuerfel.Wuerfel("W4") self.bewegungspunkte = 0 self.flughoehe = 0 self.inventory = multiset.Multiset() self.geld = 15 self.letzterZug = [] ki = Ki.Ki(self, spiel) print("erstelle Spieler: ", self.name, "in", self.position)
def bedarfMachbar(self, bedarf): gesamteAuslage = multiset.Multiset() for laden in self.spielfeld.leaden: for ware in laden.auslage: gesamteAuslage.add(ware) for ware in self.spieler.inventory: gesamteAuslage.add(ware) for ware in bedarf.waren: if not self.wareMachbar(ware, gesamteAuslage): # print("nicht machbar:",bedarf,"es fehlt:",ware) return False return True
def output_mapper(dict_in): prediction_tokenized = dict_in['tgt'] prediction = MolTransformerTokenizer.from_tokens(prediction_tokenized) prediction_split = prediction.split('.') pred_res = [] for smi in prediction_split: try: pred_res.append(rdkit_general_ops.canconicalize(smi)) except Exception: pass pred_res = pred_res[:1] out = multiset.Multiset(pred_res) return out
def formatAndComputeOperonDifferences(operon1, operon2): noDuplicatesSet1 = set() noDuplicatesSet2 = set() set1 = multiset.Multiset() set2 = multiset.Multiset() operon1 = operon1.replace('-', '') operon1 = operon1.replace('[', '') operon1 = operon1.replace(']', '') operon2 = operon2.replace('-', '') operon2 = operon2.replace('[', '') operon2 = operon2.replace(']', '') operon1List = operon1.split(',') operon2List = operon2.split(',') noWhiteSpaceOperon1List = [] noWhiteSpaceOperon2List = [] for op in operon1List: set1.add(op.split('_')[0].strip()) noDuplicatesSet1.add(op.split('_')[0].strip()) noWhiteSpaceOperon1List.append(op.strip()) for op in operon2List: set2.add(op.split('_')[0].strip()) noDuplicatesSet2.add(op.split('_')[0].strip()) noWhiteSpaceOperon2List.append(op.strip()) set3 = set1.symmetric_difference(set2) noDuplicatesSet3 = noDuplicatesSet1.symmetric_difference(noDuplicatesSet2) return len(set3), noWhiteSpaceOperon1List, noWhiteSpaceOperon2List, len( noDuplicatesSet3)
def game_full(): dice = roll() print(dice) score, d = score_all(dice) print('score: ' + str(score)) if score == 0: print('round score: 0') return 0 while True: s = 0 case = input() if case == 'stop': score += s break elif case == 'fix': print('enter dices: ', end='') inp = input() bad_select = False # TODO rewrite all input checks with exceptions for i in inp: if i not in dice.difference(d): bad_select = True break if bad_select: print('bad input, after "fix" you must enter dice with value!') continue fix = ms.Multiset(inp) dice.difference_update(fix) s = score_all(fix)[0] print('fixed: ' + str(fix)) if len(dice) == 0: dice = roll() else: dice = roll(len(dice)) print(dice) s, d = score_all(dice) if s == 0: score = 0 print('fire!') break else: print('score: ' + str(s)) score += s else: print('bad input, use: "fix" or "stop" command') print('round score: ' + str(score)) return score
def is_expected_legal_notices(self, legal_notices_path): """ :param legal_notices_path: Path to legal notices Return True if legal notices are as expected, otherwise assert. :return: True if legal notices are as expected """ default_legal_notices = set(self._config["DEFAULT"]["legal_notices"].split()) legal_notices = multiset.Multiset(self._config[self.product_type]["legal_notices"].split()) legal_notices += default_legal_notices stdout, stderr = kubectl.exec(' '.join([self.name, '-- ls -R ' + legal_notices_path])) for line in stdout: logger.debug('Found legal notice ' + self.name) if line: legal_notices.remove(line, 1) assert len(legal_notices) == 0, 'Did not find all legal notices' return True
def combine_list(self, other): ''' (SkipList Object, SkipList Object) --> SkipList Object Given two SkipLists self and other, return a third SkipList object which contains a union of the node values of each SkipList. ''' import multiset #create new SkipList temp = multiset.Multiset() #indetify start points node = self.start node2 = other.start #check nodes empty, break early dependingly if ((node and node2) == None): return temp elif ((node == None) and (node2 != None)): temp.start = other.start temp.end = other.end return temp elif ((node2 == None) and (node != None)): temp.start = self.start temp.end = self.end return temp #both nodes non-empty #move both nodes to the last row while (node.bot_link != None): node = node.bot_link while (node2.bot_link != None): node2 = node2.bot_link #loop through the first row of the node while ((node.next_link.data) != None): val = (node.next_link.data) #insert first lists values into temp temp.inserter(val) node = node.next_link #loop through the second node's row while ((node2.next_link.data) != None): val = (node2.next_link.data) #insert second list values into temp temp.inserter(val) node2 = node2.next_link return temp
def remove_shared(self, other): ''' (SkipList Object, SkipList Object) --> (SkipList Object) Take all values in the first SkipList (self), and remove the ones that are shared in the second SkipList(other). Returns a SkipList object ''' import multiset node = self.start node2 = other.start #create a new skiplist temp = multiset.Multiset() #exit early in special cases where either node or node2 is None if node == None: return temp elif node2 == None: return self #move both nodes to the last row while (node.bot_link != None): node = node.bot_link while (node2.bot_link != None): node = node.bot_link #check row values in first node is contained by second row while ((node.next_link.data) != None): #count how many of the same value the first skip list contains val = (node.next_link.data) count = node.find_val(val) count2 = node2.find_val(val) if (count > count2): #insert the data into the skip list iterations = (count - count2) for i in range(0, interations): temp.inserter(val) elif (count == 0): #insert the data into the skip list temp.inserter(val) node = node.next_link return (temp)
def _old_rst_parseval(preds, golds, input_lengths): """ :type preds: list of list of (int, int, str, str) :type golds: list of list of (int, int, str, str) :type input_lengths: list of int :rtype: {str: {str: Any}} """ assert len(preds) == len(golds) == len(input_lengths) scores = {} # {str: {str: Any}} total_ok_dict = {} total_pred_dict = {} total_gold_dict = {} for key in ["S", "S+N", "S+R", "S+N+R"]: total_ok_dict[key] = 0.0 total_pred_dict[key] = 0.0 total_gold_dict[key] = 0.0 for pred_spans, gold_spans, input_length in zip(preds, golds, input_lengths): pred_spans_dict = {} gold_spans_dict = {} pred_spans_dict["S"] = [(b, e) for b, e, r, n in pred_spans] gold_spans_dict["S"] = [(b, e) for b, e, r, n in gold_spans] pred_spans_dict["S+N"] = [(b, e, n) for b, e, r, n in pred_spans] gold_spans_dict["S+N"] = [(b, e, n) for b, e, r, n in gold_spans] pred_spans_dict["S+R"] = [(b, e, r) for b, e, r, n in pred_spans] gold_spans_dict["S+R"] = [(b, e, r) for b, e, r, n in gold_spans] pred_spans_dict["S+N+R"] = pred_spans gold_spans_dict["S+N+R"] = gold_spans for key in ["S", "S+N", "S+R", "S+N+R"]: a = multiset.Multiset(pred_spans_dict[key]) b = multiset.Multiset(gold_spans_dict[key]) n_ok = float(len(a & b)) n_pred = float(len(a)) n_gold = float(len(b)) # NOTE: Pre-terminal spans (i.e., spans of length=1) cannot be incorrect in unlabeled constituency metrics if key == "S": n_ok += input_length n_pred += input_length n_gold += input_length total_ok_dict[key] += n_ok total_pred_dict[key] += n_pred total_gold_dict[key] += n_gold for key in ["S", "S+N", "S+R", "S+N+R"]: precision = float(total_ok_dict[key]) / float(total_pred_dict[key]) recall = float(total_ok_dict[key]) / float(total_gold_dict[key]) f1 = (2 * precision * recall) / (precision + recall) precision_info = "%d/%d" % (total_ok_dict[key], total_pred_dict[key]) recall_info = "%d/%d" % (total_ok_dict[key], total_gold_dict[key]) scores[key] = { "Precision": precision, "Recall": recall, "Micro F1": f1, "Precision_info": precision_info, "Recall_info": recall_info } return scores
def __init__(self, roll=[]): ''' Initializes a roll to the given list ''' self.dice = mset.Multiset(roll)
new_states = get_states() Q_table = renew_Q(best_action, prev_val, Q_table, original_states, new_states) tf = not(complete_exodia() or len(decks) == 0 or j >= 30) j += 1 Q_tables.append(Q_table) except : pass print(n_success) Q_table.sum() Q_table.shape sum(Q_table.hands == ms.Multiset(["チキン・レース", "テラ・フォーミング", "チキン・レース", "成金ゴブリン", "封印されしエグゾディア"])) Q_table.loc[Q_table.hands == ms.Multiset(["チキン・レース", "テラ・フォーミング", "チキン・レース", "成金ゴブリン", "封印されしエグゾディア"]), :] Q_table.drop(columns=["hands", "fields", "cemetary"]).sum(axis=1).sort_values() Q_table.iloc[2491,]["hands"] Q_table.iloc[690,]["hands"] Q_table.iloc[1422,]["hands"] Q_table.iloc[4153,] Q_table.iloc[56, ] Q_table.query("テラ・フォーミング >= 10") Q_table[Q_table["テラ・フォーミング"]>=10] #### Duel simulation duel = Duel()
def roll(dice_count=6): diceset = '' for i in range(dice_count): diceset += str(rnd.randint(1, 6)) return ms.Multiset(diceset)